Salta para o conteúdo

Início rápido

Instala Ultralytics

Ultralytics fornece vários métodos de instalação, incluindo pip, conda e Docker. Instala YOLOv8 através do ultralytics pip para a última versão estável ou clonando o pacote Ultralytics Repositório GitHub para obteres a versão mais actualizada. O Docker pode ser utilizado para executar o pacote num contentor isolado, evitando a instalação local.



Observa: Ultralytics YOLO Guia de início rápido

Instala

Instala o ultralytics usando pip, ou atualiza uma instalação existente executando pip install -U ultralytics. Visita o Python Package Index (PyPI) para mais detalhes sobre o ultralytics pacote: https://pypi.org/project/ultralytics/.

Versão PyPI Transferências

# Install the ultralytics package from PyPI
pip install ultralytics

Também podes instalar o ultralytics diretamente do pacote GitHub repositório. Isto pode ser útil se quiseres a versão de desenvolvimento mais recente. Certifica-te de que tens a ferramenta de linha de comandos Git instalada no teu sistema. A ferramenta @main instala o comando main e pode ser modificado para outro ramo, ou seja @my-branchou removido por completo para que a predefinição seja main ramo.

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

O Conda é um gestor de pacotes alternativo ao pip que também pode ser utilizado para a instalação. Visita o Anaconda para mais detalhes em https://anaconda.org/conda-forge/ultralytics. Ultralytics repositório feedstock para atualizar o pacote conda está em https://github.com/conda-forge/ultralytics-feedstock/.

Receita de Conda Transferências Conda Versão Conda Plataformas Conda

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

Nota

Se estiveres a instalar num ambiente CUDA, a melhor prática é instalar ultralytics, pytorch e pytorch-cuda no mesmo comando para permitir que o gestor de pacotes conda resolva quaisquer conflitos, ou então para instalar pytorch-cuda por último, para permitir que ele substitua o pytorch se necessário.

# 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 são uma forma simples de começares 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

Clona o ultralytics se estiveres interessado em contribuir para o desenvolvimento ou quiseres experimentar o código-fonte mais recente. Após a clonagem, navega para o diretório e instala 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 .

Utiliza o Docker para executar sem esforço o ultralytics num contentor isolado, garantindo um desempenho consistente e suave em vários ambientes. Ao escolher um dos pacotes oficiais do ultralytics imagens de Docker HubO Ultralytics oferece 5 imagens Docker principais suportadas, cada uma concebida para proporcionar uma elevada compatibilidade e eficiência para diferentes plataformas e casos de utilização:

Docker Pulls

  • Dockerfile: Imagem de GPU recomendada para treinamento.
  • Dockerfile-arm64: Optimizado para a arquitetura ARM64, permitindo a implementação em dispositivos como o Raspberry Pi e outras plataformas baseadas em ARM64.
  • Dockerfile-cpu: Versão baseada no Ubuntu apenas 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 a instalação conda do pacote ultralytics .

Abaixo estão os comandos para obteres 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 imagem -it atribui um pseudo-TTY e mantém o stdin aberto, permitindo-te interagir com o contentor. O sinalizador --ipc=host define o espaço de nomes IPC (Inter-Process Communication) para o host, o que é essencial para compartilhar memória entre processos. A flag --gpus all permite o acesso a todas as GPUs disponíveis dentro do contentor, o que é crucial para tarefas que requerem computação GPU.

Nota: Para trabalhar com ficheiros no teu computador local dentro do contentor, utiliza os volumes 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

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

Para uso avançado do Docker, fica à vontade para explorar o Ultralytics Docker Guide.

Vê o ultralytics requisitos.txt para uma lista de dependências. Nota que todos os exemplos acima instalam todas as dependências necessárias.

Dica

PyTorch Os requisitos variam consoante o sistema operativo e os requisitos CUDA, pelo que se recomenda que instales primeiro o PyTorch seguindo as instruções em https://pytorch.org/get-started/locally.

PyTorch Instruções de instalação

Utiliza Ultralytics com CLI

A interface de linha de comando Ultralytics (CLI) permite comandos simples de linha única sem a necessidade de um ambiente Python . CLI não requer personalização ou código Python . Podes simplesmente executar todas as tarefas a partir do terminal com o comando yolo comanda. Verifica o CLI Guia para saber mais sobre como usar YOLOv8 a partir da linha de comando.

Exemplo

Ultralytics yolo utiliza a seguinte sintaxe:

yolo TASK MODE ARGS

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

Treina um modelo de deteção para 10 épocas com uma learning_rate inicial de 0,01

yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01

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

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

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

yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640

Exporta um modelo de classificação YOLOv8n para o formato ONNX com o tamanho de imagem 224 por 128 (não é necessária nenhuma TASK)

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

Executa comandos especiais para ver a versão, ver as definições, executar verificações e muito mais:

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

Aviso

Os argumentos devem ser passados como arg=val divididos por um sinal de igual = e delimitado por espaços entre pares. Não utilizes -- prefixos de argumentos ou vírgulas , entre argumentos.

  • yolo predict model=yolov8n.pt imgsz=640 conf=0.25 ✅
  • yolo predict model yolov8n.pt imgsz 640 conf 0.25 ❌ (falta-te =)
  • yolo predict model=yolov8n.pt, imgsz=640, conf=0.25 ❌ (não uses ,)
  • yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25 ❌ (não uses --)

CLI Guia

Utiliza Ultralytics com Python

YOLOv8A interface Python permite uma integração perfeita nos teus projectos Python , facilitando o carregamento, a execução e o processamento dos resultados do modelo. Concebida com simplicidade e facilidade de utilização em mente, a interface Python permite aos utilizadores implementar rapidamente a deteção, segmentação e classificação de objectos nos seus projectos. Isto torna a interface YOLOv8's Python uma ferramenta inestimável para quem procura incorporar estas funcionalidades nos seus projectos Python .

Por exemplo, os utilizadores podem carregar um modelo, treiná-lo, avaliar o seu desempenho num conjunto de validação e até exportá-lo para o formato ONNX com apenas algumas linhas de código. Consulta o GuiaPython para saberes mais sobre como utilizar YOLOv8 nos teus projectos Python .

Exemplo

from ultralytics import YOLO

# Create a new YOLO model from scratch
model = YOLO('yolov8n.yaml')

# Load a pretrained YOLO model (recommended for training)
model = YOLO('yolov8n.pt')

# Train the model using the 'coco128.yaml' dataset for 3 epochs
results = model.train(data='coco128.yaml', epochs=3)

# Evaluate the model's performance on the validation set
results = model.val()

# Perform object detection on an image using the model
results = model('https://ultralytics.com/images/bus.jpg')

# Export the model to ONNX format
success = model.export(format='onnx')

Python Guia

Ultralytics Definições

A biblioteca Ultralytics fornece um poderoso sistema de gestão de definições para permitir um controlo fino das tuas experiências. Ao fazer uso da biblioteca SettingsManager alojado no ultralytics.utils os utilizadores podem facilmente aceder e alterar as suas definições. Estas são armazenadas num ficheiro YAML e podem ser visualizadas ou modificadas diretamente no ambiente Python ou através da interface de linha de comandos (CLI).

Inspecionar configurações

Para teres uma ideia da configuração atual das tuas definições, podes visualizá-las diretamente:

Ver definições

Podes utilizar Python para ver as tuas definições. Começa por importar o ficheiro settings objeto do ultralytics módulo. Imprime e devolve as definições utilizando os seguintes comandos:

from ultralytics import settings

# View all settings
print(settings)

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

Em alternativa, a interface de linha de comandos permite-te verificar as tuas definições com um simples comando:

yolo settings

Modificar definições

Ultralytics permite que os utilizadores modifiquem facilmente as suas definições. As alterações podem ser efectuadas das seguintes formas:

Atualizar definições

No ambiente Python , chama o comando update no método settings para alterar as tuas definições:

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

Se preferires utilizar a interface de linha de comandos, os seguintes comandos permitem-te modificar as tuas definições:

# 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

Compreender as definições

A tabela abaixo fornece uma visão geral das definições disponíveis para ajuste em Ultralytics. Cada definição é descrita juntamente com um valor de exemplo, o tipo de dados e uma breve descrição.

Nome Exemplo de valor Tipo de dados Descrição
settings_version '0.0.4' str Ultralytics versãodas definições (diferente da versão Ultralytics pip )
datasets_dir '/path/to/datasets' str O diretório onde os conjuntos de dados são armazenados
weights_dir '/path/to/weights' str O diretório onde são armazenados os pesos do modelo
runs_dir '/path/to/runs' str O diretório onde são armazenadas as execuções da experiência
uuid 'a1b2c3d4' str O identificador único das definições actuais
sync True bool Se queres sincronizar análises e falhas com HUB
api_key '' str Ultralytics HUB Chave API
clearml True bool Se deves utilizar o registo ClearML
comet True bool Utiliza ou não o Comet ML para o acompanhamento e visualização de experiências
dvc True bool Se deves utilizar o DVC para o acompanhamento de experiências e o controlo de versões
hub True bool Se deves utilizar a Ultralytics HUB integração
mlflow True bool Se deves utilizar o MLFlow para o acompanhamento de experiências
neptune True bool Se deves utilizar o Neptune para o acompanhamento de experiências
raytune True bool Se deves utilizar o Ray Tune para a afinação de hiperparâmetros
tensorboard True bool Se queres utilizar o TensorBoard para visualização
wandb True bool Se deves utilizar o registo Weights & Biases

À medida que navega pelos seus projectos ou experiências, não te esqueças de rever estas definições para garantir que estão configuradas da melhor forma para as suas necessidades.



Criado em 2023-11-12, Atualizado em 2024-02-03
Autores: glenn-jocher (7), chr043416@gmail.com (2), Laughing-q (1), AyushExel (1)

Comentários