Commencer

Guide de démarrage rapide Docker pour Ultralytics

Ultralytics Docker images on Docker Hub

Ce guide explique comment configurer un environnement Docker pour tes projets Ultralytics. Docker est une plateforme permettant de développer, distribuer et exécuter des applications dans des conteneurs, ce qui garantit que le logiciel fonctionne de la même manière, quel que soit son environnement de déploiement.

Version de l’image Docker Téléchargements Docker

Ce que tu vas apprendre#

  • Configurer Docker avec la prise en charge de NVIDIA
  • Installer les images Docker Ultralytics
  • Exécuter Ultralytics dans un conteneur Docker avec prise en charge du CPU ou du GPU
  • Utiliser un serveur d’affichage avec Docker pour afficher les résultats de détection Ultralytics
  • Monter des répertoires locaux dans le conteneur


Regarder : Comment démarrer avec Docker | Démonstration en direct de l’utilisation du package Ultralytics Python dans Docker 🎉

Prérequis#

  • Assure-toi que Docker est installé sur ton système. Sinon, tu peux le télécharger et l’installer depuis le site Web de Docker.
  • Pour accélérer le calcul avec le GPU, vérifie que ton système est équipé d’un GPU NVIDIA et que les pilotes NVIDIA sont installés. Les images CPU ne nécessitent pas de matériel NVIDIA.
  • Si tu utilises des appareils NVIDIA Jetson, vérifie que la version appropriée de JetPack est installée. Consulte le guide NVIDIA Jetson pour en savoir plus.

Configurer Docker avec la prise en charge de NVIDIA (facultatif)#

Commence par vérifier que les pilotes NVIDIA sont correctement installés en exécutant :

nvidia-smi

Installer NVIDIA Container Toolkit#

Installe le NVIDIA Container Toolkit pour activer la prise en charge du GPU dans les conteneurs 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

Mets à jour les listes de paquets et installe NVIDIA Container Toolkit :

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

Vérifier les appareils CDI avec Docker#

Exécute nvidia-ctk cdi list pour vérifier que les appareils GPU CDI sont disponibles (le service nvidia-cdi-refresh de la boîte à outils génère et maintient automatiquement la spécification avec toolkit >= 1.18) :

nvidia-ctk cdi list

Tu devrais voir des entrées telles que nvidia.com/gpu=0 et nvidia.com/gpu=all. Les appareils CDI détectés apparaissent aussi dans docker info.

Installer les images Docker Ultralytics#

Ultralytics publie les images suivantes sur Docker Hub. Chaque image est construite à partir du Dockerfile associé par le workflow de publication Docker.

ÉtiquettePlateforme et usageSource
latestLinux AMD64 avec CUDA pour l’entraînement et l’inférence sur GPUDockerfile
latest-exportLinux AMD64 avec CUDA et les dépendances d’export pour la conversion et l’évaluation des performancesDockerfile-export
latest-amdLinux AMD64 avec ROCm et MIGraphX pour l’entraînement et l’inférence sur GPU AMDDockerfile-amd
latest-pythonImage Linux AMD64 légère avec Python 3.14 pour l’inférence sur CPUDockerfile-python
latest-python-exportImage Linux AMD64 avec Python 3.13 et CPU, incluant les dépendances d’exportDockerfile-python-export
latest-cpuImage Linux AMD64 pour CPU utilisant Bash comme commande par défautDockerfile-cpu
latest-jupyterImage Linux AMD64 pour CPU avec JupyterLab et les notebooks de tutoriels UltralyticsDockerfile-jupyter
latest-arm64Image Linux ARM64 avec Python 3.13 et CPU pour les puces Apple, Raspberry Pi et les autres systèmes ARM64Dockerfile-arm64
latest-nvidia-arm64Linux ARM64 pour DGX Spark (DGX OS) et PyTorch sur Thor (JetPack 7.1) ; TensorRT fourni ne prend pas en charge JetPackDockerfile-nvidia-arm64
latest-jetson-jetpack6Linux ARM64 pour les appareils NVIDIA Jetson exécutant JetPack 6Dockerfile-jetson-jetpack6
latest-jetson-jetpack5Linux ARM64 pour les appareils NVIDIA Jetson exécutant JetPack 5Dockerfile-jetson-jetpack5
latest-jetson-jetpack4Linux ARM64 pour les appareils NVIDIA Jetson exécutant JetPack 4Dockerfile-jetson-jetpack4
latest-runnerImage Linux AMD64 avec CUDA pour un exécuteur GPU GitHub Actions auto-hébergéDockerfile-runner
latest-runner-cpuImage Linux AMD64 pour un exécuteur CPU GitHub Actions auto-hébergéDockerfile-runner-cpu

Les images GPU AMD64 (latest, latest-export et latest-runner) utilisent PyTorch 2.15 et CUDA 13.2. Vérifie la prise en charge de CUDA par le pilote de l’hôte avec nvidia-smi avant de les lancer ; l’installation d’un conteneur plus récent ne met pas à niveau le pilote de l’hôte. CUDA 13 abandonne la prise en charge des GPU Maxwell, Pascal et Volta, notamment Tesla P100 et V100.

L’image NVIDIA ARM64 utilise NVIDIA PyTorch 26.10 avec CUDA 13.4 et TensorRT 11.4. La prise en charge de Thor par PyTorch ne s’étend pas à TensorRT : NVIDIA ne prend pas en charge TensorRT 11.4 sur JetPack. Pour les exports TensorRT sur Jetson, utilise le runtime TensorRT 10.x pris en charge par ta version de JetPack. Suis les exigences de la plateforme dans le guide Jetson ou le guide DGX Spark. Les images JetPack 4, 5 et 6 conservent leurs piles distinctes, propres à chaque appareil.

Le Dockerfile Conda est disponible pour les compilations locales ; la publication automatisée de latest-conda est désactivée, cette étiquette du registre ne contient donc pas ces mises à jour.

Les images Python, CPU, Jupyter et runner CPU utilisent Python 3.14. L’image Python pour l’export utilise la base latest-python-3.13, construite à partir du même Dockerfile-python avec --build-arg PYTHON_VERSION=3.13, car TensorFlow, CoreML et PaddlePaddle ne prennent pas encore en charge Python 3.14.

Les étiquettes commençant par latest correspondent à la version la plus récemment publiée depuis la branche principale. Les étiquettes versionnées remplacent le préfixe latest par une version Ultralytics, comme VERSION, VERSION-cpu ou VERSION-jetson-jetpack6. Utilise une étiquette versionnée pour obtenir un environnement reproductible.

Pour récupérer la dernière image :

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

Pour construire toi-même une image, clone le dépôt et indique le Dockerfile correspondant dans le tableau ci-dessus, en utilisant la racine du dépôt comme contexte de compilation :

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

Exécuter Ultralytics dans un conteneur Docker#

Voici comment exécuter le conteneur Docker Ultralytics :

Utiliser uniquement le CPU#

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

Utiliser des 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

L’option -it alloue un pseudo-terminal et garde stdin ouvert, ce qui te permet d’interagir avec le conteneur. L’option --ipc=host active le partage de l’espace de noms IPC de l’hôte, indispensable au partage de mémoire entre les processus. Pour les GPU NVIDIA, l’option --device nvidia.com/gpu=... autorise l’accès via CDI. Pour les GPU AMD, les options --device autorisent l’accès au pilote du noyau GPU (/dev/kfd) et aux nœuds de rendu d’affichage (/dev/dri).

Utiliser CDI plutôt que `--gpus all`

Sous Linux, les requêtes d’appareils CDI nécessitent Docker >= 28.2.0 (CDI est activé par défaut) et nvidia-container-toolkit >= 1.18 (génération automatique de la spécification CDI). Mets à niveau les anciens hôtes Linux avant d’exécuter des conteneurs GPU. L’option héritée --gpus all peut entraîner une perte d’accès au GPU (Failed to initialize NVML: Unknown Error) lorsque l’hôte recharge systemd lors des mises à jour courantes de paquets (nvidia-container-toolkit#48). Les requêtes CDI --device incluent les nœuds de périphérique dans la configuration du conteneur ; les conteneurs de longue durée, tels que les processus d’entraînement ou les exécuteurs CI, conservent ainsi l’accès au GPU lors des rechargements.

La prise en charge des GPU par Docker Desktop sous Windows utilise actuellement --gpus all avec le moteur WSL 2, car les appareils NVIDIA CDI n’y sont pas disponibles. Windows n’utilise pas systemd sous Linux ; l’échec du rechargement du démon décrit ci-dessus ne s’applique donc pas.

Remarque sur l’accès aux fichiers#

Pour accéder aux fichiers de ta machine locale depuis le conteneur, tu peux utiliser des volumes 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

Remplace /path/on/host par le chemin du répertoire sur ta machine locale et /path/in/container par le chemin souhaité dans le conteneur Docker.

Conserver les sorties d’entraînement#

Par défaut, les sorties d’entraînement sont enregistrées dans /ultralytics/runs/<task>/<name>/ à l’intérieur du conteneur. Si tu ne montes pas de répertoire de l’hôte, les sorties sont perdues lorsque le conteneur est supprimé.

Pour conserver les sorties d’entraînement :

# 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

Cette commande enregistre toutes les sorties d’entraînement dans ./runs sur ta machine hôte.

Exécuter des applications à interface graphique (GUI) dans un conteneur Docker#

Très expérimental – l’utilisateur assume tous les risques

Les instructions suivantes sont expérimentales. Le partage d’un socket X11 avec un conteneur Docker présente des risques de sécurité potentiels. Il est donc recommandé de tester cette solution uniquement dans un environnement contrôlé.

Docker est principalement utilisé pour conteneuriser des applications en arrière-plan et des programmes CLI, mais il peut également exécuter des programmes graphiques. Sous Linux, deux principaux serveurs graphiques gèrent l’affichage : X11 (également appelé système X Window) et Wayland. Avant de commencer, il est essentiel de déterminer quel serveur graphique tu utilises actuellement. Exécute cette commande pour le savoir :

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

La configuration d’un serveur d’affichage X11 ou Wayland n’entre pas dans le cadre de ce guide. Si la commande ci-dessus ne renvoie rien, tu devras d’abord faire fonctionner l’un de ces serveurs sur ton système avant de continuer.

Exécuter un conteneur Docker avec une interface graphique#

Exemple
Utiliser des GPU

Si tu utilises des GPU, tu peux ajouter l’option --device nvidia.com/gpu=all à la commande.

Si tu utilises X11, tu peux exécuter la commande suivante pour autoriser le conteneur Docker à accéder au 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

Cette commande définit la variable d’environnement DISPLAY sur l’affichage de l’hôte, monte le socket X11 et associe le fichier .Xauthority au conteneur. La commande xhost +local:docker permet au conteneur Docker d’accéder au serveur X11.

Utiliser Docker avec une interface graphique#

Les images Ultralytics incluent une version sans interface graphique d’OpenCV. Installe donc d’abord la version avec interface graphique d’OpenCV et ses bibliothèques système dans le conteneur :

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

Tu peux maintenant afficher des applications graphiques dans ton conteneur Docker. Par exemple, tu peux exécuter la commande CLI suivante pour visualiser les prédictions d’un modèle YOLO26 :

yolo predict model=yolo26n.pt show=True
Tests

Pour vérifier simplement que le groupe Docker a accès au serveur X11, exécute un conteneur avec un programme doté d’une interface graphique, comme xclock ou xeyes. Tu peux aussi installer ces programmes dans le conteneur Docker Ultralytics pour tester l’accès au serveur X11 de ton serveur d’affichage GNU/Linux. Si tu rencontres des problèmes, pense à définir la variable d’environnement -e QT_DEBUG_PLUGINS=1. Elle active l’affichage des informations de débogage, ce qui facilite le dépannage.

Après avoir utilisé l’interface graphique de Docker#

Révoquer l’accès

Dans les deux cas, n’oublie pas de révoquer l’accès du groupe Docker lorsque tu as terminé.

xhost -local:docker
Tu veux afficher les résultats des images directement dans le terminal ?

Sous Linux et macOS, tu peux afficher les résultats d’image dans le terminal intégré de VSCode à l’aide du protocole sixel.

Tu es maintenant prêt à utiliser Ultralytics avec Docker. Pour héberger toi-même l’application Web Ultralytics, consulte le guide de déploiement sur site de la plateforme.

FAQ#

  • Pour configurer Ultralytics avec Docker, vérifie d’abord que Docker est installé sur ton système. Si tu as un GPU NVIDIA, installe le NVIDIA Container Toolkit pour activer la prise en charge du GPU. Récupère ensuite la dernière image Docker Ultralytics depuis Docker Hub à l’aide de la commande suivante :

    sudo docker pull ultralytics/ultralytics:latest
  • L’utilisation des images Docker Ultralytics garantit un environnement cohérent sur différentes machines, avec les mêmes logiciels et dépendances. C’est particulièrement utile pour collaborer en équipe, exécuter des modèles sur divers matériels et garantir la reproductibilité des déploiements de modèles. Utilise latest pour l’entraînement général sur GPU NVIDIA ou sélectionne l’image correspondant à ta version de JetPack pour un appareil NVIDIA Jetson.

  • Vérifie d’abord que le NVIDIA Container Toolkit est installé et configuré. Exécute ensuite la commande suivante pour lancer Ultralytics YOLO avec la prise en charge des GPU :

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

    Cette commande configure un conteneur Docker avec un accès au GPU, que tu peux limiter à des GPU spécifiques ou basculer vers AMD ROCm.

  • Pour visualiser les résultats des prédictions YOLO avec une interface graphique dans un conteneur Docker, tu dois autoriser Docker à accéder à ton serveur d’affichage. Pour les systèmes utilisant X11, la commande est la suivante :

    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

    Pour les systèmes utilisant Wayland, utilise :

    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

    Dans le conteneur, installe la version avec interface graphique d’OpenCV avant d’utiliser show=True, comme indiqué dans la section Exécuter des applications à interface utilisateur graphique (GUI) dans un conteneur Docker.

  • Oui, tu peux monter des répertoires locaux dans le conteneur Docker Ultralytics à l’aide de l’option -v :

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

    Remplace /path/on/host par le répertoire de ta machine locale et /path/in/container par le chemin souhaité dans le conteneur. Cette configuration te permet de travailler avec tes fichiers locaux dans le conteneur. Pour en savoir plus, consulte la section Remarque sur l’accessibilité des fichiers.

Commentaires14

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  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(modifié)

      @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(modifié)

      @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(modifié)

      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!