Configuration de l'environnement pour YOLOv8

Installation de la distribution Anaconda

Pour commencer, téléchargez l'installateur Anaconda depuis un miroir fiable. Exécutez le programme d'installation et suivez les étapes suivantes :

1. Acceptez le contrat de licence.
2. Choisissez l'option « Tous les utilisateurs » pour l'installation.
3. Sélectionnez un répertoire d'installation sans caractères spéciaux ou espaces.
4. Assurez-vous que les variables d'environnement sont configurées automatiquement.
5. Terminez l'installation et vérifiez l'accès à l'invite Anaconda.

Pour valider l'installation, ouvrez une fenêtre Anaconda Prompt et exécutez :

conda env list

Cette commande doit s'exécuter sans erreur.

Création de l'environnement virtuel pour YOLOv8

Générez un environnement dédié avec Python 3.10 en utilisant Conda :

conda create -n detection_env python=3.10 -y

Activez ensuite cet environnement :

conda activate detection_env

Installation de PyTorch

Rendez-vous sur le site officiel de PyTorch pour obtenir la version adaptée aux processeurs sans GPU. Installez PyTorch via pip dans l'environnement actif :

pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/cpu

Vérifiez l'installation en lançant un interpréteur Python :

python -c "import torch; print(torch.__version__)"

Installation des bibliothèques Ultralytics et OpenCV

Installez le package ultralytics pour YOLOv8 et les dépendances associées :

pip install ultralytics tqdm opencv-contrib-python

Validez l'installation d'OpenCV :

python -c "import cv2; print(cv2.__version__)"

Préparation du jeu de données

Créez une structure de répertoire pour les données d'entraînement, avec des sous-dossiers pour les annotations et les images. Définissez un fichier de configuraton YAML spécifiant le nombre de classes et leurs noms. Exemple de contenu pour un fichier config.yaml :

train: ./data/train.txt
val: ./data/val.txt
nc: 3
names: ['objet_a', 'objet_b', 'objet_c']

Entraînement du modèle YOLOv8

Créez un script Python pour lancer l'entraînement. Utilisez un modèle pré-entraîné comme point de départ :

import torch
from ultralytics import YOLO

torch.serialization.add_safe_globals([YOLO])
modele_base = YOLO("yolov8n.pt")
resultats = modele_base.train(
    data='./config.yaml',
    epochs=150,
    batch=4,
    device='cpu'
)

Détection d'objets sur images et vidéo

Pour effectuer des prédictions sur une image statique :

from ultralytics import YOLO

detecteur = YOLO("./best_model.pt", task="detect")
resultat = detecteur(source="./test_image.jpg", save=True)

Pour une détection en temps réel via une caméra, utilisez un script qui capture le flux vidéo, applique le modèle et affiche les résultats avec le FPS calculé :

import cv2
from ultralytics import YOLO
from cv2 import getTickCount, getTickFrequency

detecteur = YOLO('./best_model.pt')
capteur = cv2.VideoCapture(0)

while capteur.isOpened():
    debut = getTickCount()
    succes, image = capteur.read()
    if succes:
        predictions = detecteur.predict(source=image)
    image_annotee = predictions[0].plot()
    duree = (getTickCount() - debut) / getTickFrequency()
    fps = int(1 / duree)
    cv2.putText(image_annotee, f"FPS: {fps}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
    cv2.imshow('Detection temps reel', image_annotee)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

capteur.release()
cv2.destroyAllWindows()

Intégration d'OpenVINO pour l'accélération GPU Intel

Installation des dépendances OpenVINO

Pour tirer parti des GPU Intel, installez les paquets OpenVINO et les outils associés :

pip install openvino openvino-dev ultralytics

En cas de conflits de version avec NumPy, désinstallez les paquets problématiques et réinstallez les versions compatibles.

Conversion du modèle au format OpenVINO

Exportez le modèle YOLOv8 entraîné vers le format OpenVINO pour une inférence optimisée :

from ultralytics import YOLO

modele = YOLO("./best_model.pt")
modele.export(format="openvino", dynamic=True)

Serveur de détection avec WebSocket et API REST

Développez un serveur Flask avec Socket.IO pour gérer les requêtes de détection en temps réel. Le serveur peut basculer entre le moteur YOLO original et OpenVINO. Voici une structure simplifiée :

import os
import cv2
import json
import time
import base64
import numpy as np
from ultralytics import YOLO
from flask import Flask, request, jsonify
from flask_socketio import SocketIO, emit
import openvino.runtime as ov

app = Flask(__name__)
socketio = SocketIO(app, cors_allowed_origins="*", async_mode='eventlet')

class SystemeDetection:
    def __init__(self):
        self.modele_yolo = None
        self.modele_ov = None
        self.modele_compile = None
        self.utiliser_openvino = False

systeme = SystemeDetection()

def initialiser_modele(chemin_modele):
    systeme.modele_yolo = YOLO(chemin_modele)
    chemin_ov = chemin_modele.replace('.pt', '_openvino_model/')
    if os.path.exists(chemin_ov):
        noyau = ov.Core()
        modele_xml = os.path.join(chemin_ov, "model.xml")
        modele_bin = os.path.join(chemin_ov, "model.bin")
        systeme.modele_ov = noyau.read_model(model=modele_xml, weights=modele_bin)
        systeme.modele_compile = noyau.compile_model(model=systeme.modele_ov, device_name='GPU')
        systeme.utiliser_openvino = True

def traiter_image(image_base64):
    donnees = base64.b64decode(image_base64)
    tableau = np.frombuffer(donnees, np.uint8)
    image = cv2.imdecode(tableau, cv2.IMREAD_COLOR)
    if systeme.utiliser_openvino:
        # Logique d'inférence avec OpenVINO
        pass
    else:
        # Logique d'inférence avec YOLO
        resultats = systeme.modele_yolo.predict(source=image)
    return resultats

@socketio.on('detecter_image')
def gerer_detection(donnees):
    resultat = traiter_image(donnees['image'])
    emit('resultat_detection', resultat)

if __name__ == '__main__':
    initialiser_modele('./best_model.pt')
    socketio.run(app, host='0.0.0.0', port=5010, debug=False)

Automatisation au démarrage avec le Planificateur de tâches Windows

Pour exécuter automatiquement le serveur de détection au démarrage du système :

1. Ouvrez le Planificateur de tâches via taskschd.msc.
2. Créez une tâche de base déclenchée au démarrage du PC.
3. Configurez l'action pour lancer un script batch qui active l'environnement Conda et démarre le serveur Python.
4. Dans les propriétés avancées, sélectionnez « Exécuter indépandamment de la session utilisateur » et « Exécuter avec les privilèges les plus élevés ».

Exemple de contenu pour le fichier demarrer_serveur.bat :

call conda activate detection_env
python C:\chemin\vers\serveur_detection.py

Outils de développement

Pour le débogage et le développement, PyCharm est recommandé. Configurez l'interpréteur Python pour utiliser l'environnement Conda créé. Le chemin vers l'exécutable Conda sur Windows est typiquement C:\Users\Utilisateur\anaconda3\python.exe.