Ultralytics YOLO27:

Guia de início rápido do Docker para Ultralytics#

Ultralytics Docker Package Visual

Este guia é uma introdução abrangente à configuração de um ambiente Docker para os teus projetos Ultralytics. O Docker é uma plataforma para desenvolver, distribuir e executar aplicações em contentores. É particularmente útil para garantir que o software funcione sempre da mesma forma, independentemente de onde seja implementado. Para mais detalhes, visita o repositório Docker da Ultralytics no Docker Hub.

Versão da imagem Docker Downloads Docker

O que vais aprender#

  • Configurar o Docker com suporte para NVIDIA
  • Instalar imagens Docker da Ultralytics
  • Executar a Ultralytics num contentor Docker com suporte para CPU ou GPU
  • Usar um servidor de visualização com o Docker para mostrar resultados de deteção da Ultralytics
  • Montar diretórios locais no contentor


Watch: How to Get started with Docker | Usage of Ultralytics Python Package inside Docker live demo 🎉

Pré-requisitos#

  • Certifica-te de que o Docker está instalado no teu sistema. Caso contrário, podes transferi-lo e instalá-lo a partir do site do Docker.
  • Para aceleração por GPU, certifica-te de que o teu sistema tem uma GPU NVIDIA e os controladores NVIDIA instalados. As imagens para CPU não requerem hardware NVIDIA.
  • Se estiveres a usar dispositivos NVIDIA Jetson, certifica-te de que tens instalada a versão adequada do JetPack. Consulta o guia NVIDIA Jetson para mais detalhes.

Configurar o Docker com suporte para NVIDIA (opcional)#

Primeiro, verifica se os controladores NVIDIA estão corretamente instalados executando:

nvidia-smi

Instalar o NVIDIA Container Toolkit#

Agora, vamos instalar o NVIDIA Container Toolkit para ativar o suporte para GPU nos contentores 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

Atualiza as listas de pacotes e instala o NVIDIA Container Toolkit:

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

Verificar dispositivos CDI com o Docker#

Executa nvidia-ctk cdi list para garantir que os dispositivos GPU CDI estão disponíveis (o serviço nvidia-cdi-refresh do toolkit gera e mantém automaticamente a especificação no toolkit >= 1.18):

nvidia-ctk cdi list

Deves ver entradas como nvidia.com/gpu=0 e nvidia.com/gpu=all. Os dispositivos CDI detetados também aparecem em docker info.

Instalar imagens Docker da Ultralytics#

A Ultralytics publica as seguintes imagens no Docker Hub. Cada imagem é criada a partir do Dockerfile associado pelo fluxo de publicação do Docker.

EtiquetaPlataforma e finalidadeOrigem
latestLinux AMD64 com CUDA para treino e inferência em GPUDockerfile
latest-exportLinux AMD64 com CUDA e dependências de exportação para conversão e avaliação de desempenhoDockerfile-export
latest-pythonImagem Python Linux AMD64 leve para inferência em CPUDockerfile-python
latest-python-exportImagem Linux AMD64 para CPU com dependências de exportaçãoDockerfile-python-export
latest-cpuImagem Linux AMD64 para CPU com Bash como comando predefinidoDockerfile-cpu
latest-jupyterImagem Linux AMD64 para CPU com JupyterLab e notebooks de tutoriais da UltralyticsDockerfile-jupyter
latest-arm64Imagem Linux ARM64 para CPU para Apple silicon, Raspberry Pi e outros sistemas ARM64Dockerfile-arm64
latest-nvidia-arm64Linux ARM64 para DGX Spark (DGX OS) e PyTorch em Thor (JetPack 7.1); o TensorRT empacotado não oferece suporte ao JetPackDockerfile-nvidia-arm64
latest-jetson-jetpack6Linux ARM64 para dispositivos NVIDIA Jetson com JetPack 6Dockerfile-jetson-jetpack6
latest-jetson-jetpack5Linux ARM64 para dispositivos NVIDIA Jetson com JetPack 5Dockerfile-jetson-jetpack5
latest-jetson-jetpack4Linux ARM64 para dispositivos NVIDIA Jetson com JetPack 4Dockerfile-jetson-jetpack4
latest-runnerImagem Linux AMD64 com CUDA para um runner de GPU do GitHub Actions autoalojadoDockerfile-runner
latest-runner-cpuImagem Linux AMD64 para um runner de CPU do GitHub Actions autoalojadoDockerfile-runner-cpu

As imagens de GPU AMD64 (latest, latest-export e latest-runner) utilizam o PyTorch 2.14 e o CUDA 13.2. Verifica o suporte ao CUDA do controlador do host com nvidia-smi antes de inicia-las; a instalação de um contentor mais recente não atualiza o controlador do host. O CUDA 13 remove o suporte para GPUs Maxwell, Pascal e Volta, incluindo as Tesla P100 e V100. Vê as notas de lançamento do CUDA da NVIDIA e os requisitos de compatibilidade de controladores.

A imagem NVIDIA ARM64 utiliza o NVIDIA PyTorch 26.08 com o CUDA 13.4 e o TensorRT 11.2. O seu suporte do PyTorch para Thor não se estende ao TensorRT: a NVIDIA não suporta o TensorRT 11.2 no JetPack. Para exportações do Jetson TensorRT, utiliza o tempo de execução do TensorRT 10.x suportado para a tua versão do JetPack. Segue os requisitos da plataforma no guia do Jetson ou no guia do DGX Spark. As imagens do JetPack 4, 5 e 6 retêm as suas pilhas específicas de dispositivos separadas.

O Dockerfile do Conda está disponível para compilações locais; a publicação automatizada de latest-conda está desativada, pelo que essa etiqueta de registo não contém estas atualizações.

Utiliza latest-python-export para exportações do LiteRT. A imagem de GPU latest-export mantém o PyTorch 2.14 e omite o LiteRT porque a sua dependência atual requer um PyTorch inferior a 2.14.

As etiquetas que começam por latest acompanham a compilação mais recentemente publicada do branch principal. As etiquetas com versão substituem o prefixo latest por uma versão da Ultralytics, como VERSION, VERSION-cpu ou VERSION-jetson-jetpack6. Usa uma etiqueta com versão para obter um ambiente reproduzível.

Para obter a imagem mais recente:

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

Para criares tu próprio uma imagem, clona o repositório e indica o Dockerfile correspondente da tabela acima, usando a raiz do repositório como contexto de compilação:

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

Executar a Ultralytics num contentor Docker#

Eis como executar o contentor Docker da Ultralytics:

Usar apenas a CPU#

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

Usar GPUs#

# 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

A opção -it atribui um pseudo-TTY e mantém o stdin aberto, permitindo-te interagir com o contentor. A opção --ipc=host ativa a partilha do espaço de nomes IPC do anfitrião, essencial para partilhar memória entre processos. A opção --device nvidia.com/gpu=... concede ao contentor acesso às GPUs do anfitrião através de CDI.

Usar CDI em vez de `--gpus all`

No Linux, os pedidos de dispositivos CDI requerem Docker >= 28.2.0 (CDI ativado por predefinição) e nvidia-container-toolkit >= 1.18 (geração automática da especificação CDI). Atualiza os anfitriões Linux mais antigos antes de executar contentores GPU. A opção legada --gpus all pode perder o acesso à GPU (Failed to initialize NVML: Unknown Error) quando o anfitrião recarrega o systemd durante atualizações de pacotes de rotina (nvidia-container-toolkit#48). Os pedidos CDI --device incluem os nós de dispositivos na configuração do contentor, pelo que contentores de longa duração, como workers de treino ou runners de CI, mantêm o acesso à GPU após os recarregamentos.

O suporte para GPU do Docker Desktop no Windows usa atualmente --gpus all com o backend WSL 2, porque os dispositivos CDI da NVIDIA não estão disponíveis nesse ambiente. O Windows não usa o systemd do Linux, pelo que a falha de daemon-reload acima não se aplica.

Nota sobre acessibilidade de ficheiros#

Para trabalhar com ficheiros no teu computador local dentro do contentor, podes usar 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

Substitui /path/on/host pelo caminho do diretório no teu computador local e /path/in/container pelo caminho pretendido dentro do contentor Docker.

Persistir os resultados do treino#

Por predefinição, os resultados do treino são guardados em /ultralytics/runs/<task>/<name>/ dentro do contentor. Sem montar um diretório do anfitrião, os resultados perdem-se quando o contentor é removido.

Para persistir os resultados do treino:

# 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

Isto guarda todos os resultados do treino em ./runs no teu computador anfitrião.

Executar aplicações de interface gráfica do utilizador (GUI) num contentor Docker#

Altamente experimental — o utilizador assume todos os riscos

As instruções seguintes são experimentais. Partilhar um socket X11 com um contentor Docker acarreta potenciais riscos de segurança. Por isso, recomenda-se testar esta solução apenas num ambiente controlado. Para mais informações, consulta estes recursos sobre como usar xhost(1)(2).

O Docker é utilizado principalmente para colocar aplicações em segundo plano e programas CLI em contentores, mas também pode executar programas gráficos. No mundo Linux, dois servidores gráficos principais gerem a apresentação gráfica: X11 (também conhecido como X Window System) e Wayland. Antes de começar, é essencial determinar qual servidor gráfico estás a usar atualmente. Executa este comando para descobri-lo:

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

A configuração de um servidor de visualização X11 ou Wayland está fora do âmbito deste guia. Se o comando acima não devolver nada, terás primeiro de configurar um deles para funcionar no teu sistema antes de continuar.

Executar um contentor Docker com uma GUI#

Exemplo
Usar GPUs

Se estiveres a usar GPUs, podes adicionar a opção --device nvidia.com/gpu=all ao comando.

Se estiveres a usar X11, podes executar o comando seguinte para permitir que o contentor Docker aceda ao 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 define a variável de ambiente DISPLAY para o ecrã do anfitrião, monta o socket X11 e mapeia o ficheiro .Xauthority para o contentor. O comando xhost +local:docker permite que o contentor Docker aceda ao servidor X11.

Usar o Docker com uma GUI#

Agora podes apresentar aplicações gráficas dentro do teu contentor Docker. Por exemplo, podes executar o seguinte comando CLI para visualizar as previsões de um modelo YOLO26:

yolo predict model=yolo26n.pt show=True
Testes

Uma forma simples de validar se o grupo Docker tem acesso ao servidor X11 é executar um contentor com um programa GUI, como xclock ou xeyes. Em alternativa, também podes instalar estes programas no contentor Docker da Ultralytics para testar o acesso ao servidor X11 do teu servidor de visualização GNU-Linux. Se encontrares problemas, considera definir a variável de ambiente -e QT_DEBUG_PLUGINS=1. Definir esta variável de ambiente ativa a apresentação de informações de depuração, ajudando no processo de resolução de problemas.

Quando terminares de usar a GUI do Docker#

Revogar o acesso

Em ambos os casos, não te esqueças de revogar o acesso do grupo Docker quando terminares.

xhost -local:docker
Queres ver os resultados das imagens diretamente no Terminal?

Consulta o guia seguinte sobre ver os resultados das imagens com um terminal

Está tudo pronto para usares a Ultralytics com o Docker e tirares partido das suas capacidades. Para alojar autonomamente a aplicação Web da Ultralytics, consulta o guia da Plataforma no local. Para métodos alternativos de instalação do pacote Python, consulta a documentação de início rápido da Ultralytics.

Perguntas frequentes#

  • Para configurares a Ultralytics com o Docker, certifica-te primeiro de que o Docker está instalado no teu sistema. Se tiveres uma GPU NVIDIA, instala o NVIDIA Container Toolkit para ativar o suporte para GPU. Em seguida, obtém a imagem Docker mais recente da Ultralytics a partir do Docker Hub usando o comando seguinte:

    sudo docker pull ultralytics/ultralytics:latest

    Para obteres instruções detalhadas, consulta o nosso Guia de início rápido do Docker.

  • Usar imagens Docker da Ultralytics garante um ambiente consistente em máquinas diferentes, reproduzindo o mesmo software e as mesmas dependências. Isto é particularmente útil para colaborar entre equipas, executar modelos em vários tipos de hardware e manter a reprodutibilidade. Usa latest para treino geral em GPU NVIDIA ou seleciona a imagem correspondente à tua versão do JetPack para um dispositivo NVIDIA Jetson. Consulta a tabela completa de imagens ou explora o Docker Hub da Ultralytics.

  • Primeiro, certifica-te de que o NVIDIA Container Toolkit está instalado e configurado. Em seguida, usa o comando seguinte para executar o Ultralytics YOLO com suporte para GPU:

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

    Este comando configura um contentor Docker com acesso à GPU. Para mais detalhes, consulta o Guia de início rápido do Docker.

  • Para visualizares resultados de previsões YOLO com uma GUI num contentor Docker, tens de permitir que o Docker aceda ao teu servidor de visualização. Em sistemas com X11, o comando é:

    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

    Em sistemas com Wayland, usa:

    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

    Podes encontrar mais informações na secção Executar aplicações de interface gráfica do utilizador (GUI) num contentor Docker.

  • Sim, podes montar diretórios locais no contentor Docker da Ultralytics usando a opção -v:

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

    Substitui /path/on/host pelo diretório no teu computador local e /path/in/container pelo caminho pretendido dentro do contentor. Esta configuração permite-te trabalhar com os teus ficheiros locais dentro do contentor. Para mais informações, consulta a secção Nota sobre acessibilidade de ficheiros.

Comentários