使用Dockerfile构建一个包含NVIDIA的PyTorch和Detectron2的镜像

查看Dockerfile

以下是详细的解释：

# 使用更具体的标记来固定基础镜像版本，确保环境一致性
FROM nvcr.io/nvidia/pytorch:23.01-py3

# 设置工作目录和环境变量
WORKDIR /root
ENV DETECTRON2_PATH /root/detectron2

# 复制并安装 Detectron2
COPY detectron2 $DETECTRON2_PATH
RUN pip install --no-cache-dir -e $DETECTRON2_PATH

# 设置入口命令
CMD ["bash"]

这个Dockerfile定义了构建一个基于NVIDIA的PyTorch镜像的开发环境，同时安装和配置Detectron2。让我们逐行解析这个Dockerfile：

1. 基础镜像：

   # 使用更具体的标记来固定基础镜像版本，确保环境一致性
   FROM nvcr.io/nvidia/pytorch:23.01-py3
   

   • FROM 指令指定了构建这个镜像所基于的基础镜像。
   • 在这里，基础镜像来自 nvcr.io/nvidia/pytorch，版本为 23.01-py3。这意味着已经安装了PyTorch的NVIDIA优化版，且基于Python 3。

2. 设置工作目录和环境变量：

   # 设置工作目录和环境变量
   WORKDIR /root
   ENV DETECTRON2_PATH /root/detectron2
   

   • WORKDIR /root：设置工作目录为 /root。后续的所有命令都会在这个目录下执行。
   • ENV DETECTRON2_PATH /root/detectron2：定义一个环境变量 DETECTRON2_PATH，其值为 /root/detectron2，方便在后续命令中引用这个路径。

3. 复制并安装 Detectron2：

   # 复制并安装 Detectron2
   COPY detectron2 $DETECTRON2_PATH
   RUN pip install --no-cache-dir -e $DETECTRON2_PATH
   

   • COPY detectron2 $DETECTRON2_PATH：将本地主机的 detectron2 目录复制到镜像内部的 $DETECTRON2_PATH（即 /root/detectron2）目录下。
   • RUN pip install --no-cache-dir -e $DETECTRON2_PATH：运行 pip install 命令以“可编辑模式”安装 detectron2。--no-cache-dir 选项用于避免pip缓存安装包，以减少镜像体积。

4. 设置入口命令：

   # 设置入口命令
   CMD ["bash"]
   

   • CMD ["bash"]：指定容器启动时的默认命令，这里是启动一个Bash shell。这使得容器在启动后进入Bash环境，用户可以在这个环境中继续运行其他命令。

综述：

• 基础镜像：选择了一个已经包含PyTorch的镜像，减少了安装PyTorch的时间。
• 工作目录：设置为 /root，简化路径配置。
• 环境变量：增加了灵活性和可读性。
• 复制文件：将本地的 detectron2 目录复制到镜像中。
• 安装Detectron2：确保应用在容器中可以运行。
• 入口命令：启动时默认进入Bash shell，便于进一步交互和开发。

通过这些步骤，这个Dockerfile创建了一个既包含PyTorch又配置了Detectron2的开发环境，使得用户可以在容器内进行计算机视觉的开发和实验。

构建Docker镜像

这段内容展示了构建一个Docker镜像的过程，并且执行了一些相关的命令。通过逐行分析可以更好地了解发生了什么。

1. 查看构建目录内容：

   [root@cityvisual-gpu011162126120 docker]# ls
   detectron2  Dockerfile
   

   • 这里显示当前目录下有两个项：一个是detectron2目录，另一个是Dockerfile文件。

2. 构建镜像命令：

   [root@cityvisual-gpu011162126120 docker]# docker build -t detectron2_env .
   

   • 使用docker build命令来构建Docker镜像。
   • -t detectron2_env：指定新镜像的标签为detectron2_env。
   • .：指定构建上下文为当前目录，包含Dockerfile和detectron2子目录。

3. 镜像构建过程：

   • Step 1/5：选择基础镜像

     Step 1/5 : FROM nvcr.io/nvidia/pytorch:23.01-py3
      ---> 9eda6061497d
     

     • 选择nvcr.io/nvidia/pytorch:23.01-py3作为基础镜像。

   • Step 2/5：复制detectron2目录

     Step 2/5 : COPY detectron2 /root/detectron2
      ---> 9c46a77f6793
     

     • 将本地的detectron2目录复制到镜像内的/root/detectron2目录。

   • Step 3/5：安装detectron2

     Step 3/5 : RUN pip install -e /root/detectron2
      ---> Running in 996c4b8eb01d
     

     • 在镜像内以可编辑模式安装detectron2库。
     • 输出显示了安装过程中下载和安装的依赖包，如pycocotools, termcolor, yacs, tabulate, fvcore, iopath, omegaconf, hydra-core, black等。
     • 安装完成，并成功构建了必要的wheel文件。

     Successfully installed antlr4-python3-runtime-4.9.3 black-24.4.2 detectron2-0.6 fvcore-0.1.5.post20221221 hydra-core-1.3.2 iopath-0.1.9 mypy-extensions-1.0.0 omegaconf-2.3.0 pathspec-0.12.1 portalocker-2.10.1 pycocotools-2.0.7 tabulate-0.9.0 termcolor-2.4.0 yacs-0.1.8
     

     • 有两个警告：
       • 建议使用虚拟环境。
       • 建议升级pip。

     WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
     WARNING: You are using pip version 21.2.4; however, version 24.2 is available.
     You should consider upgrading via the '/usr/bin/python -m pip install --upgrade pip' command.
     

   • Step 4/5：设置工作目录

     Step 4/5 : WORKDIR /root
      ---> Running in ac297733d7cb
     

     • 设置工作目录为/root。

   • Step 5/5：设置入口命令

     Step 5/5 : CMD ["bash"]
      ---> Running in a245bd0213c6
     

     • 设置默认入口命令为bash，即启动容器时进入Bash shell。

   • 镜像构建成功

     Successfully built aafcb4714270
     Successfully tagged detectron2_env:latest
     

     • 镜像成功构建并打上了标签detectron2_env:latest。

4. 查看Docker镜像

   [root@cityvisual-gpu011162126120 docker]# docker images
   

   • 列出了当前系统中的Docker镜像。

   REPOSITORY               TAG                              IMAGE ID       CREATED          SIZE
   detectron2_env           latest                           aafcb4714270   42 minutes ago   20.7GB
                                                 3f45d1c9166a   2 days ago       20.7GB
   nvcr.io/nvidia/pytorch   20.12-py3                        f59272c7f361   2 months ago     15.2GB
                                                 4f31e57b31d2   2 months ago     15.1GB
   cuda                     10.2-devel-ubuntu18.04-compile   a8f1a999f299   3 months ago     4.6GB
   nvcr.io/nvidia/pytorch   23.01-py3                        9eda6061497d   18 months ago    20.5GB
   nvcr.io/nvidia/pytorch                              ad0f29ddeb63   3 years ago      14.2GB
   

   • 可以看到多个镜像，包括刚刚构建的detectron2_env:latest（IMAGE ID为aafcb4714270，大小为20.7GB）。

5. 保存Docker镜像为文件

   [root@cityvisual-gpu011162126120 docker]# docker save -o detectron2_env.tar detectron2_env:latest
   

   • 使用docker save命令将镜像保存为一个tar文件，文件名为detectron2_env.tar，来源镜像为detectron2_env:latest。

6. 查看目录内容

   [root@cityvisual-gpu011162126120 docker]# ls
   

   • 列出当前目录内容，显示新增了detectron2_env.tar文件。

   detectron2  detectron2_env.tar  Dockerfile
   

   • 现在目录中有三个项：detectron2（目录），detectron2_env.tar（镜像文件）和Dockerfile。

总结

• 构建镜像：基于指定的Dockerfile和上下文（包括detectron2目录），构建并标签为detectron2_env。
• 查看镜像：构建成功的镜像大小为20.7GB。
• 保存镜像：将镜像保存为detectron2_env.tar文件，便于分发和备份。

这样通过这些步骤，用户可以构建、查看和保存一个包含Detectron2的Docker镜像。这个过程详细展示了每一步的执行和输出，对于理解Docker操作和镜像管理具有很好的参考价值。

这一段内容说明了如何使用docker run命令来启动一个包含Detectron2环境的Docker容器，并查看正在运行的容器。以下是详细解析：

启动Docker容器

1. 启动命令：

   docker run --gpus all -d --name detectron2_env -v /data/dw/Detectron2:/liveguard -w /liveguard detectron2_env:latest   tail -f /dev/null
   

   • docker run：运行一个新的容器。

   • --gpus all：启用容器对GPU的访问，这里表示让容器能够使用所有的GPU。这个参数要求Docker支持GPU加速。

   • -d：表示以后台模式运行容器。

   • --name detectron2_env：为新的容器指定一个名字为detectron2_env。

   • -v /data/dw/Detectron2:/liveguard：将本地目录/data/dw/Detectron2挂载到容器内的/liveguard目录。这样，主机上的数据可以直接在容器中访问，并与容器内的软件共享。

   • -w /liveguard：设置容器的工作目录为/liveguard，即运行任何命令之前将该目录作为当前目录。

   • detectron2_env:latest：指定要运行的镜像，这里是之前构建并标记为latest版本的detectron2_env镜像。

   • tail -f /dev/null：在容器中运行阻塞命令tail -f /dev/null，保持容器持续运行。这是一种保持容器“活着”的简单方法，特别是当没有其他长时间运行的命令时。

查看正在运行的容器

2. 查看容器状态：

   [root@cityvisual-gpu011162126120 Detectron2]# docker ps
   

   • docker ps：显示当前正在运行的容器。

   • 输出内容如下：

     CONTAINER ID   IMAGE                COMMAND                   CREATED          STATUS          PORTS                   NAMES
     a7863c2c7604   detectron2_env:latest "/opt/nvidia/nvidia_…"   10 minutes ago   Up 10 minutes   6006/tcp, 8888/tcp      detectron2_env
     

   • 解析：

     • CONTAINER ID：容器的唯一标识符，例如a7863c2c7604。
     • IMAGE：容器使用的镜像名称，这里是detectron2_env:latest。
     • COMMAND：容器中正在运行的命令，在这里显示为简略的命令"/opt/nvidia/nvidia_…"。
     • CREATED：容器创建的时间，这里是10 minutes ago。
     • STATUS：容器的状态，这里是Up 10 minutes，表示容器已运行10分钟。
     • PORTS：容器暴露的端口，这里显示为6006/tcp, 8888/tcp，但没有映射到主机的端口。
     • NAMES：容器的名称，这里是detectron2_env，与启动容器时指定的名称一致。

总结

• docker run命令：启动了一个新的容器，并启用了GPU支持，以后台模式运行，并指定了容器名称、目录挂载和初始工作目录。

• docker ps命令：显示了当前正在运行的容器及其相关信息，包括容器ID、镜像、命令、创建时间、状态、暴露端口和名称。

通过这些操作，用户已经成功启动并管理一个包含Detectron2环境的Docker容器，并能够通过挂载的目录在容器和主机之间共享数据。

这段内容展示了在一个运行中的Docker容器中执行一个Python脚本以进行图像推理的过程。以下是具体步骤的解析：

进入容器

1. 进入容器：

   docker exec -it detectron2_env bash
   

   • docker exec -it detectron2_env bash 让你进入名为 detectron2_env 的运行中的Docker容器，并启动交互式的Bash shell。

   进入容器后，你的提示符会变成容器内部的提示符，例如：

   root@a7863c2c7604:/liveguard#
   

   • 其中，a7863c2c7604 是容器的ID。当前工作目录是 /liveguard。

运行推理脚本

2. 运行Python推理脚本：

   python3 detectron2_inference.py --input ./input.jpg --output ./outputs/ --model-name COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml --cache-dir ./models/
   

   • 这条命令使用Python解释器 python3 来运行 detectron2_inference.py 脚本，并传递一些参数：
     • --input ./input.jpg：待处理的输入图像，路径为 ./input.jpg。
     • --output ./outputs/：处理后的输出结果将保存到 ./outputs/ 目录。
     • --model-name COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml：指定使用的模型配置，这里是COCO实例分割模型mask_rcnn_R_50_FPN_3x。
     • --cache-dir ./models/：指定模型缓存目录为 ./models/。

执行推理

3. 执行过程及输出：

   • 执行脚本时，检测到使用的设备是 cuda, 表示GPU加速。

   Using device: cuda
   

   • 脚本加载预训练模型：

   [08/01 10:44:53 d2.checkpoint.detection_checkpoint]: [DetectionCheckpointer] Loading from https://dl.fbaipublicfiles.com/detectron2/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl ...
   

   • 加载过程中，TORCH发出警告，提示未来版本中会需要传递 indexing 参数：

   /usr/local/lib/python3.8/dist-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/pytorch/pytorch/aten/src/ATen/native/TensorShape.cpp:3435.)
     return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]
   

   • 处理完成后，输出结果保存到指定位置：

   Output saved to ./outputs/input_mask_rcnn_R_50_FPN_3x.jpg
   

总结

• 进入容器：使用 docker exec -it detectron2_env bash 进入运行中的容器，并获得一个交互式终端。
• 运行推理脚本：在容器内运行 detectron2_inference.py 脚本，指定输入图像、输出目录、模型配置和缓存目录。
• 加载模型：从预定义的网址加载指定的COCO-Instance-Segmentation模型 mask_rcnn_R_50_FPN_3x。
• 进行处理：检测到使用GPU设备（CUDA），并发出一些预处理警告。
• 保存结果：处理完成后，输出结果图像保存在 ./outputs 目录。

这一步操作说明了如何在容器内部执行复杂的推理任务，并充分利用容器环境提供的依赖和库。这样，不仅可以确保一致的执行环境，还便于开发和调试机器学习模型。

有任何问题评论区留言

测试代码

这个代码是一个用于图像推理的脚本，使用Detectron2库进行图像实例分割、目标检测等任务。

# 导入必要的库
import argparse
import cv2
import os
import torch
from detectron2.utils.logger import setup_logger
from detectron2 import model_zoo
from detectron2.engine import DefaultPredictor
from detectron2.config import get_cfg
from detectron2.utils.visualizer import Visualizer
from detectron2.data import MetadataCatalog

# 定义主函数
def main(args):
    # 初始化日志记录器
    setup_logger()

    # 设置FVCORE_CACHE环境变量
    os.makedirs(args.cache_dir, exist_ok=True)
    os.environ["FVCORE_CACHE"] = args.cache_dir

    # 检查设备（CPU或CUDA）
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print(f"Using device: {device}")

    # 加载输入图像
    im = cv2.imread(args.input)

    # 创建配置
    cfg = get_cfg()
    cfg.merge_from_file(model_zoo.get_config_file(args.model_name))
    cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5  # 设置置信度阈值
    cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(args.model_name)  # 加载模型权重
    cfg.MODEL.DEVICE = device  # 设置设备

    # 创建预测器
    predictor = DefaultPredictor(cfg)

    # 进行预测
    outputs = predictor(im)

    # 可视化预测结果
    v = Visualizer(im[:, :, ::-1],  # BGR到RGB转换
                   MetadataCatalog.get(cfg.DATASETS.TRAIN[0]), 
                   scale=1.2)
    out = v.draw_instance_predictions(outputs["instances"].to("cpu"))

    # 生成输出路径
    input_filename = os.path.splitext(os.path.basename(args.input))[0]
    model_filename = os.path.splitext(os.path.basename(args.model_name))[0]
    output_filename = f"{input_filename}_{model_filename}.jpg"
    output_path = os.path.join(args.output, output_filename)

    # 保存输出图像到文件
    output_image = out.get_image()[:, :, ::-1]  # RGB到BGR转换
    cv2.imwrite(output_path, output_image)

    print(f"Output saved to {output_path}")

# 如果脚本是直接执行（而不是作为模块导入），则运行下面的代码
if __name__ == "__main__":
    # 定义命令行参数解析器
    parser = argparse.ArgumentParser(
        description="Detectron2 Inference Script"
    )
    parser.add_argument("--input", required=True, help="Path to the input image")
    parser.add_argument("--output", required=True, help="Path to the output directory")
    parser.add_argument("--model-name", required=True, 
                        help="Name of the model in Detectron2 Model Zoo")
    parser.add_argument("--cache-dir", required=True, 
                        help="Path to the cache directory")
    
    # 解析命令行参数
    args = parser.parse_args()

    # 运行主函数
    main(args)

主要功能解释

1. 设置日志和缓存目录

• setup_logger(): 初始化日志记录，以便在控制台输出信息。
• os.environ["FVCORE_CACHE"] = args.cache_dir: 设置环境变量 FVCORE_CACHE 指向给定的缓存目录（如果目录不存在则创建）。

2. 检查计算设备

• 检测是否有CUDA支持，并使用GPU（如果可用）；否则使用CPU。

3. 加载和预处理输入图像

• 使用OpenCV（cv2）读取输入图像文件。

4. 创建和配置模型

• 使用Detectron2的 get_cfg() 和 model_zoo 配置文件来创建模型配置。
• 设置模型的阈值和权重路径。
• 将模型配置为在检测到的设备上运行。

5. 创建预测器并进行推理

• 使用 DefaultPredictor 创建基于配置的预测器。
• 使用预测器对输入图像进行推理。

6. 可视化和保存结果

• 使用 Visualizer 将预测结果绘制到输入图像上。
• 生成输出路径和文件名，并将可视化的输出图像保存到指定的输出目录。

7. 命令行参数解析和启动

• 使用 argparse 来解析命令行参数，确保输入图像路径、输出目录、模型名称和缓存目录都是必需的。
• 当脚本直接运行时，调用 main(args) 函数进行推理。

这个脚本的主要功能是读取一张输入图像，使用指定的检测模型进行实例分割或目标检测，并可视化和保存预测结果图像。通过命令行参数指定模型、输入和输出路径，使得脚本高度可配置和灵活，用于不同的检测任务和数据集上。

有任何问题评论区留言,更多应用体验查看下面内容

一键体验Detectron2框架中的所有预训练模型
在自定义数据集上训练现有的Detectron2模型