Início rápido

Q: Can I install Ultralytics YOLO using conda?

Sim, você pode instalar Ultralytics YOLO usando conda executando: Este método é uma excelente alternativa ao pip e garante a compatibilidade com outros pacotes no seu ambiente. Para ambientes CUDA , é melhor instalar ultralytics, pytorch, e pytorch-cuda simultaneamente para resolver quaisquer conflitos: Para obter mais instruções, visite o guia de início rápido do Conda.

Instalar Ultralytics

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

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

Instalar

Instalação do Pip (recomendado)Instalação do CondaClone do GitDocker

Instalar o ultralytics utilizando o pip, ou atualizar uma instalação existente executando pip install -U ultralytics. Visite o Python Package Index (PyPI) para obter mais detalhes sobre o ultralytics pacote: https://pypi.org/project/ultralytics/.

# Install the ultralytics package from PyPI
pip install ultralytics

Também é possível instalar o ultralytics diretamente a partir do pacote GitHub repositório. 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 no seu sistema. O @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. Visite Anaconda para obter 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/.

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

Nota

Se estiver 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 último para permitir que se sobreponha ao CPU-specific pytorch pacote, 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ç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 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 .

Utilize o Docker para executar sem esforço o ultralytics num contentor isolado, assegurando um desempenho consistente e suave em vários ambientes. Ao escolher um dos pacotes ultralytics imagens de Centro de DockerO 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:

Dockerfile: GPU imagem recomendada para a formação.
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 CPU-apenas adequada para inferência e ambientes sem GPUs.
Dockerfile-jetson: Adaptado para dispositivos NVIDIA Jetson, integrando o suporte GPU optimizado para estas 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 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 atribui um pseudo-TTY e mantém o stdin aberto, permitindo-lhe 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 a partilha de 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 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

Alterar /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 acessibilidade.

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

Ver o ultralytics pyproject.toml para uma lista de dependências. Note 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 instale primeiro PyTorch seguindo as instruções em https://pytorch.org/get-started/locally.

Utilizar 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 . Pode simplesmente executar todas as tarefas a partir do terminal com o comando yolo comando. Verificar o CLI Guia para saber mais sobre como usar YOLO a partir da linha de comando.

Exemplo

SintaxeComboioPreverValExportaçãoEspecial

Ultralytics yolo utilizam a seguinte sintaxe:

yolo TASK MODE ARGS

TASK (opcional) é um dos (detetar, segmento, classificar, pose, obb)
MODE (obrigatório) é um dos (comboio, val, prever, exportação, pista, referência)
ARGS (opcional) são arg=value pares como imgsz=640 que se sobrepõem às predefinições.

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 learning_rate 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

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

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

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

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

Execute comandos especiais para ver a versão, visualizar definições, efetuar 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 pares, divididos por um sinal de igual = e delimitado por espaços entre pares. Não utilizar -- prefixos de argumentos ou vírgulas , entre argumentos.

yolo predict model=yolo11n.pt imgsz=640 conf=0.25 ✅
yolo predict model yolo11n.pt imgsz 640 conf 0.25 ❌ (em falta =)
yolo predict model=yolo11n.pt, imgsz=640, conf=0.25 ❌ (não utilizar ,)
yolo predict --model yolo11n.pt --imgsz 640 --conf 0.25 ❌ (não utilizar --)

CLI Guia

Utilizar Ultralytics com Python

YOLOA interface Python permite uma integração perfeita nos seus 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 YOLO'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. Consulte o GuiaPython para saber mais sobre como usar YOLO em seus projetos Python .

Exemplo

from ultralytics import YOLO

# Create a new YOLO model from scratch
model = YOLO("yolo11n.yaml")

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo11n.pt")

# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.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 que permite um controlo minucioso das suas 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 JSON no diretório de configuração do utilizador do ambiente e podem ser visualizadas ou modificadas diretamente no ambiente Python ou através da interface da linha de comandos (CLI).

Inspeção de definições

Para obter informações sobre a configuração atual das suas definições, pode visualizá-las diretamente:

Ver definições

PythonCLI

Pode utilizar Python para ver as suas definições. Comece por importar o ficheiro settings objeto do ultralytics módulo. Imprimir e devolver 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-lhe verificar as suas definições com um simples comando:

yolo settings

Modificar definições

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

Atualizar definições

PythonCLI

No ambiente Python , chame a função update no método settings para alterar as suas 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 preferir utilizar a interface de linha de comandos, os seguintes comandos permitir-lhe-ão modificar as suas 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 seguinte apresenta 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ãodo pip Ultralytics )
`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 é necessário sincronizar análises e falhas com o HUB
`api_key`	`''`	`str`	Ultralytics Chave da API do HUB
`clearml`	`True`	`bool`	Se deve ser utilizado o ClearML registo
`comet`	`True`	`bool`	Utilizar ou não o Comet ML para o registo e visualização de experiências
`dvc`	`True`	`bool`	Se deve utilizar o DVC para o acompanhamento de experiências e o controlo de versões
`hub`	`True`	`bool`	Se deve ser utilizada a integração do Ultralytics HUB
`mlflow`	`True`	`bool`	Se deve ser utilizado o MLFlow para o acompanhamento de experiências
`neptune`	`True`	`bool`	Se deve ser utilizado Neptune para rastreio de experiências
`raytune`	`True`	`bool`	Se deve ser utilizado o Ray Tune para afinação de hiperparâmetros
`tensorboard`	`True`	`bool`	Se deve utilizar o TensorBoard para visualização
`wandb`	`True`	`bool`	Se deve ser utilizado o Weights & Biases registo
`vscode_msg`	`True`	`bool`	Quando o terminal VS Code é detectado, ativa o pedido de transferência da extensão Ultralytics-Snippets.

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

FAQ

Como instalo o Ultralytics usando o pip?

Para instalar o Ultralytics com o pip, execute o seguinte comando:

pip install ultralytics

Para a última versão estável, isso instalará o ultralytics diretamente a partir do Python Package Index (PyPI). Para mais detalhes, visite o ultralytics pacote no PyPI.

Em alternativa, pode instalar a versão de desenvolvimento mais recente diretamente a partir do GitHub:

pip install git+https://github.com/ultralytics/ultralytics.git

Certifique-se de que tem a ferramenta de linha de comandos Git instalada no seu sistema.

Posso instalar Ultralytics YOLO utilizando conda?

Sim, pode instalar Ultralytics YOLO utilizando conda, executando:

conda install -c conda-forge ultralytics

Este método é uma excelente alternativa ao pip e assegura a compatibilidade com outros pacotes no seu ambiente. Para ambientes CUDA , é melhor instalar ultralytics, pytorche pytorch-cuda simultaneamente para resolver eventuais conflitos:

conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics

Para obter mais instruções, visite o guia de início rápido do Conda.

Quais são as vantagens de utilizar o Docker para executar Ultralytics YOLO ?

Usando o Docker para executar Ultralytics YOLO fornece um ambiente isolado e consistente, garantindo um desempenho suave em diferentes sistemas. Também elimina a complexidade da instalação local. As imagens oficiais do Docker de Ultralytics estão disponíveis no Docker Hub, com diferentes variantes adaptadas para os ambientes GPU, CPU, ARM64, NVIDIA Jetson e Conda. Abaixo estão os comandos para extrair e executar a imagem mais recente:

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

# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all ultralytics/ultralytics:latest

Para obter instruções mais detalhadas sobre o Docker, consulte o guia de início rápido do Docker.

Como é que clono o repositório Ultralytics para desenvolvimento?

Para clonar o repositório Ultralytics e configurar um ambiente de desenvolvimento, utilize os seguintes passos:

# 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 .

Esta abordagem permite-lhe contribuir para o projeto ou experimentar o código-fonte mais recente. Para mais pormenores, visite o repositórioUltralytics do GitHub.

Por que razão devo utilizar Ultralytics YOLO CLI ?

A interface de linha de comandos Ultralytics YOLO (CLI) simplifica a execução de tarefas de deteção de objectos sem necessitar de código Python . Pode executar comandos de linha única para tarefas como formação, validação e previsão diretamente a partir do seu terminal. A sintaxe básica para yolo comandos é:

yolo TASK MODE ARGS

Por exemplo, para treinar um modelo de deteção com parâmetros especificados:

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

Consulte o guia completo CLI para explorar mais comandos e exemplos de utilização.

📅C riado há 1 ano ✏️ Atualizado há 1 mês