Começar

Como instalar Ultralytics YOLO com Conda

Ultralytics package for Conda from conda-forge

Este guia explica como configurar um ambiente Conda para seus projetos Ultralytics. Conda é um sistema de código aberto para gerenciamento de pacotes e ambientes e uma alternativa ao pip para instalar pacotes e dependências. Seus ambientes isolados o tornam especialmente adequado para projetos de ciência de dados e aprendizado de máquina.

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

Este guia explica como criar um ambiente com Ultralytics, executar inferências, usar a imagem Docker do Conda e acelerar as instalações com libmamba.

Pré-requisitos#

Deves ter o Anaconda ou o Miniconda instalado no teu sistema. Caso contrário, transfere e instala a partir de Anaconda ou Miniconda.

Instalar Ultralytics#

Cria um novo ambiente Conda com Ultralytics a partir do canal conda-forge e, em seguida, ativa-o. Instala Python, Ultralytics e torchvision (que não é uma dependência do pacote conda-forge) no mesmo comando para que o conda resolva em conjunto versões atuais e compatíveis:

conda create --name ultralytics-env -c conda-forge python=3.11 ultralytics torchvision -y
conda activate ultralytics-env
Instalar num ambiente CUDA

Se estiveres a trabalhar num ambiente com CUDA, adiciona o metapacote pytorch-gpu do conda-forge ao mesmo comando para que o conda resolva uma compilação do PyTorch com suporte a CUDA:

conda create --name ultralytics-env -c conda-forge python=3.11 ultralytics torchvision pytorch-gpu -y
conda activate ultralytics-env

Nota sobre o ambiente ROCm (GPU AMD, Linux)#

Para aceleração de GPU AMD em Linux com ROCm, os wheels PyTorch ROCm não estão disponíveis através do Conda e têm de ser instalados com pip. Usa um ambiente Conda para isolamento e, em seguida, instala PyTorch ROCm e Ultralytics através de pip:

conda create --name ultralytics-rocm python=3.12 -y
conda activate ultralytics-rocm
pip install "torch[device-all]" "torchvision[device-all]" --index-url https://stable.repo.amd.com/rocm/whl-next/
pip install ultralytics

Consulta a página Começar com PyTorch para veres as versões ROCm suportadas e o guia de GPU AMD para configurares a inferência MIGraphX, que requer Python 3.11 ou posterior em Linux x86_64.

Usar Ultralytics#

Com Ultralytics instalado, podes executar deteção de objetos, segmentação de instâncias e outras tarefas de visão. Por exemplo, para executar a inferência numa imagem:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # inicializar o modelo
results = model("path/to/image.jpg")  # executar a inferência
results[0].show()  # mostrar os resultados da primeira imagem

Imagem Docker do Conda da Ultralytics#

O Dockerfile do Conda usa PyTorch 2.13, torchvision 0.28 e CUDA 13.0 do conda-forge. As versões do conda-forge podem ser disponibilizadas mais tarde do que as versões PyTorch pip usadas na imagem GPU padrão. A publicação automatizada de latest-conda está desativada, por isso compila localmente a imagem atual:

git clone https://github.com/ultralytics/ultralytics
cd ultralytics
t=ultralytics-conda:local
sudo docker build -f docker/Dockerfile-conda -t $t .

Executa a imagem:

# Run the Ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --device nvidia.com/gpu=all $t                         # all GPUs
sudo docker run -it --ipc=host --device nvidia.com/gpu=2 --device nvidia.com/gpu=3 $t # specify GPUs

Em Linux, os pedidos de dispositivos CDI requerem Docker >= 28.2.0 e NVIDIA Container Toolkit >= 1.18. A flag antiga --gpus all pode fazer perder o acesso à GPU após o recarregamento dos daemons do anfitrião; atualiza, por isso, os anfitriões Linux mais antigos e usa --device. Consulta o Guia de início rápido do Docker para mais informações.

Acelerar a instalação com Libmamba#

libmamba é um resolvedor rápido, multiplataforma e consciente das dependências que substitui o resolvedor clássico do Conda. O Conda 23.10 e versões posteriores já usam libmamba como resolvedor predefinido, por isso a maioria das instalações é mais rápida logo de início.

Se estiveres a usar uma versão mais antiga do Conda, podes ativar libmamba manualmente:

  1. Primeiro, instala o pacote conda-libmamba-solver:

    conda install conda-libmamba-solver
  2. Em seguida, configura o Conda para usar libmamba como resolvedor:

    conda config --set solver libmamba

Configuraste com sucesso um ambiente Conda, instalaste o pacote Ultralytics e estás agora pronto para explorar as respetivas funcionalidades. Para tutoriais e exemplos mais avançados, consulta a documentação da Ultralytics.

Perguntas frequentes#

  • Cria o ambiente com Python e Ultralytics do canal conda-forge num único comando, para que conda resolva as dependências em conjunto; em seguida, ativa-o:

    conda create --name ultralytics-env -c conda-forge python=3.11 ultralytics torchvision -y
    conda activate ultralytics-env
  • Conda é um sistema de gestão de pacotes e ambientes que oferece várias vantagens em relação ao pip. Gere dependências de forma eficiente e garante a compatibilidade de todas as bibliotecas necessárias. Os ambientes isolados do Conda evitam conflitos entre pacotes, o que é fundamental em projetos de ciência de dados e machine learning. Além disso, Conda suporta a distribuição de pacotes binários, acelerando o processo de instalação.

  • Sim. Cria o ambiente com ultralytics e o metapacote pytorch-gpu do conda-forge no mesmo comando, para que uma compilação de PyTorch com suporte para CUDA seja resolvida em conjunto:

    conda create --name ultralytics-env -c conda-forge python=3.11 ultralytics torchvision pytorch-gpu -y
    conda activate ultralytics-env

    Esta configuração ativa a aceleração por GPU, essencial para tarefas exigentes, como o treino e a inferência de modelos de aprendizagem profunda. Para saber mais, consulta o guia de instalação da Ultralytics.

  • O Dockerfile do Conda fornece um ambiente conda-forge isolado com PyTorch com CUDA. Segue as instruções de compilação local e, em seguida, executa-o com as opções de GPU aí indicadas. A imagem de GPU padrão publicada e outras alternativas estão listadas no guia do Docker.

  • O Conda 23.10 e versões posteriores já usam o resolvedor rápido libmamba por predefinição. Nas versões mais antigas do Conda, podes ativá-lo manualmente instalando primeiro o pacote conda-libmamba-solver:

    conda install conda-libmamba-solver

    Em seguida, configura o Conda para usar libmamba como resolvedor:

    conda config --set solver libmamba

    Esta configuração proporciona uma gestão de pacotes mais rápida e eficiente.

Comentários6

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

  1. najwazkiyahhGitHub

    Hi! I'm the new to using YOLO. I have python 3.12 on my laptop because my previous exam need it-the latest version of python. I want to install ultralytics YOLOv11, should I downgrade my python version from 3.12 into 3.11? Or I should downgrade my python version to the recommended requirement, 3.8? Thank you, hope you (anybody) can answer my confusion.

    1. Glenn JocherUltralytics

      @najwazkiyahh you don't need to downgrade your system Python! 😊 Simply create a Conda environment with Python 3.11 using conda create --name yolo_env python=3.11, then activate it and install Ultralytics. This keeps your existing Python 3.12 intact while giving you a compatible YOLO11 environment. For full steps, see the Conda Quickstart Guide for Ultralytics.

      We recommend this approach as it maintains version isolation while allowing you to work with both Python versions seamlessly. Welcome to the YOLO community! 🚀

  2. MalvinlamGitHub

    Hi is there a way to install the yolov8 dependencies using Anaconda prompt to the virtual environment other than pip install ultralytics? For example I already downloaded the ultralytics package from GitHub and opened it as project folder using PyCharm. Is there a way to only install the required libraries?

    1. Glenn JocherUltralytics(editado)

      @Malvinlam hi there! 👋

      Absolutely, you can install the required dependencies for Ultralytics using Conda without relying on pip install ultralytics. Here's a step-by-step guide to help you set up your Conda environment and install the necessary libraries:

      1. Create a New Conda Environment: First, create a new Conda environment with Python 3.11 (or your preferred version):

        conda create --name ultralytics-env python=3.11 -y
      2. Activate the Environment: Activate your newly created environment:

        conda activate ultralytics-env
      3. Install Required Libraries: The repository no longer has a requirements.txt; its dependencies are declared in pyproject.toml. From the root of your cloned repository, run:

        pip install -e .

        Alternatively, if you want to install specific packages manually, you can use:

        conda install -c conda-forge numpy pandas matplotlib opencv scikit-learn
        conda install -c pytorch pytorch torchvision torchaudio
      4. Note on CUDA Environment: If you're working in a CUDA-enabled environment, it's a good practice to install pytorch and pytorch-cuda together to resolve any conflicts:

        conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision torchaudio pytorch-cuda=11.8
      5. Using Ultralytics: With the dependencies installed, you can now start using Ultralytics. For example, to perform inference with YOLO26:

        from ultralytics import YOLO
        
        model = YOLO("yolo26n.pt")  # initialize model
        results = model("path/to/image.jpg")  # perform inference
        results[0].show()  # display results for the first image

      For more detailed instructions, you can refer to our Conda Quickstart Guide.

      If you encounter any issues or have further questions, feel free to ask. Happy coding! 😊

  3. nadinatorGitHub

    Does the python version have to be 3.8? Can it be a newer version? What would/wouldn't break if we used 3.11, for example (I'm thinking of the [ray]tuning feature)?

    1. Glenn JocherUltralytics

      Hey there! 😊

      You can definitely use Python versions newer than 3.8, including 3.11. However, it's important to note that while most features should work fine, there might be some compatibility issues with newer Python versions, especially with external libraries or specific features like [ray] tuning.

      If you're keen on using Python 3.11, I'd recommend testing the key functionalities you plan to use in your project to ensure everything runs smoothly. For the [ray] tuning feature, you might want to check Ray's documentation or GitHub issues for any known compatibility concerns with Python 3.11.

      Here's a quick example of how you might set up your environment with Python 3.11:

      conda create --name ultralytics-env python=3.11 -y
      conda activate ultralytics-env
      conda install -c conda-forge ultralytics

      And remember, if you encounter any issues, the Ultralytics community is here to help! 🚀