Instalar Ultralytics

Instalar ou atualizar o ultralytics utilizando o pip, executando pip install -U ultralytics. Para mais pormenores sobre o ultralytics pacote, visite a página Índice de Pacotes Python (PyPI).

# Install the ultralytics package from PyPI
pip install ultralytics

Também é possível instalar ultralytics diretamente do Ultralytics Repositório GitHub. Isso pode ser útil se você quiser a versão de desenvolvimento mais recente. Certifique-se de que tem a ferramenta de linha de comandos Git instalada e, em seguida, 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 obter mais detalhes, visite Anaconda. O repositório de matéria-prima Ultralytics para atualizar o pacote conda está disponível no 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 do Docker Conda

Ultralytics As imagens do Conda Docker também estão disponíveis em DockerHub. Estas imagens são baseadas em Miniconda3 e fornecem uma forma direta de começar a utilizar ultralytics num 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

Clonar o Ultralytics Repositório GitHub se estiver interessado em contribuir para o desenvolvimento ou quiser experimentar o código-fonte mais recente. Após a clonagem, navegue para o diretório e instale o pacote em modo editável -e utilizando o 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 num contentor isolado, garantindo um desempenho consistente em vários ambientes. Ao selecionar um dos pacotes ultralytics imagens de Centro de DockerCom o Ultralytics, evita a complexidade da instalação local e obtém acesso a um ambiente de trabalho verificado. Ultralytics oferece cinco imagens Docker principais suportadas, cada uma concebida para uma elevada compatibilidade e eficiência:

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

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 contentor Docker com a última versão do ultralytics imagem. A -it atribuem um pseudo-TTY e mantêm o stdin aberto, permitindo a interação com o contentor. As --ipc=host define o espaço de nomes IPC (Inter-Process Communication) para o host, o que é essencial para a partilha de memória entre processos. A flag --gpus all permite o acesso a todas as GPUs disponíveis dentro do contentor, crucial para tarefas que requerem computação GPU .

Nota: Para trabalhar com ficheiros no seu computador local dentro do contentor, utilize os volumes do Docker para montar um diretório local no contentor:

# 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

Substituir /path/on/host com o caminho do diretório na sua máquina local, e /path/in/container com o caminho desejado dentro do contentor Docker.

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

É possível instalar o ultralytics sem quaisquer dependências usando o comando --no-deps flag. Para isso, é necessário instalar manualmente todas as dependências necessárias posteriormente.

1. Instalar ultralytics núcleo:

   pip install ultralytics --no-deps
   

2. Instalar manualmente as dependências: É necessário instalar todos os pacotes necessários listados no pyproject.toml substituindo ou modificando as versões conforme necessário. Para o exemplo do OpenCV sem cabeça:

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

Se precisar de modificações personalizadas persistentes (como utilizar sempre opencv-python-headless), pode bifurcar o repositório Ultralytics , fazer alterações no pyproject.toml ou outro código, e instalar a partir da sua bifurcação.

1. Transfira o repositório GitHub doUltralytics para a sua própria conta GitHub.
2. Clone o seu garfo localmente:

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

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

   git checkout -b custom-opencv
   

4. Modificar pyproject.toml: Aberto pyproject.toml num editor de texto e substitua a linha que contém "opencv-python>=4.6.0" com "opencv-python-headless>=4.6.0" (ajustar a versão conforme necessário).
5. Confirmar e enviar as suas alterações:

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

6. Instalar utilizando o pip com o git+https apontando para o seu ramo:

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

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

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

1. Clone o repositório Ultralytics :

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

2. Modificar pyproject.toml: Edite o ficheiro para fazer as alterações desejadas. Por exemplo, utilize sed (em Linux/macOS) ou um editor de texto para substituir opencv-python com opencv-python-headless. Utilizar sed (verificar a linha exacta 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 editar manualmente pyproject.toml para mudar "opencv-python>=... para "opencv-python-headless>=...".
3. Instalar o pacote em modo editável (-e). O Pip irá agora usar o seu pyproject.toml para resolver e instalar dependências:

   pip install -e .
   

Esta abordagem é útil para testar alterações locais a dependências ou configurações de compilação antes de as confirmar ou para configurar ambientes de desenvolvimento específicos.

Se você gerencia as dependências do seu projeto usando um requirements.txt pode especificar a sua bifurcação personalizada Ultralytics diretamente no mesmo. Isso garante que qualquer pessoa que configure o projeto receba sua versão específica com suas dependências modificadas (como opencv-python-headless).

1. Criar ou editar requirements.txt: Adicione uma linha que aponte para a sua bifurcação e ramo personalizados (conforme preparado no Método 2).
   requisitos.txt

   # Core dependencies
   numpy
   matplotlib
   pandas
   pyyaml
   Pillow
   psutil
   requests>=2.23.0
   tqdm
   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 é necessário listar as dependências já exigidas pelo seu ultralytics garfo (como opencv-python-headless) aqui, pois o pip irá instalá-los com base no fork pyproject.toml.
2. Instalar dependências do ficheiro:

   pip install -r requirements.txt
   

Este método integra-se perfeitamente nos fluxos de trabalho padrão de gestão de dependências de projectos Python , permitindo-lhe fixar ultralytics para a sua fonte Git personalizada.

Ultralytics yolo utilizam a seguinte sintaxe:

yolo TASK MODE ARGS

Ver tudo ARGS na íntegra Guia de configuração ou com o yolo cfg CLI comando.

Treinar um modelo de deteção para 10 épocas com uma taxa de aprendizagem inicial de 0,01:

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

Prever um vídeo do YouTube utilizando 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 deteção pré-treinado com um tamanho de lote de 1 e um tamanho de imagem de 640:

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

Exportar um modelo de classificação YOLOv11n para o formato ONNX com um tamanho de imagem de 224x128 (não é necessário TASK):

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

Contar objectos num vídeo ou numa transmissão em direto utilizando o YOLO11:

yolo solutions count show=True

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

Monitorize os exercícios de treino utilizando 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

Utilize YOLO11 para contar objectos numa 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

Efectue a deteção de objectos, a segmentação de instâncias ou a estimativa de pose num navegador Web utilizando o 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, ver definições, executar verificações e muito mais:

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

Utilize Python para visualizar as suas definições importando o settings objeto do ultralytics módulo. Imprimir e devolver definiçõ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 comandos permite-lhe verificar as suas definições com:

yolo settings

Em Python, utilize a opção update no método 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 definições utilizando a interface da linha de comandos:

# 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