YOLOv8: Guia Completo para Detecção de Objetos

O YOLOv8 é a versão mais recente do algoritmo YOLO (You Only Look Once), desenvolvido pela Ultralytics. Ele oferece desempenho aprimorado e uma API mais intuitiva.

1. Instalação e Configuração

# Installation des dépendances
pip install ultralytics opencv-python numpy

# Import des bibliothèques nécessaires
from ultralytics import YOLO
import cv2
import numpy as np

2. Modelos Disponíveis

2.1 Carregamento dos Modelos

# Chargement des différents modèles
model_nano = YOLO('yolov8n.pt')  # Nano
model_small = YOLO('yolov8s.pt')  # Small
model_medium = YOLO('yolov8m.pt')  # Medium
model_large = YOLO('yolov8l.pt')  # Large
model_xlarge = YOLO('yolov8x.pt')  # XLarge

2.2 Comparação dos Modelos

def compare_models():
    # Configuration de base
    test_image = "path/to/test/image.jpg"
    
    # Test des différents modèles
    models = {
        'nano': model_nano,
        'small': model_small,
        'medium': model_medium,
        'large': model_large,
        'xlarge': model_xlarge
    }
    
    results = {}
    for name, model in models.items():
        # Mesure du temps d'inférence
        start_time = time.time()
        results[name] = model(test_image)
        inference_time = time.time() - start_time
        
        print(f"Modèle {name}:")
        print(f"Temps d'inférence: {inference_time:.2f}s")
        print(f"Nombre de détections: {len(results[name][0].boxes)}")

3. Detecção de Objetos

3.1 Detecção Simples

def detect_objects(image_path):
    # Chargement du modèle
    model = YOLO('yolov8n.pt')
    
    # Détection
    results = model(image_path)
    
    # Traitement des résultats
    for result in results:
        boxes = result.boxes
        for box in boxes:
            # Coordonnées de la boîte
            x1, y1, x2, y2 = box.xyxy[0]
            x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
            
            # Confiance
            confidence = float(box.conf[0])
            
            # Classe
            class_id = int(box.cls[0])
            class_name = model.names[class_id]
            
            # Dessiner la boîte
            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
            
            # Ajouter le texte
            label = f"{class_name} {confidence:.2f}"
            cv2.putText(image, label, (x1, y1 - 10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
    
    return image

3.2 Detecção em Tempo Real

def real_time_detection():
    # Initialisation de la caméra
    cap = cv2.VideoCapture(0)
    
    # Chargement du modèle
    model = YOLO('yolov8n.pt')
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Détection
        results = model(frame)
        
        # Visualisation
        annotated_frame = results[0].plot()
        
        # Affichage
        cv2.imshow('YOLOv8 Detection', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

4. Segmentação

4.1 Segmentação de Instância

def instance_segmentation():
    # Chargement du modèle de segmentation
    model = YOLO('yolov8n-seg.pt')
    
    # Segmentation
    results = model('path/to/image.jpg')
    
    # Visualisation
    for result in results:
        # Masques de segmentation
        masks = result.masks
        if masks is not None:
            for mask in masks:
                # Conversion du masque en image
                mask_array = mask.data.cpu().numpy()
                
                # Application du masque
                masked_image = cv2.bitwise_and(
                    image, image, mask=mask_array.astype(np.uint8)
                )
                
                # Affichage
                cv2.imshow('Segmentation', masked_image)

4.2 Segmentação em Tempo Real

def real_time_segmentation():
    # Initialisation
    cap = cv2.VideoCapture(0)
    model = YOLO('yolov8n-seg.pt')
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Segmentation
        results = model(frame)
        
        # Visualisation
        annotated_frame = results[0].plot()
        
        # Affichage
        cv2.imshow('YOLOv8 Segmentation', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

5. Classificação

5.1 Classificação de Imagens

def image_classification():
    # Chargement du modèle de classification
    model = YOLO('yolov8n-cls.pt')
    
    # Classification
    results = model('path/to/image.jpg')
    
    # Traitement des résultats
    for result in results:
        # Probabilités des classes
        probs = result.probs
        
        # Classe prédite
        predicted_class = probs.top1
        confidence = probs.top1conf
        
        print(f"Classe prédite: {model.names[predicted_class]}")
        print(f"Confiance: {confidence:.2f}")

5.2 Classificação em Tempo Real

def real_time_classification():
    # Initialisation
    cap = cv2.VideoCapture(0)
    model = YOLO('yolov8n-cls.pt')
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Classification
        results = model(frame)
        
        # Visualisation
        annotated_frame = results[0].plot()
        
        # Affichage
        cv2.imshow('YOLOv8 Classification', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

6. Treinamento Personalizado

6.1 Preparação dos Dados

def prepare_training():
    # Configuration du dataset
    data_yaml = """
    path: dataset  # Chemin vers le dataset
    train: images/train  # Images d'entraînement
    val: images/val  # Images de validation
    
    # Classes
    names:
      0: person
      1: car
      2: truck
      # ... autres classes
    """
    
    # Sauvegarde de la configuration
    with open('data.yaml', 'w') as f:
        f.write(data_yaml)

6.2 Treinamento do Modelo

def train_model():
    # Chargement du modèle
    model = YOLO('yolov8n.pt')
    
    # Configuration de l'entraînement
    results = model.train(
        data='data.yaml',
        epochs=100,
        imgsz=640,
        batch=16,
        device='0',  # GPU
        workers=8,
        project='runs/train',
        name='exp'
    )

7. Otimização e Implantação

7.1 Exportação do Modelo

def export_model():
    # Chargement du modèle
    model = YOLO('yolov8n.pt')
    
    # Export dans différents formats
    model.export(format='onnx')  # ONNX
    model.export(format='engine')  # TensorRT
    model.export(format='coreml')  # CoreML
    model.export(format='tflite')  # TFLite

7.2 Otimização do Desempenho

def optimize_performance():
    # Configuration pour de meilleures performances
    model = YOLO('yolov8n.pt')
    
    # Optimisation des paramètres
    results = model.predict(
        source='0',  # Caméra
        conf=0.25,  # Seuil de confiance
        iou=0.45,  # Seuil IoU
        agnostic_nms=True,  # NMS agnostique aux classes
        max_det=300,  # Nombre maximum de détections
        half=True  # Utilisation de la précision FP16
    )

8. Boas Práticas

1. Escolha do Modelo

   • Nano para dispositivos móveis
   • Small/Medium para aplicações gerais
   • Large/XLarge para máxima precisão

2. Otimização

   • Usar precisão FP16 em GPUs
   • Ajustar os limiares de confiança e de IoU
   • Otimizar o tamanho do batch

3. Implantação

   • Exportar no formato apropriado
   • Usar aceleração de hardware
   • Implementar um sistema de cache

Conclusão

Pontos principais:

• Desempenho aprimorado
• API intuitiva
• Suporte multiplataforma
• Exportação para diversos formatos

Recomendações:

• Escolher o modelo certo de acordo com as necessidades
• Otimizar o desempenho
• Usar aceleração de hardware
• Implementar um tratamento de erros robusto