Configurer YOLOv8 pour GPU : accélérer la détection d'objets

Introduction

YOLOv8, développé par Ultralytics en 2023, est devenu l'un des algorithmes de détection d'objets uniques de la série YOLO et présente des améliorations significatives en termes d'architecture et de performances par rapport à ses prédécesseurs, comme YOLOv5. Ces améliorations incluent un squelette CSPNet pour une meilleure extraction des fonctionnalités, un col FPN+PAN pour une détection améliorée des objets multi-échelles et un passage à une approche sans ancrage. Ces changements améliorent considérablement la précision, l’efficacité et la convivialité du modèle pour la détection d’objets en temps réel.

L'utilisation d'un GPU avec YOLOv8 peut améliorer considérablement les performances des tâches de détection d'objets, offrant ainsi une formation et une inférence plus rapides. Ce guide vous guidera dans la configuration de YOLOv8 pour l'utilisation du GPU, y compris des conseils de configuration, de dépannage et d'optimisation.

YOLOv8

YOLOv8 s'appuie sur ses prédécesseurs avec des techniques avancées de conception de réseaux neuronaux et de formation pour améliorer les performances de détection d'objets. Il unifie la localisation et la classification des objets dans un cadre unique et efficace, équilibrant vitesse et précision. L'architecture comprend trois composants clés :

1. Backbone : un backbone CNN hautement optimisé, potentiellement basé sur CSPDarknet, extrait des fonctionnalités multi-échelles à l'aide de couches efficaces telles que des convolutions séparables en profondeur, garantissant des performances élevées avec une surcharge de calcul minimale.
2. Cou : un réseau d'agrégation de chemins (PANet) amélioré affine et intègre des fonctionnalités multi-échelles pour mieux détecter les objets de différentes tailles. Il est optimisé pour l’efficacité et l’utilisation de la mémoire.
3. Tête : la tête sans ancre prédit les cadres de délimitation, les scores de confiance et les étiquettes de classe, simplifiant ainsi les prédictions et améliorant l'adaptabilité à diverses formes et échelles d'objets.

Ces innovations rendent YOLOv8 plus rapide, plus précis et polyvalent pour les tâches modernes de détection d'objets. De plus, YOLOv8 introduit une approche sans ancre pour la prédiction du cadre de délimitation, s'éloignant des méthodes basées sur l'ancre des versions précédentes.

Pourquoi utiliser un GPU avec YOLOv8 ?

YOLOv8 (You Only Look Once, Version 8) est un puissant framework de détection d'objets. Bien qu'il fonctionne sur des processeurs, l'utilisation d'un GPU offre quelques avantages clés, tels que :

• Vitesse : les GPU gèrent les calculs parallèles plus efficacement, réduisant ainsi les temps de formation et d'inférence.
• Évolutivité : des ensembles de données et des modèles plus volumineux peuvent être gérés avec des GPU.
• Performances améliorées : la détection d'objets en temps réel devient possible, permettant des applications telles que les véhicules autonomes, la surveillance et le traitement vidéo en direct.

Les GPU sont le choix évident pour obtenir des résultats plus rapides et gérer des tâches plus complexes avec YOLOv8.

CPU contre GPU

Lorsque vous travaillez avec YOLOv8 ou tout autre modèle de détection d'objets, le choix entre CPU et GPU peut avoir un impact significatif sur les performances du modèle, tant pour la formation que pour l'inférence. Les processeurs, comme nous le savons, sont parfaits pour un usage général et peuvent gérer efficacement des tâches plus petites. Cependant, les processeurs échouent lorsque la tâche devient coûteuse en termes de calcul. Des tâches telles que la détection d'objets nécessitent de la vitesse et un calcul parallèle, et les GPU sont conçus pour gérer des tâches de traitement parallèle hautes performances. Par conséquent, ils sont idéaux pour exécuter des modèles d’apprentissage profond comme YOLO. Par exemple, la formation et l'inférence sur un GPU peuvent être 10 à 50 fois plus rapides que sur un CPU, selon le matériel et la taille du modèle.

La différence devient encore plus prononcée lors de l’entraînement, où les GPU raccourcissent considérablement les époques par rapport aux CPU. Cette augmentation de vitesse permet aux GPU de traiter des ensembles de données plus volumineux et d'effectuer plus efficacement une détection d'objets en temps réel.

Conditions préalables à l'utilisation de YOLOv8 avec GPU

Avant de configurer YOLOv8 pour GPU, assurez-vous de répondre aux exigences suivantes :

1. Configuration matérielle requise

• GPU NVIDIA : YOLOv8 s'appuie sur CUDA pour l'accélération GPU, vous aurez donc besoin d'un GPU NVIDIA avec une capacité de calcul CUDA de 6.0 ou supérieure.
• Mémoire : au moins 8 Go de mémoire GPU sont recommandés pour les ensembles de données modérés. Pour les ensembles de données plus volumineux, 16 Go ou plus sont préférables.

2. Configuration logicielle requise

• Python : version 3.8 ou ultérieure.
• PyTorch : installé avec prise en charge GPU (via CUDA). De préférence un GPU NVIDIA.
• CUDA Toolkit et cuDNN : assurez-vous qu'ils sont compatibles avec votre version de PyTorch.
• YOLOv8 : installable à partir du référentiel Ultralytics.

3. Exigences du pilote

• Téléchargez et installez les derniers pilotes NVIDIA à partir du site Web de NVIDIA.
• Vérifiez la disponibilité de votre GPU à l'aide de nvidia-smi après l'installation du pilote.

Guide étape par étape pour configurer YOLOv8 pour GPU

1. Installez les pilotes NVIDIA

Pour installer les pilotes NVIDIA :

• Identifiez votre GPU à l'aide du code ci-dessous :

nvidia-smi

• Visitez la page de téléchargement des pilotes NVIDIA et téléchargez le pilote approprié.
• Suivez les instructions d'installation correspondant à votre système d'exploitation.
• Redémarrez votre ordinateur pour appliquer les modifications.
• Vérifiez l'installation en exécutant :

nvidia-smi

• Cette commande affiche les informations du GPU et confirme la fonctionnalité du pilote.

2. Installez la boîte à outils CUDA et cuDNN

Pour utiliser YOLOv8, nous devons sélectionner la version PyTorch appropriée, qui à son tour nécessite la version CUDA.

Étapes pour installer la boîte à outils CUDA

1. Téléchargez la version appropriée de CUDA Toolkit à partir du site NVIDIA Developer.
2. Installez CUDA Toolkit et définissez les variables d'environnement (par exemple, PATH, LD_LIBRARY_PATH).
3. Vérifiez l'installation en exécutant :

nvcc --version

S'assurer que vous disposez de la dernière version de CUDA permettra à PyTorch d'utiliser efficacement le GPU

Étapes pour installer cuDNN

1. Téléchargez cuDNN depuis le site des développeurs NVIDIA.
2. Extrayez le contenu et copiez-le dans les répertoires CUDA correspondants (par exemple, bin, include, lib).
3. Assurez-vous que la version de cuDNN correspond à votre installation CUDA.

3. Installez PyTorch avec prise en charge GPU

Pour installer PyTorch avec prise en charge GPU, visitez la page de démarrage de PyTorch et sélectionnez la commande d'installation appropriée. Par exemple:

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117

4. Installez et exécutez YOLOv8

Installez YOLOv8 en suivant ces étapes :

• Installez Ultralytics pour travailler avec yolov8 et importez les bibliothèques nécessaires

pip install ultralytics

• Exemple de script Python :

from Ultralytics import YOLOLoad a COCO-pretrained YOLOv8n model

model = YOLO("yolov8n.pt")
Display model information (optional)
model.info()
Train the model on the COCO8 example dataset for 100 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device = ‘cuda’)
Run inference with the YOLOv8n model on the 'bus.jpg' image
results = model("path/to/image.jpg")

• Exemple de ligne de commande :

# use the CLI commands to directly run the model:
from Ultralytics import YOLO
Load a COCO-pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
Display model information (optional)
model.info()
Train the model on the COCO8 example dataset for 100 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
Run inference with the YOLOv8n model on the 'bus.jpg' image
results = model("path/to/image.jpg")

5. Vérifiez la configuration du GPU dans YOLOv8

Utilisez la commande Python suivante pour vérifier si votre GPU est détecté et si CUDA est activé :

import torchCheck if GPU is available
print("CUDA Available:", torch.cuda.is_available())
Get GPU details
if torch.cuda.is_available():
    print("GPU Name:", torch.cuda.get_device_name(0))

6. Entraîner ou déduire avec GPU

Spécifiez l'appareil comme cuda dans vos commandes d'entraînement ou d'inférence :

Exemple de ligne de commande

yolo task=detect mode=train data=coco.yaml model=yolov8n.pt device=0 epochs = 128 plots = True

Valider le modèle personnalisé

yolo task=detect mode=val model={HOME}/runs/detect/train/weights/best.pt data={dataset.location}/data.yaml

Exemple de script Python

from ultralytics import YOLO
Load the YOLOv8 model 
model = YOLO('yolov8n.pt')
Train the model on GPU 
model.train(data='coco.yaml', epochs=50, device='cuda')
Perform inference on GPU 
results = model.predict(source='input.jpg', device='cuda')

Pourquoi les gouttelettes GPU DigitalOcean ?

Les droplets GPU DigitalOcean sont conçus pour gérer des tâches d’IA et d’apprentissage automatique hautes performances. Les H100 alimentent ces gouttelettes GPU pour offrir une vitesse exceptionnelle et des capacités de traitement parallèle, ce qui les rend idéales pour entraîner et exécuter efficacement des modèles YOLOv8. Pour en ajouter plus, ces droplets sont préinstallés avec la dernière version de CUDA, vous permettant ainsi de commencer à tirer parti de l'accélération GPU sans passer de temps sur les configurations manuelles. Cet environnement rationalisé vous permet de vous concentrer entièrement sur l'optimisation de vos modèles YOLOv8 et de faire évoluer vos projets sans effort.

Dépannage des problèmes courants

1. YOLOv8 n'utilise pas de GPU

• Vérifiez la disponibilité du GPU à l'aide

torch.cuda.is_available()

• Vérifiez la compatibilité CUDA et PyTorch.
• Assurez-vous de spécifier device=0 ou device='cuda' dans les commandes ou les scripts.
• Mettez à jour les pilotes NVIDIA et réinstallez CUDA Toolkit si nécessaire.

2. Erreurs CUDA

• Assurez-vous que la version de CUDA Toolkit correspond aux exigences de PyTorch.
• Vérifiez l'installation de cuDNN en exécutant des scripts de diagnostic.
• Vérifiez les variables d'environnement pour CUDA (PATH et LD_LIBRARY_PATH).

3. Performances lentes

• Activez l'entraînement de précision mixte pour optimiser l'utilisation de la mémoire et la vitesse :

model.train(data='coco.yaml', epochs=50, device='cuda', amp=True)

• Réduisez la taille du lot si l’utilisation de la mémoire est trop élevée.
• Assurez-vous de disposer d'un système optimisé pour exécuter le traitement parallèle et envisagez d'utiliser le traitement par lots dans votre script de détection pour améliorer les performances.

from Ultralytics import YOLO
Load the models
vehicle_model = YOLO('yolov8l.pt')
license_model = YOLO('Registration.pt')
Process each stream, example for one stream
results = vehicle_model(source='stream1.mp4', batch=4)  # Modify as needed for parallel processing

FAQ

Comment activer le GPU pour YOLOv8 ?

Spécifiez device='cuda' ou device=0 (si vous utilisez le premier GPU) dans vos commandes ou scripts lors du chargement du modèle. Cela permettra à YOLOv8 d'utiliser le GPU pour un calcul plus rapide pendant l'inférence et la formation. Assurez-vous que votre GPU est correctement configuré et détecté.

model = YOLO("yolov8n.pt") 
model.to('cuda')

Pourquoi YOLOv8 n'utilise-t-il pas mon GPU ?

YOLOv8 peut ne pas utiliser le GPU en cas de problèmes avec le matériel, les pilotes ou la configuration. Pour commencer, vérifiez l'installation de CUDA et la compatibilité avec PyTorch. Mettez à jour les pilotes si nécessaire. Assurez-vous que vos CUDA et CuDNN sont compatibles avec votre installation PyTorch. Installez torchvision et vérifiez la configuration en cours d'installation et d'utilisation.

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118`

import torch print(torch.cuda.get_device_name())

De plus, si PyTorch n'est pas installé avec la prise en charge du GPU (par exemple, une version CPU uniquement), ou si le paramètre device dans vos commandes YOLOv8 peut ne pas être explicitement défini sur cuda. L'exécution de YOLOv8 sur un système sans GPU compatible CUDA ou sans VRAM insuffisante peut également entraîner son utilisation par défaut du CPU.

Pour résoudre ce problème, assurez-vous que votre GPU est compatible CUDA, vérifiez l'installation de toutes les dépendances requises, vérifiez que torch.cuda.is_available() renvoie True et spécifiez explicitement le Paramètre device='cuda' dans vos scripts ou commandes YOLOv8.

Quelle est la configuration matérielle requise pour YOLOv8 sur GPU ?

Pour installer et exécuter efficacement YOLOVv8 sur un GPU, Python 3.7 ou supérieur est recommandé, et un GPU compatible CUDA est requis pour utiliser l'accélération GPU.

Un GPU NVIDIA moderne avec au moins 8 Go de mémoire est recommandé. Pour les grands ensembles de données, davantage de mémoire est bénéfique. Pour des performances optimales, il est recommandé d'utiliser Python 3.8 ou version ultérieure, PyTorch 1.10 ou version ultérieure et un GPU NVIDIA compatible avec CUDA 11.2+. Le GPU devrait idéalement disposer d’au moins 8 Go de VRAM pour gérer efficacement les ensembles de données modérés, bien que davantage de VRAM soit bénéfique pour les ensembles de données plus volumineux et les modèles complexes. De plus, votre système doit disposer d'au moins 8 Go de RAM et de 50 Go d'espace disque libre pour stocker les ensembles de données et faciliter la formation du modèle. Garantir ces configurations matérielles et logicielles vous aidera à obtenir une formation et une inférence plus rapides avec YOLOv8, en particulier pour les tâches gourmandes en calcul.

Veuillez noter : les GPU AMD peuvent ne pas prendre en charge CUDA, il est donc essentiel de choisir un GPU NVIDIA pour la compatibilité YOLOv8.

YOLOv8 peut-il fonctionner sur plusieurs GPU ?

Pour entraîner YOLOv8 à l'aide de plusieurs GPU, vous pouvez utiliser DataParallel de PyTorch ou spécifier plusieurs appareils directement (par exemple, cuda:0,1). Pour la formation distribuée, YOLOv8 utilise par défaut le multi-GPU DistributedDataParallel (DDP) de PyTorch. Assurez-vous que votre système dispose de plusieurs GPU disponibles et spécifiez les GPU que vous souhaitez utiliser dans le script de formation ou la ligne de commande. Par exemple, définissez --device 0,1,2,3 dans la CLI ou device=[0,1,2,3] en Python pour utiliser les GPU 0, 1, 2 et 3. YOLOv8 gère automatiquement l'entraînement parallèle sur les GPU spécifiés sans nécessiter d'argument data_parallel explicite. Bien que tous les GPU soient utilisés pendant la formation, la phase de validation s'exécute généralement sur un seul GPU par défaut, car elle nécessite moins de ressources que la formation.

Comment optimiser YOLOv8 pour l'inférence sur GPU ?

Activez une précision mixte et ajustez la taille des lots pour équilibrer la mémoire et la vitesse. En fonction de votre ensemble de données, la formation de YOLOv8 nécessite une certaine puissance de calcul pour fonctionner efficacement. Utilisez une variante de modèle plus petite ou quantifiée (par exemple, versions quantifiées YOLOv8n ou INT8) pour réduire l'utilisation de la mémoire et le temps d'inférence. Dans votre script d'inférence, définissez explicitement le paramètre device sur cuda pour l'exécution GPU. Utilisez des techniques telles que l'inférence par lots pour traiter plusieurs images simultanément et maximiser l'utilisation du GPU. Le cas échéant, utilisez TensorRT pour optimiser davantage le modèle afin d'obtenir une inférence GPU plus rapide. Surveillez régulièrement la mémoire et les performances du GPU pour garantir une utilisation efficace des ressources.

L'extrait de code ci-dessous vous permettra de traiter des images en parallèle dans la taille de lot définie.

from Ultralytics import YOLO
model = YOLO('yolov8n.pt', device='cpu', batch=4)  # specify the batch size as needed
pass the argument ‘images’, which is the list of preprocessed images
results = model.predict(images)  # 'images' should have the shape (N, 3, H, W)

Si vous utilisez la CLI, spécifiez la taille du lot avec -b ou --batch-size. Avec Python, assurez-vous que l'argument batch est correctement défini lors de l'initialisation de votre modèle ou de l'appel de la méthode de prédiction.

Comment résoudre les problèmes de mémoire insuffisante de CUDA ?

Pour résoudre les erreurs de mémoire insuffisante CUDA, réduisez la taille du lot de validation dans votre fichier de configuration YOLOv8, car les lots plus petits nécessitent moins de mémoire GPU. De plus, si vous avez accès à plusieurs GPU, envisagez de répartir la charge de travail de validation entre eux à l'aide de DistributedDataParallel de PyTorch ou d'une fonctionnalité similaire, bien que cela nécessite une connaissance avancée de PyTorch. Vous pouvez également essayer de vider la mémoire cache en utilisant torch.cuda.empty_cache() dans votre script et vous assurer qu'aucun processus inutile ne s'exécute sur votre GPU. La mise à niveau vers un GPU avec plus de VRAM ou l'optimisation de votre modèle et de votre ensemble de données pour l'efficacité de la mémoire sont d'autres étapes pour atténuer ces problèmes.

Conclusion

Configurer YOLOv8 pour utiliser un GPU est un processus simple qui peut améliorer considérablement les performances. En suivant ce guide détaillé, vous pouvez accélérer la formation et l'inférence pour vos tâches de détection d'objets. Optimisez votre configuration, résolvez les problèmes courants et libérez tout le potentiel de YOLOv8 avec l'accélération GPU.

Références

• Comment entraîner Yolov8 avec multi-gpu ? · Numéro 3308
• QU'EST-CE QUE YOLOV8 : UNE EXPLORATION APPROFONDIE DES CARACTÉRISTIQUES INTERNES DU DÉTECTEUR D'OBJETS DE NOUVELLE GÉNÉRATION