Instalar o Ultralytics

Instale ou atualize o ultralytics package usando pip executando pip install -U ultralytics. Para mais detalhes sobre o ultralytics package, visite o Índice de Pacotes Python (PyPI).

# Install the ultralytics package from PyPI
pip install ultralytics

Também pode instalar ultralytics diretamente do repositório Ultralytics GitHub. Isso pode ser útil se você quiser a versão de desenvolvimento mais recente. Certifique-se de ter a ferramenta de linha de comando Git instalada e execute:

# Install the ultralytics package from GitHub
pip install git+https://github.com/ultralytics/ultralytics.git@main

O Conda pode ser usado como um gerenciador de pacotes alternativo ao pip. Para mais detalhes, visite Anaconda. O repositório de feedstock da Ultralytics para atualizar o pacote conda está disponível em GitHub.

# Install the ultralytics package using conda
conda install -c conda-forge ultralytics

# Install all packages together using conda
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics

Imagem Docker do Conda

As imagens Ultralytics Conda Docker também estão disponíveis no DockerHub. Essas imagens são baseadas no Miniconda3 e fornecem uma maneira direta de começar a usar ultralytics em um ambiente Conda.

# Set image name as a variable
t=ultralytics/ultralytics:latest-conda

# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t

# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs

Clone o repositório Ultralytics GitHub se você estiver interessado em contribuir para o desenvolvimento ou desejar experimentar o código-fonte mais recente. Após a clonagem, navegue até o diretório e instale o pacote no modo editável -e usando pip.

# Clone the ultralytics repository
git clone https://github.com/ultralytics/ultralytics

# Navigate to the cloned directory
cd ultralytics

# Install the package in editable mode for development
pip install -e .

Use o Docker para executar o ultralytics package em um contêiner isolado, garantindo um desempenho consistente em vários ambientes. Ao selecionar um dos ultralytics imagens de Docker Hub, você evita a complexidade da instalação local e obtém acesso a um ambiente de trabalho verificado. A Ultralytics oferece cinco imagens Docker principais suportadas, cada uma projetada para alta compatibilidade e eficiência:

• Dockerfile: Imagem de GPU recomendada para treinamento.
• Dockerfile-arm64: Otimizado para arquitetura ARM64, adequado para implantação em dispositivos como Raspberry Pi e outras plataformas baseadas em ARM64.
• Dockerfile-cpu: Versão baseada em Ubuntu somente para CPU, adequada para inferência e ambientes sem GPUs.
• Dockerfile-jetson: Projetado para dispositivos NVIDIA Jetson, integrando suporte a GPU otimizado para essas plataformas.
• Dockerfile-python: Imagem mínima com apenas python e dependências necessárias, ideal para aplicações leves e desenvolvimento.
• Dockerfile-conda: Baseado no Miniconda3 com uma instalação conda do ultralytics package.

Aqui estão os comandos para obter a imagem mais recente e executá-la:

# Set image name as a variable
t=ultralytics/ultralytics:latest

# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t

# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs

O comando acima inicializa um contêiner Docker com a versão mais recente da ultralytics imagem. A flag -it flags atribuem um pseudo-TTY e mantêm o stdin aberto, permitindo a interação com o contêiner. O --ipc=host define o namespace IPC (Inter-Process Communication) para o host, o que é essencial para compartilhar memória entre processos. A flag --gpus all flag permite o acesso a todas as GPUs disponíveis dentro do contêiner, crucial para tarefas que exigem computação de GPU.

Observação: Para trabalhar com arquivos em sua máquina local dentro do contêiner, use volumes Docker para montar um diretório local no contêiner:

# Mount local directory to a directory inside the container
sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t

Substitua /path/on/host com o caminho do diretório em sua máquina local e /path/in/container pelo caminho desejado dentro do contêiner Docker.

Para uso avançado do Docker, explore o Guia do Docker da Ultralytics.

Você pode instalar o ultralytics pacote core sem quaisquer dependências usando o pip --no-deps flag. Isso exige que você instale manualmente todas as dependências necessárias posteriormente.

1. Instalar ultralytics core:

   pip install ultralytics --no-deps
   

2. Instale as dependências manualmente: Você precisa instalar todos os pacotes necessários listados no pyproject.toml arquivo, substituindo ou modificando versões conforme necessário. Para o exemplo OpenCV headless:

   # Install other core dependencies
   pip install torch torchvision numpy matplotlib polars pyyaml pillow psutil requests scipy seaborn ultralytics-thop
   
   # Install headless OpenCV instead of the default
   pip install opencv-python-headless
   

Se você precisar de modificações personalizadas persistentes (como usar sempre opencv-python-headless), você pode fazer um fork do repositório Ultralytics, fazer alterações em pyproject.toml ou outro código, e instale a partir do seu fork.

1. Faça um fork do repositório Ultralytics no GitHub para sua própria conta do GitHub.
2. Clone seu fork localmente:

   git clone https://github.com/YOUR_USERNAME/ultralytics.git
   cd ultralytics
   

3. Criar um novo branch para as suas alterações:

   git checkout -b custom-opencv
   

4. Modificar pyproject.toml: Abrir pyproject.toml em um editor de texto e substitua a linha que contém "opencv-python>=4.6.0" com "opencv-python-headless>=4.6.0" (ajuste a versão conforme necessário).
5. Commit e push suas alterações:

   git add pyproject.toml
   git commit -m "Switch to opencv-python-headless"
   git push origin custom-opencv
   

6. Instalar usando pip com o git+https sintaxe, apontando para sua branch:

   pip install git+https://github.com/YOUR_USERNAME/ultralytics.git@custom-opencv
   

Este método garante que seu conjunto de dependências personalizado seja usado sempre que você instalar a partir deste URL específico. Consulte o Método 4 para usar isso em um requirements.txt ficheiro.

Semelhante ao método padrão "Git Clone" para desenvolvimento, você pode clonar o repositório localmente, modificar os arquivos de dependência antes da instalação e, em seguida, instalar no modo editável.

1. Clone o repositório Ultralytics:

   git clone https://github.com/ultralytics/ultralytics
   cd ultralytics
   

2. Modificar pyproject.toml: Edite o arquivo para fazer as alterações desejadas. Por exemplo, use sed (no Linux/macOS) ou um editor de texto para substituir opencv-python com opencv-python-headless. Usando sed (verifique a linha exata em pyproject.toml primeiro):

   # Example: Replace the line starting with "opencv-python..."
   # Adapt the pattern carefully based on the current file content
   sed -i'' -e 's/^\s*"opencv-python>=.*",/"opencv-python-headless>=4.8.0",/' pyproject.toml
   

   Ou edite manualmente pyproject.toml para alterar "opencv-python>=... para "opencv-python-headless>=...".
3. Instalar o pacote em modo editável (-e). O Pip agora usará seu pyproject.toml para resolver e instalar as dependências:

   pip install -e .
   

Esta abordagem é útil para testar alterações locais nas dependências ou configurações de construção antes de commitá-las ou para configurar ambientes de desenvolvimento específicos.

Se você gerencia as dependências do seu projeto usando um requirements.txt arquivo, você pode especificar seu fork Ultralytics personalizado diretamente nele. Isso garante que qualquer pessoa que configurar o projeto obtenha sua versão específica com suas dependências modificadas (como opencv-python-headless).

1. Criar ou editar requirements.txt: Adicione uma linha apontando para o seu fork e branch personalizados (conforme preparado no Método 2).
   requirements.txt

   # Core dependencies
   numpy
   matplotlib
   polars
   pyyaml
   Pillow
   psutil
   requests>=2.23.0
   torch>=1.8.0 # Or specific version/variant
   torchvision>=0.9.0 # Or specific version/variant
   
   # Install ultralytics from a specific git commit or branch
   # Replace YOUR_USERNAME and custom-branch with your details
   git+https://github.com/YOUR_USERNAME/ultralytics.git@custom-branch
   
   # Other project dependencies
   flask
   # ... etc
   

   Nota: Não precisa de listar as dependências já exigidas pelo seu personalizado ultralytics fork (como opencv-python-headless) aqui, pois o pip os instalará com base no fork pyproject.toml.
2. Instalar dependências do ficheiro:

   pip install -r requirements.txt
   

Este método integra-se perfeitamente com os fluxos de trabalho padrão de gerenciamento de dependências de projetos Python, ao mesmo tempo que permite fixar ultralytics para a sua fonte Git personalizada.

Ultralytics yolo comandos usam a seguinte sintaxe:

yolo TASK MODE ARGS

Veja todos os ARGS no completo Guia de Configuração ou com o yolo cfg comando da CLI.

Treine um modelo de detecção por 10 épocas com uma taxa de aprendizado inicial de 0,01:

yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01

Preveja um vídeo do YouTube usando um modelo de segmentação pré-treinado no tamanho de imagem 320:

yolo predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320

Validar um modelo de detecção pré-treinado com um tamanho de lote de 1 e tamanho de imagem de 640:

yolo val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640

Exporte um modelo de classificação YOLOv11n para o formato ONNX com um tamanho de imagem de 224x128 (sem necessidade de TASK):

yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128

Contar objetos em um vídeo ou transmissão ao vivo usando YOLO11:

yolo solutions count show=True

yolo solutions count source="path/to/video.mp4" # specify video file path

Monitore os exercícios de treino usando um modelo de pose YOLO11:

yolo solutions workout show=True

yolo solutions workout source="path/to/video.mp4" # specify video file path

# Use keypoints for ab-workouts
yolo solutions workout kpts="[5, 11, 13]" # left side
yolo solutions workout kpts="[6, 12, 14]" # right side

Use o YOLO11 para contar objetos em uma fila ou região designada:

yolo solutions queue show=True

yolo solutions queue source="path/to/video.mp4" # specify video file path

yolo solutions queue region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]" # configure queue coordinates

Realize detecção de objetos, segmentação de instâncias ou estimativa de pose em um navegador da web usando Streamlit:

yolo solutions inference

yolo solutions inference model="path/to/model.pt" # use model fine-tuned with Ultralytics Python package

Execute comandos especiais para ver a versão, visualizar as configurações, executar verificações e muito mais:

yolo help
yolo checks
yolo version
yolo settings
yolo copy-cfg
yolo cfg
yolo solutions help

Use o python para visualizar suas configurações importando o settings objeto do ultralytics módulo. Imprima e retorne as configurações com estes comandos:

from ultralytics import settings

# View all settings
print(settings)

# Return a specific setting
value = settings["runs_dir"]

A interface de linha de comando permite que você verifique suas configurações com:

yolo settings

Em Python, use o update no objeto settings objeto:

from ultralytics import settings

# Update a setting
settings.update({"runs_dir": "/path/to/runs"})

# Update multiple settings
settings.update({"runs_dir": "/path/to/runs", "tensorboard": False})

# Reset settings to default values
settings.reset()

Para modificar as configurações usando a interface de linha de comando:

# Update a setting
yolo settings runs_dir='/path/to/runs'

# Update multiple settings
yolo settings runs_dir='/path/to/runs' tensorboard=False

# Reset settings to default values
yolo settings reset