Empezar

Guía de inicio rápido de Docker para Ultralytics

Ultralytics Docker images on Docker Hub

Esta guía explica cómo configurar un entorno Docker para tus proyectos de Ultralytics. Docker es una plataforma para desarrollar, distribuir y ejecutar aplicaciones en contenedores, lo que garantiza que el software se ejecute de la misma manera independientemente de dónde se implemente.

Versión de la imagen Docker Descargas de Docker

Qué aprenderás#

  • Configurar Docker con compatibilidad con NVIDIA
  • Instalar imágenes Docker de Ultralytics
  • Ejecutar Ultralytics en un contenedor Docker con compatibilidad con CPU o GPU
  • Usar un servidor de pantalla con Docker para mostrar los resultados de detección de Ultralytics
  • Montar directorios locales en el contenedor


Ver: Cómo empezar a usar Docker | Demostración en directo del uso del paquete Ultralytics Python dentro de Docker 🎉

Requisitos previos#

  • Asegúrate de que Docker esté instalado en tu sistema. Si no lo está, puedes descargarlo e instalarlo desde el sitio web de Docker.
  • Para acelerar el procesamiento con GPU, asegúrate de que tu sistema tenga una GPU NVIDIA y los controladores NVIDIA instalados. Las imágenes para CPU no requieren hardware de NVIDIA.
  • Si utilizas dispositivos NVIDIA Jetson, asegúrate de tener instalada la versión adecuada de JetPack. Consulta la guía de NVIDIA Jetson para obtener más información.

Configurar Docker con compatibilidad con NVIDIA (opcional)#

Primero, comprueba que los controladores NVIDIA estén instalados correctamente ejecutando:

nvidia-smi

Instalar NVIDIA Container Toolkit#

Instala el NVIDIA Container Toolkit para habilitar la compatibilidad con GPU en contenedores Docker:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
  | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
    | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Actualiza las listas de paquetes e instala NVIDIA Container Toolkit:

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

Verificar dispositivos CDI con Docker#

Ejecuta nvidia-ctk cdi list para comprobar que los dispositivos CDI de GPU están disponibles (el servicio nvidia-cdi-refresh del kit de herramientas genera y mantiene automáticamente la especificación en toolkit >= 1.18):

nvidia-ctk cdi list

Deberías ver entradas como nvidia.com/gpu=0 y nvidia.com/gpu=all. Los dispositivos CDI detectados también aparecen en docker info.

Instalar imágenes Docker de Ultralytics#

Ultralytics publica las siguientes imágenes en Docker Hub. La automatización de publicación de Docker compila cada imagen a partir del Dockerfile enlazado.

EtiquetaPlataforma y usoFuente
latestLinux AMD64 con CUDA para entrenamiento e inferencia con GPUDockerfile
latest-exportLinux AMD64 con CUDA y dependencias de exportación para conversión y evaluación de rendimientoDockerfile-export
latest-amdLinux AMD64 con ROCm y MIGraphX para entrenamiento e inferencia con GPU AMDDockerfile-amd
latest-pythonImagen ligera Linux AMD64 Python 3.14 para inferencia en CPUDockerfile-python
latest-python-exportImagen Linux AMD64 Python 3.13 para CPU con dependencias de exportaciónDockerfile-python-export
latest-cpuImagen de Linux AMD64 para CPU con Bash como comando predeterminadoDockerfile-cpu
latest-jupyterImagen de Linux AMD64 para CPU con JupyterLab y cuadernos de tutoriales de UltralyticsDockerfile-jupyter
latest-arm64Imagen Linux ARM64 Python 3.13 para CPU para Apple silicon, Raspberry Pi y otros sistemas ARM64Dockerfile-arm64
latest-nvidia-arm64Linux ARM64 para DGX Spark (DGX OS) y PyTorch en Thor (JetPack 7.1); TensorRT incluido no es compatible con JetPackDockerfile-nvidia-arm64
latest-jetson-jetpack6Linux ARM64 para dispositivos NVIDIA Jetson con JetPack 6Dockerfile-jetson-jetpack6
latest-jetson-jetpack5Linux ARM64 para dispositivos NVIDIA Jetson con JetPack 5Dockerfile-jetson-jetpack5
latest-jetson-jetpack4Linux ARM64 para dispositivos NVIDIA Jetson con JetPack 4Dockerfile-jetson-jetpack4
latest-runnerImagen Linux AMD64 con CUDA para un ejecutor de GPU autohospedado de GitHub ActionsDockerfile-runner
latest-runner-cpuImagen Linux AMD64 para un ejecutor de CPU autohospedado de GitHub ActionsDockerfile-runner-cpu

Las imágenes de GPU AMD64 (latest, latest-export y latest-runner) usan PyTorch 2.15 y CUDA 13.2. Comprueba la compatibilidad del controlador del host con CUDA con nvidia-smi antes de iniciarlas; instalar un contenedor más reciente no actualiza el controlador del host. CUDA 13 elimina la compatibilidad con las GPU Maxwell, Pascal y Volta, incluidas Tesla P100 y V100.

La imagen NVIDIA ARM64 utiliza NVIDIA PyTorch 26.10 con CUDA 13.4 y TensorRT 11.4. La compatibilidad de PyTorch con Thor no se extiende a TensorRT: NVIDIA no es compatible con TensorRT 11.4 en JetPack. Para exportar a TensorRT en Jetson, utiliza el runtime TensorRT 10.x compatible con tu versión de JetPack. Sigue los requisitos de la plataforma en la guía de Jetson o la guía de DGX Spark. Las imágenes de JetPack 4, 5 y 6 mantienen sus pilas específicas para cada dispositivo.

El Dockerfile de Conda está disponible para compilaciones locales; la publicación automatizada de latest-conda está desactivada, por lo que esa etiqueta del registro no contiene estas actualizaciones.

Las imágenes Python, CPU, Jupyter y ejecutor de CPU usan Python 3.14. La imagen de exportación de Python usa la base latest-python-3.13, creada a partir de la misma Dockerfile-python con --build-arg PYTHON_VERSION=3.13, porque TensorFlow, CoreML y PaddlePaddle aún no son compatibles con Python 3.14.

Las etiquetas que empiezan por latest corresponden a la compilación publicada más reciente de la rama principal. En las etiquetas con versión, el prefijo latest se sustituye por una versión de Ultralytics, como VERSION, VERSION-cpu o VERSION-jetson-jetpack6. Usa una etiqueta con versión para obtener un entorno reproducible.

Para descargar la imagen más reciente:

# Pull the latest Ultralytics image from Docker Hub
sudo docker pull ultralytics/ultralytics:latest

Si prefieres compilar una imagen tú mismo, clona el repositorio y pasa el Dockerfile correspondiente de la tabla anterior; usa la raíz del repositorio como contexto de compilación:

# Build the CPU image locally from docker/Dockerfile-cpu
sudo docker build -t ultralytics/ultralytics:latest-cpu -f docker/Dockerfile-cpu .

Ejecutar Ultralytics en un contenedor Docker#

A continuación se explica cómo ejecutar el contenedor Docker de Ultralytics:

Usar solo la CPU#

# Run without GPU
sudo docker run -it --ipc=host ultralytics/ultralytics:latest-cpu

Usar GPU#

# Run with all GPUs
sudo docker run -it --ipc=host --device nvidia.com/gpu=all ultralytics/ultralytics:latest

# Run specifying which GPUs to use
sudo docker run -it --ipc=host --device nvidia.com/gpu=2 --device nvidia.com/gpu=3 ultralytics/ultralytics:latest

La opción -it asigna un pseudo-TTY y mantiene stdin abierto, lo que te permite interactuar con el contenedor. La opción --ipc=host habilita el uso compartido del espacio de nombres IPC del host, algo esencial para compartir memoria entre procesos. Para GPU NVIDIA, la opción --device nvidia.com/gpu=... concede acceso mediante CDI. Para GPU AMD, las opciones --device conceden acceso al controlador del núcleo de la GPU (/dev/kfd) y a los nodos de representación de pantalla (/dev/dri).

Usar CDI en lugar de `--gpus all`

En Linux, las solicitudes de dispositivos CDI requieren Docker >= 28.2.0 (CDI está habilitado de forma predeterminada) y nvidia-container-toolkit >= 1.18 (generación automática de especificaciones CDI). Actualiza los hosts Linux antiguos antes de ejecutar contenedores con GPU. La opción heredada --gpus all puede hacer que se pierda el acceso a la GPU (Failed to initialize NVML: Unknown Error) cuando el host vuelve a cargar systemd durante las actualizaciones rutinarias de paquetes (nvidia-container-toolkit#48). Las solicitudes CDI --device incluyen los nodos de dispositivo en la configuración del contenedor, por lo que los contenedores de larga duración, como los procesos de entrenamiento o los ejecutores de CI, mantienen el acceso a la GPU tras las recargas.

La compatibilidad de Docker Desktop con GPU en Windows utiliza actualmente --gpus all con el backend de WSL 2, ya que los dispositivos CDI de NVIDIA no están disponibles allí. Windows no usa systemd de Linux, así que no se aplica el fallo de recarga del daemon descrito anteriormente.

Nota sobre el acceso a los archivos#

Para trabajar con archivos de tu equipo local desde el contenedor, puedes usar volúmenes Docker:

# Mount a local directory into the container
sudo docker run -it --ipc=host --device nvidia.com/gpu=all -v /path/on/host:/path/in/container ultralytics/ultralytics:latest

Sustituye /path/on/host por la ruta del directorio de tu equipo local y /path/in/container por la ruta deseada dentro del contenedor Docker.

Conservar los resultados del entrenamiento#

De forma predeterminada, los resultados del entrenamiento se guardan en /ultralytics/runs/<task>/<name>/ dentro del contenedor. Si no montas un directorio del host, los resultados se pierden al eliminar el contenedor.

Para conservar los resultados del entrenamiento:

# Recommended: mount workspace and specify project path
sudo docker run --rm -it -v "$(pwd)":/w -w /w ultralytics/ultralytics:latest \
  yolo train model=yolo26n.pt data=coco8.yaml project=/w/runs

Esto guarda todos los resultados del entrenamiento en ./runs en tu equipo host.

Ejecutar aplicaciones de interfaz gráfica de usuario (GUI) en un contenedor Docker#

Altamente experimental: el usuario asume todos los riesgos

Las siguientes instrucciones son experimentales. Compartir un socket X11 con un contenedor Docker conlleva posibles riesgos de seguridad. Por tanto, se recomienda probar esta solución únicamente en un entorno controlado.

Docker se utiliza principalmente para contenerizar aplicaciones en segundo plano y programas de CLI, pero también puede ejecutar programas gráficos. En el entorno Linux, hay dos servidores gráficos principales que gestionan la visualización: X11 (también conocido como X Window System) y Wayland. Antes de empezar, es fundamental determinar qué servidor gráfico estás usando. Ejecuta este comando para averiguarlo:

env | grep -E -i 'x11|xorg|wayland'

La configuración de un servidor de visualización X11 o Wayland queda fuera del alcance de esta guía. Si el comando anterior no devuelve nada, primero tendrás que conseguir que uno de ellos funcione en tu sistema antes de continuar.

Ejecutar un contenedor Docker con una GUI#

Ejemplo
Usar GPU

Si usas GPU, puedes añadir la marca --device nvidia.com/gpu=all al comando.

Si usas X11, puedes ejecutar el siguiente comando para permitir que el contenedor Docker acceda al socket X11:

xhost +local:docker && docker run -e DISPLAY=$DISPLAY \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  -v ~/.Xauthority:/root/.Xauthority \
  -it --ipc=host ultralytics/ultralytics:latest

Este comando establece la variable de entorno DISPLAY con la pantalla del host, monta el socket X11 y asigna el archivo .Xauthority al contenedor. El comando xhost +local:docker permite que el contenedor Docker acceda al servidor X11.

Usar Docker con una GUI#

Las imágenes de Ultralytics incluyen OpenCV sin interfaz gráfica, así que instala primero la versión de OpenCV con interfaz gráfica y sus bibliotecas del sistema dentro del contenedor:

apt-get update && apt-get install -y --no-install-recommends libgl1 libglib2.0-0 libsm6
pip uninstall -y opencv-python-headless && pip install opencv-python

Ahora puedes mostrar aplicaciones gráficas dentro del contenedor Docker. Por ejemplo, puedes ejecutar el siguiente comando de CLI para visualizar las predicciones de un modelo YOLO26:

yolo predict model=yolo26n.pt show=True
Pruebas

Una forma sencilla de comprobar que el grupo Docker tiene acceso al servidor X11 es ejecutar un contenedor con un programa con interfaz gráfica, como xclock o xeyes. También puedes instalar estos programas en el contenedor Docker de Ultralytics para probar el acceso al servidor X11 de tu servidor de pantalla GNU/Linux. Si tienes algún problema, plantéate configurar la variable de entorno -e QT_DEBUG_PLUGINS=1. Al establecer esta variable de entorno, se muestra información de depuración que ayuda a resolver problemas.

Cuando termines de usar la GUI de Docker#

Revocar el acceso

En ambos casos, no olvides revocar el acceso del grupo Docker cuando termines.

xhost -local:docker
¿Quieres ver los resultados de las imágenes directamente en el terminal?

En Linux y macOS, puedes mostrar los resultados de las imágenes en el terminal integrado de VSCode mediante el protocolo sixel.

Ya puedes usar Ultralytics con Docker. Para alojar tú mismo la aplicación web de Ultralytics, consulta la guía de Platform On-Premise.

Preguntas frecuentes#

  • Para configurar Ultralytics con Docker, primero asegúrate de que Docker esté instalado en tu sistema. Si tienes una GPU NVIDIA, instala el NVIDIA Container Toolkit para habilitar la compatibilidad con GPU. Después, descarga la última imagen Docker de Ultralytics desde Docker Hub con el siguiente comando:

    sudo docker pull ultralytics/ultralytics:latest
  • Usar imágenes Docker de Ultralytics garantiza un entorno coherente en distintas máquinas al replicar el mismo software y las mismas dependencias. Esto resulta especialmente útil para colaborar entre equipos, ejecutar modelos en distintos tipos de hardware y mantener las implementaciones de modelos reproducibles. Usa latest para el entrenamiento general con GPU NVIDIA o selecciona la imagen que corresponda a tu versión de JetPack para un dispositivo NVIDIA Jetson.

  • Primero, asegúrate de que NVIDIA Container Toolkit esté instalado y configurado. A continuación, usa el siguiente comando para ejecutar Ultralytics YOLO con compatibilidad con GPU:

    sudo docker run -it --ipc=host --device nvidia.com/gpu=all ultralytics/ultralytics:latest # all GPUs

    Este comando configura un contenedor Docker con acceso a la GPU, que puedes limitar a GPU específicas o cambiar a AMD ROCm.

  • Para visualizar los resultados de las predicciones de YOLO con una GUI en un contenedor Docker, tienes que permitir que Docker acceda a tu servidor de visualización. En los sistemas que usan X11, el comando es:

    xhost +local:docker && docker run -e DISPLAY=$DISPLAY \
      -v /tmp/.X11-unix:/tmp/.X11-unix \
      -v ~/.Xauthority:/root/.Xauthority \
      -it --ipc=host ultralytics/ultralytics:latest

    En los sistemas que usan Wayland, utiliza:

    xhost +local:docker && docker run -e DISPLAY=$DISPLAY \
      -v $XDG_RUNTIME_DIR/$WAYLAND_DISPLAY:/tmp/$WAYLAND_DISPLAY \
      --net=host -it --ipc=host ultralytics/ultralytics:latest

    Dentro del contenedor, instala la versión de OpenCV con interfaz gráfica antes de usar show=True, tal como se describe en la sección Ejecutar aplicaciones con interfaz gráfica de usuario (GUI) en un contenedor Docker.

  • Sí, puedes montar directorios locales en el contenedor Docker de Ultralytics con la marca -v:

    sudo docker run -it --ipc=host --device nvidia.com/gpu=all -v /path/on/host:/path/in/container ultralytics/ultralytics:latest

    Sustituye /path/on/host por el directorio de tu equipo local y /path/in/container por la ruta que quieras usar dentro del contenedor. Esta configuración te permite trabajar con tus archivos locales desde el contenedor. Para obtener más información, consulta la sección Nota sobre la accesibilidad de los archivos.

Comentarios14

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  1. Letícia Rama

    Hello,

    Is this workflow suitable for other YOLO families, such as YOLO26?

    1. Glenn JocherUltralytics

      Yes, the same workflow supports YOLO26 and other model families available in the ultralytics package—use an up-to-date official image and specify the appropriate weights, such as model=yolo26n.pt. See the Docker Quickstart Guide for current image options, and feel free to drop any follow-up questions here so the Ultralytics team can help.

      1
  2. HellaPinotGitHub

    Hello! I have been testing running yolov8 inside a container, things seem to work well however after a somewhat random amount of time the inference hangs with no error output.

    I know the container hasn't crashed as I am reading events from a processing queue and I can see new partitions are being allocated on another thread.

    I'm running two models one after the other (different sizes and detection classes), so I'm wondering if this could be the root of the issue? At no point would they be running at the same time.

    I believe it is happening exactly when I call predict. Its hard to debug as again it happens very randomly and there is not output from the container, it seems like there might be an infinite loop somewhere thats stopping it from continuing.

    Curious if anything like this has been encountered before?

    1. Glenn JocherUltralytics

      Hello! 👋

      It sounds like a tricky issue, especially since it occurs randomly. Here are a few suggestions that might help you isolate or resolve the problem:

      1. Logging and Monitoring: Enhance the logging within your container. Consider logging the input sizes and other relevant data before the prediction call, and make sure you're logging any exceptions that could be silently caught.

      2. Resource Checks: Ensure that there are no resource starvation issues, such as GPU memory not being freed up properly. Tools like nvidia-smi can help monitor GPU usage.

      3. Sequential Model Loading: Although the models are run sequentially and not in parallel, it could be beneficial to explicitly clear the memory after each model's predictions are done. This can be done by deleting model objects and calling torch.cuda.empty_cache() if you are using PyTorch.

      4. Hardware Testing: Run your container pointing the inference to CPU only for a time to see if the problem persists. This could help determine if the issue is related to GPU computation or not.

      5. Reproducibility Tactic: Since the issue is sporadic, try to determine if there’s a specific type of input or specific conditions under which this occurs more frequently.

      If these suggestions don't help, please provide more details or code snippets, and I’d be happy to dive deeper into this!

      Let me know how it goes!

  3. HWKevinhwkGitHub

    I want to install ultralytics using docker on top of NVIDIA TX2, is there a detailed procedure? The reason for this question is that after entering the command nvidia-smi in the TX2 terminal, the output is command not found, and I'm worried that the steps in the document above are not applicable to TX2.

    1. Paula DerrengerUltralytics(editado)

      @HWKevinhwk hey there! 🚀 Setting up Ultralytics on NVIDIA TX2 with Docker can be a bit tricky if nvidia-smi is missing, but no worries.

      For NVIDIA Jetson platforms like TX2, nvidia-smi is typically not available, and you'll use tegrastats instead to monitor the GPU. The Jetson TX2 is supported on JetPack 4, so install JetPack 4 first, as it includes the NVIDIA drivers and libraries needed for GPU acceleration. Jetson devices use the Docker integration provided through JetPack with --runtime=nvidia rather than --gpus all. Then pull and run the Ultralytics Docker image for JetPack 4:

      t=ultralytics/ultralytics:latest-jetson-jetpack4
      sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t

      See the NVIDIA Jetson guide for details. If you encounter any specific issues, feel free to drop them here. Happy detecting! 🎉

    2. HWKevinhwkGitHub

      Is there a detailed tutorial on deploying yolov8 on jetson TX2 using docker? I am pulling images docker pull ultralytics/ultralytics:latest-jetson terminal will downloading pause, long time pulling images unsuccessful, repeated attempts still so, any solution please?

    3. Paula DerrengerUltralytics(editado)

      @HWKevinhwk hey there! 😊

      It sounds like you're facing issues with the Docker image pull for the Jetson TX2. This might be due to network issues or Docker Hub delays, or to using a tag that does not exist.

      Here's a simplified breakdown to get you started on the TX2 using Docker:

      1. Ensure JetPack is installed: The TX2 is supported on JetPack 4, which includes the GPU drivers necessary for Docker integration with the Jetson GPU.

      2. Install Docker:

        sudo apt-get install docker.io
      3. NVIDIA runtime support (JetPack should handle this): nvidia-smi doesn't work on Jetson, so verify the nvidia runtime with docker info | grep -i runtime.

      4. Pull the Docker image for Jetson. Pulling large Docker images can be challenging on slower networks:

        sudo docker pull ultralytics/ultralytics:latest-jetson-jetpack4

        If you keep facing issues while pulling the image, try restarting your Docker service or check your network settings. Sometimes, using a different network can help too!

      5. Run the Image:

        sudo docker run -it --ipc=host --runtime=nvidia ultralytics/ultralytics:latest-jetson-jetpack4

      This should set you on the right path to running Ultralytics YOLO on your Jetson TX2. If the problem persists, it might be worth checking Docker's log or discussing this issue further with your network admin or on Docker forums! 😄

      Happy coding! 🚀

  4. Peter-codingGitHub

    Hey! I trained a YOLOv8 model on my local computer. I have the best.pt file, and I can use it in CLI (conda) for predict. I want to make a python app, which uses this best.pt file, and I want to containerize it. Is it possible to write the full python app (it is just a few lines of code, which runs the detection, then writes the detection result to a database), then containerize it, and able to use it anywhere? Thank you! :D

    1. Paula DerrengerUltralytics

      Hey there! 😊

      Absolutely, you can absolutely containerize your Python app that uses the best.pt model! Here's a quick guide:

      1. Create Your Python App: Just like you mentioned, write your Python code that performs the detection and interacts with the database.

      2. Dockerize Your Application:

        • Dockerfile: Create a Dockerfile in your project directory. Here's a simple example that uses Ultralytics' Docker image as a base:

          FROM ultralytics/ultralytics:latest
          WORKDIR /app
          COPY . /app
          RUN pip install -r requirements.txt  # Assuming you have a requirements.txt
          CMD ["python", "your_script.py"]
        • Build Your Docker Image: Run the following command in your project directory:

          sudo docker build -t your-app-name .
        • Run Your Container: To run your container, especially if you're planning to use GPU, you might want to specify --gpus all:

          sudo docker run -it --ipc=host --gpus all your-app-name

          For accessing local files, consider mounting a volume as described in the Docker Quickstart Guide.

      3. Deployment: With your Docker image built, you can now deploy and run it anywhere that Docker is supported. If using a GPU, ensure the host machine supports NVIDIA GPUs and has the necessary drivers and Docker configured correctly.

      That's it! You should be able to use your model within a containerized app now. If you hit any snags, double-check the Docker Quickstart Guide for Ultralytics for more details. Happy coding! 😄

  5. udayzee05GitHub

    DEPRECATION NOTICE The nvidia-docker wrapper is no longer supported, and the NVIDIA Container Toolkit has been extended to allow users to configure Docker to use the NVIDIA Container Runtime. For further instructions, see the NVIDIA Container Toolkit documentation and specifically the install guide.22 Jan 2024

    1. Paula DerrengerUltralytics(editado)

      Hey there! 👋 Thanks for bringing up the deprecation notice regarding the nvidia-docker wrapper. You're right; use the NVIDIA Container Toolkit for GPU support in Docker containers. Here's how to set it up on Ubuntu/Debian, as described in our Docker Quickstart Guide:

      # Add the NVIDIA Container Toolkit repository
      curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
        && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
        | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
          | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
      
      # Install the NVIDIA Container Toolkit
      sudo apt-get update
      sudo apt-get install -y nvidia-container-toolkit

      And to verify that the GPU devices are available to Docker:

      nvidia-ctk cdi list

      This should list entries such as nvidia.com/gpu=all, indicating that your Docker setup can leverage GPU acceleration. 🚀

      For more detailed instructions and tips on using Ultralytics with Docker, including mounting local directories and running containers, check out our Docker Quickstart Guide. Happy coding!