Este guia fornece instruções passo a passo para configurar o ambiente de desenvolvimento do framework YOLO (You Only Look Once) em sistemas Windows e Ubuntu. O objetivo é permitir a execução de modelos pré-treinados para detecção de objetos, segmentação de instâncias e estimativa de pose, bem como preparar o terreno para treinamentos personalizados. Requisitos de hardware: GPU NVIDIA com pelo menos 4GB de memória e 16GB de RAM.

1. Verificação da Configuração do Sistema

Antes de começar, confirme os componentes do seu sistema.

No Windows:

Abra o Gerenciador de Tarefas (Win+X). Navegue até a aba "Desempenho" e selecione a GPU NVIDIA listada (ex.: GPU 1). Verifique o modelo e a memória dedicada. Certifique-se de que a memória da GPU seja ≥4GB e a RAM do sistema ≥16GB.

No Ubuntu:

Execute o comando no terminal para obter informações da GPU:

nvidia-smi

Verifique o modelo e a memória disponível. Confirme que a memória da GPU é suficiente. 2. Obtenção do Código Fonte e Modelos Pré-treinados

Para ambos os sistemas:

Baixe o repositório oficial do Ultralytics. No Windows, pode-se usar um navegador ou, no Ubuntu, o terminal. Recomenda-se usar uma versão específica para consistência, como a v8.3.163.

No Ubuntu (via terminal):

git clone https://github.com/ultralytics/ultralytics.git
cd ultralytics
git checkout v8.3.163

Alternativamente, baixe o arquivo ZIP do repositório e extraia-o. Baixando Modelos Pré-treinados:

Visite a página de lançamentos dos assets do Ultralytics no GitHub. Procure por modelos desejados (ex.: yolov11n.pt para detecção, yolov11n-seg.pt para segmentação, yolov11n-pose.pt para pose). Coloque os arquivos .pt baixados no diretório raiz do repositório ultralytics extraído.

3. Instalação do Anaconda e Configuração de Espelhos

No Windows:

1. Baixe o instalador do Anaconda (versão 2024.06-1 ou similar) do site oficial ou de um espelho confiável.
2. Execute o instalador e siga as instruções padrão (opção "Just Me").
3. Abra o "Anaconda Prompt".
4. Configure o espelho do conda editando o arquivo .condarc: ``` notepad .condarc

   
   Cole o seguinte conteúdo e salve: ```
   channels:
     - defaults
   show_channel_urls: true
   default_channels:
     - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
     - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
     - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
   custom_channels:
     conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
     pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
   

5. Configure o espelho do pip: ``` pip config set global.index-url https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple

No Ubuntu:

1. Baixe o instalador do Anaconda (Linux) e torne-o executável: ``` chmod +x Anaconda3-2024.06-1-Linux-x86_64.sh

2. Execute o script de instalação e siga o assistente. Use o caminho padrão e digite yes quando perguntado sobre inicialização.

3. Carregue as variáveis de ambiente: ``` source ~/.bashrc

4. Desative a ativação automática do ambiente base: ``` conda config --set auto_activate_base false

5. Configure o espelho do conda usando um comando de append: ``` cat <> ~/.condarc channels:

   • defaults show_channel_urls: true default_channels:
   • https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
   • https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
   • https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2 custom_channels: conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud EOF

6. Configure o espelho do pip (mesmo comando do Windows).

7. Criação do Ambiente e Instalação de Dependências

Para ambos os sistemas (via terminal ou Anaconda Prompt):

1. Crie e ative um novo ambiente conda: ``` conda create -n yolo_env python=3.11 -y conda activate yolo_env

2. Instalação do PyTorch com CUDA: Verifique a versão CUDA do seu driver (nvidia-smi). Se for ≥11.8 (ou ≥12.1 para versões mais recentes), instale o PyTorch correspondente. Exemplo para CUDA 11.8: ``` pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/cu118

3. Verificação do PyTorch: Inicie o interpretador Python e verifique: ``` python -c "import torch; print('CUDA disponível:', torch.cuda.is_available()); print(torch.rand(2,2).cuda())"

   
   Se sair `True` e um tensor na GPU, a instalação está correta.
   

4. Instale o pacote ultralytics a partir do código fonte local: ``` cd /caminho/para/ultralytics pip install -e .

5. Teste Rápido: Execute um teste de detecção com o modelo pré-treinado: ``` yolo detect predict model=yolov11n.pt source='https://ultralytics.com/images/bus.jpg'

   
   Os resultados serão salvos no diretório `runs/detect/predict`.
   
   

6. Configuração da IDE e Exemplo de Código

Configuração do PyCharm:

1. Instale o PyCharm (Community ou Professional).
2. Abra o projeto do diretório ultralytics que você clonou/extraiu.
3. Nas configurações do projeto (Settings > Project > Python Interpreter), adicione um novo interpretador "Conda Environment". Selecione "Use existing environment" e escolha o ambiente yolo\_env que você criou.

Exemplo de Código para Detecção com Webcam (Windows/Ubuntu):

Crie um arquivo Python (ex.: detector\_webcam.py) com o seguinte código modificado:

import cv2
from ultralytics import YOLO

# Carrega um modelo YOLO pré-treinado
modelo_yolo = YOLO("yolov11n.pt")

# Fonte de vídeo: 0 para webcam integrada, 1 para webcam USB externa
fonte_video = 0

# Realiza inferência em tempo real
resultados = modelo_yolo(source=fonte_video, stream=True, verbose=False)

for deteccao in resultados:
    # Desenha as caixas de detecção no frame
    frame_anotado = deteccao.plot()
    cv2.imshow("Monitoramento em Tempo Real", frame_anotado)
    # Pressione 'q' para sair
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cv2.destroyAllWindows()

Execute este script para ver a detecção de objetos ao vivo. Para usar seu próprio modelo treinado, substitua "yolov11n.pt" pelo caminho do seu arquivo .pt.

6. Exemplo de Script de Treinamento (Ubuntu com múltiplas GPUs)

O script a seguir demonstra como configurar um treinamento YOLO. Os parâmetros devem ser ajustados com base na sua GPU e dataset.

from ultralytics import YOLO
import torch

if __name__ == '__main__':
    # Verifica GPUs disponíveis
    num_gpus = torch.cuda.device_count()
    print(f"GPUs detectadas: {num_gpus}")

    # Carrega um modelo base (pode ser yolov8n.pt, yolov11n.pt, etc.)
    modelo_base = YOLO("yolov11n.pt")

    # Configura e inicia o treinamento
    historico_treinamento = modelo_base.train(
        data="caminho/para/seu/dataset.yaml",  # Arquivo de configuração do dataset
        epochs=100,                          # Número total de épocas
        imgsz=640,                           # Tamanho das imagens (deve ser múltiplo de 32)
        batch=-1,                            # Tamanho do lote automático (-1) ou manual
        device=list(range(num_gpus)),        # Usa todas as GPUs disponíveis [0,1,...]
        workers=4,                           # Número de threads para carregamento de dados
        project="runs/treinamento",          # Diretório raiz para salvar resultados
        name="meu_modelo_customizado"        # Nome da subpasta para esta execução
    )

    # O modelo treinado final (best.pt) estará em: runs/treinamento/meu_modelo_customizado/weights/

Dicas de Parâmetros:

• batch: Se for -1, o YOLO tentará determinar o maior tamanho de lote que cabe na memória da GPU. Defina um valor fixo (ex.: 16) se preferir controle manual.
• device: Para uma única GPU, use device=0. Para múltiplas GPUs, use uma lista (ex.: device=\[0,1\]).
• data: Este arquivo YAML define as classes, caminhos para treino/validação e outras configurações do seu dataset.