Comment entraîner des modèles Ultralytics YOLO à détecter des animaux sauvages

La faune de notre planète est incroyablement diverse, des abeilles bourdonnantes aux imposants éléphants, et préserver cette biodiversité est essentiel au maintien d’un écosystème équilibré. Cependant, les efforts de conservation deviennent plus difficiles en raison de la perte d’habitats, du braconnage et du changement climatique. Tous ces facteurs ont des effets négatifs sur les populations animales.

Les méthodes traditionnelles de suivi des animaux, comme l’analyse manuelle des images de pièges photographiques et les relevés sur le terrain, peuvent être lentes et nécessiter beaucoup de ressources. Ces efforts ne permettent souvent pas de couvrir efficacement de vastes zones et de grandes populations.

Pour surmonter ces limites, l’intelligence artificielle (AI) peut être un outil efficace pour la conservation de la faune. Plus précisément, les modèles de vision par ordinateur comme Ultralytics YOLO11 peuvent analyser des données visuelles telles que des images et des vidéos afin d’automatiser l’identification et le suivi des animaux en temps réel.

Les tâches de vision par ordinateur comme la détection d’objets et la segmentation d’instances, prises en charge par Ultralytics YOLO11, sont très utiles dans ce contexte. En analysant les données visuelles, ces tâches nous aident à recueillir des données essentielles, à repérer des tendances écologiques et à réagir plus efficacement aux menaces environnementales.

Dans cet article, nous allons suivre les étapes de l’entraînement d’Ultralytics YOLO11 pour détecter des animaux.

Premiers pas avec Ultralytics YOLO11#

Avant de passer au tutoriel, examinons les différentes options de configuration et les outils nécessaires pour entraîner et utiliser Ultralytics YOLO11.

L’outil principal dont tu auras besoin est le package Python Ultralytics, qui facilite l’utilisation des modèles YOLO pour des tâches comme l’entraînement, la détection d’objets et l’exécution d’inférences. Pour utiliser le package Ultralytics, tu dois configurer un environnement où exécuter ton code. Plusieurs options s’offrent à toi.

Voici quelques-unes des options les plus populaires pour configurer ton environnement de développement :

• Interface en ligne de commande (CLI) : la CLI, également appelée terminal, est un outil textuel qui te permet d’interagir avec ton ordinateur en saisissant des commandes. Contrairement aux interfaces graphiques (GUIs), où tu cliques sur des boutons et utilises une souris, la CLI nécessite de saisir des instructions textuelles pour lancer des programmes ou exécuter des tâches.
• Jupyter Notebooks : ces notebooks te permettent d’écrire et d’exécuter du code par petites sections appelées cellules. L’environnement est interactif : tu peux voir immédiatement le résultat de ton code, ce qui facilite les tests et le débogage.
• Google Colab : Google Colab est une plateforme cloud qui fonctionne comme Jupyter Notebooks, mais offre un accès gratuit à de puissants GPU. Sa configuration est simple et tu n’as rien à installer sur ton ordinateur.

Tu peux découvrir d’autres options de configuration de ton environnement dans la documentation officielle d’Ultralytics, mais les trois options présentées ci-dessus demandent très peu de configuration et sont faciles à utiliser, ce qui les rend idéales pour démarrer rapidement.

Dans ce tutoriel, nous allons montrer comment configurer et entraîner Ultralytics YOLO11 avec Google Colab, Jupyter Notebooks ou un simple fichier Python, car les étapes sont très similaires dans ces différents environnements.

Comprendre le jeu de données African Wildlife#

Après avoir choisi un environnement de développement, il nous faut un jeu de données d’images annotées de grande qualité pour entraîner Ultralytics YOLO11 à détecter spécifiquement les animaux sauvages. Chaque image doit indiquer clairement où se trouvent les animaux et de quelle espèce ils sont, afin que le modèle apprenne à les reconnaître par apprentissage supervisé.

Dans ce tutoriel, nous utiliserons le jeu de données African Wildlife. Il est pris en charge par le package Python Ultralytics et conçu spécifiquement pour détecter les animaux couramment présents dans les écosystèmes africains. Il contient des images annotées de quatre espèces importantes : des buffles, des éléphants, des rhinocéros et des zèbres.

Fig. 1. Aperçu du jeu de données African Wildlife.

Voici quelques caractéristiques importantes du jeu de données African Wildlife :

• Taille : le jeu de données comprend 1504 images réparties en trois sous-ensembles : 1052 pour l’entraînement, 225 pour la validation et 227 pour le test. Cette répartition permet au modèle d’apprendre efficacement et d’être évalué de manière approfondie.
• Intégration facile : Ultralytics fournit un fichier de configuration YAML qui définit les chemins d’accès aux jeux de données, les classes et d’autres détails, ce qui facilite son utilisation pour entraîner des modèles YOLO.
• Licence : Le jeu de données source, publié sur Kaggle par Bianca Ferreira, ne précise pas de licence ; vérifie donc ses conditions avant toute utilisation commerciale.

Entraîner Ultralytics YOLO11 à détecter des animaux#

Maintenant que nous avons exploré le jeu de données African Wildlife, nous pouvons commencer à entraîner un modèle Ultralytics YOLO11 pour détecter des animaux dans des images. Le processus consiste à configurer l’environnement de développement, à entraîner le modèle YOLO11 et à évaluer ses performances.

Étape 1 : Configurer l’environnement#

Pour commencer, nous allons préparer un environnement d’entraînement et de test du modèle. Tu peux utiliser Google Colab, Jupyter Notebooks ou un simple fichier Python, selon tes préférences. Crée un notebook Google Colab, un notebook Jupyter ou un fichier Python en conséquence.

Si tu utilises Google Colab, l’environnement fonctionne par défaut sur un CPU (unité centrale de traitement (CPU)), ce qui peut ralentir l’entraînement. Pour accélérer le processus, en particulier avec les modèles les plus volumineux, tu peux configurer l’environnement d’exécution pour utiliser un GPU. Dans Google Colab, ouvre l’onglet « Runtime » du menu, sélectionne « Change runtime type » et choisis un GPU comme accélérateur matériel (de préférence un GPU T4). C’est important pour réduire la durée de l’entraînement.

Ensuite, quel que soit l’environnement que tu utilises, tu dois installer le package Python Ultralytics. Si tu travailles dans un environnement basé sur un notebook (Google Colab ou Jupyter), exécute la commande suivante en ajoutant un point d’exclamation (!) au début.

pip install ultralytics

Étape 2 : Charger Ultralytics YOLO11 et préparer le jeu de données#

Une fois le package Ultralytics installé, l’étape suivante consiste à charger le modèle YOLO11 et à préparer le jeu de données pour l’entraînement. Commençons par charger le modèle YOLO11n, déjà préentraîné pour des tâches générales de détection d’objets. Ce modèle préentraîné constitue un bon point de départ, car il a déjà appris à détecter différents objets.

Ensuite, nous indiquons le jeu de données à l’aide d’un fichier YAML qui contient des informations sur les images et les étiquettes. Ce fichier indique au modèle où trouver le jeu de données et quels objets il doit apprendre à reconnaître.

Le package Ultralytics prend en charge le jeu de données African Wildlife : celui-ci sera donc téléchargé automatiquement au démarrage de l’entraînement, ce qui t’évite de devoir le configurer manuellement. Tu peux également parcourir ses images et ses étiquettes sur Ultralytics Platform.

Une fois le jeu de données prêt, le modèle commence son entraînement. Il parcourt le jeu de données plusieurs fois — un processus appelé entraînement sur plusieurs époques — afin d’améliorer sa capacité à reconnaître les animaux dans les images. Pendant ce processus, les images sont redimensionnées de manière uniforme pour le traitement, et le modèle traite un nombre défini d’images à la fois, appelé lot. Cela l’aide à apprendre plus efficacement.

En résumé, le modèle est chargé, le jeu de données est téléchargé automatiquement et l’entraînement à la détection d’animaux à partir du jeu de données African Wildlife démarre lorsque l’extrait de code ci-dessous est exécuté.

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
results = model.train(data="african-wildlife.yaml", epochs=30, batch=8)

Le même code fonctionne avec les modèles Ultralytics YOLO26 plus récents : il suffit de remplacer yolo11n.pt par yolo26n.pt.

Étape 3 : Présentation de l’entraînement d’Ultralytics YOLO11#

Une fois l’extrait de code ci-dessus exécuté, le modèle commence son entraînement selon les paramètres définis. Nous lui avons indiqué dans le code de parcourir les images d’entraînement 30 fois. Autrement dit, le modèle examinera toutes les images du jeu de données à 30 reprises et apprendra un peu plus à chaque passage.

Imagine que tu essaies d’apprendre à dessiner un animal. Ton premier dessin ne sera peut-être pas très réussi, mais tu t’amélioreras à force de t’exercer. Chaque nouvel essai t’aide à comprendre ce qui n’a pas fonctionné et à le corriger. C’est ce que fait chaque époque pour le modèle : il examine les images, fait des erreurs, en tire des enseignements et reconnaît mieux les animaux à chaque fois.

Si le code d’entraînement s’exécute correctement, tu verras le résultat suivant au fur et à mesure de l’entraînement :

• Configuration de l’entraînement : La première partie indique la version d’Ultralytics et de PyTorch, ainsi que le matériel utilisé (le CPU dans ce cas), et présente la configuration de l’entraînement, notamment le modèle (yolo11n.pt), la taille des lots, le nombre d’époques et la taille des images.
• Résumé du modèle : Il fournit des informations sur la complexité du modèle, comme le nombre de couches et de paramètres, et indique ainsi la taille du modèle.
• Optimiseur et taux d’apprentissage : Il indique l’optimiseur (par exemple, AdamW) et le taux d’apprentissage, qui déterminent comment le modèle ajuste ses paramètres pendant l’entraînement.
• Analyse du jeu de données : Le modèle analyse le jeu de données et indique le nombre d’images valides et prêtes pour l’entraînement. Cela confirme que le jeu de données ne présente aucun problème.
• Progression de l’entraînement : Le résultat est mis à jour après chaque époque (cycle d’entraînement) et indique la progression de l’entraînement ainsi que les principales valeurs de perte (box_loss, cls_loss, dfl_loss), qui montrent dans quelle mesure le modèle apprend.
• Métriques de performance : Après chaque époque, tu verras des métriques de performance comme la précision, le rappel et la mAP (précision moyenne). Ces valeurs indiquent la précision avec laquelle le modèle détecte et classe les objets.
• Utilisation de la mémoire GPU : Si tu utilises un GPU, le résultat indique l’utilisation de la mémoire pour suivre l’utilisation du matériel.

Fig. 2. Résultat affiché pendant l’entraînement du modèle.

Étape 4 : Évaluer les performances du modèle personnalisé entraîné#

Une fois l’entraînement terminé, tu peux consulter les métriques de performance du modèle et les valider. Dans Google Colab, tu peux accéder au dossier « runs », puis au dossier « detect » et enfin au dossier « train », où tu trouveras des journaux présentant les principaux indicateurs de performance.

Dans un environnement Python, les résultats de l’entraînement sont enregistrés par défaut dans le répertoire « runs/detect/train » du répertoire de travail actuel. Chaque nouvel entraînement crée un nouveau sous-répertoire (par exemple, runs/detect/train2, runs/detect/train3, etc.), où tu trouveras les journaux et les autres sorties associées à l’entraînement.

Si tu utilises la CLI, tu peux facilement accéder à ces résultats et paramètres avec la commande « yolo settings », qui te permet d’afficher ou de modifier les chemins et les autres configurations associés aux journaux d’entraînement et aux détails des expériences.

Parmi les journaux, tu trouveras également des graphiques qui te permettront d’évaluer le déroulement de l’entraînement du modèle. Créés une fois l’entraînement terminé, ces graphiques indiquent si le modèle s’est amélioré au fil du temps en faisant moins d’erreurs et en devenant plus précis.

Ils suivent la progression du modèle en montrant la diminution de la perte (l’écart entre les prédictions du modèle et les valeurs réelles) et l’augmentation de la précision pendant l’entraînement. Cela t’aide à comprendre dans quelle mesure le modèle a appris à reconnaître les animaux et à quel point il s’est amélioré à la fin de l’entraînement.

Fig. 3. Exemple de graphiques à analyser pour évaluer ton modèle.

Principales métriques d’évaluation des performances#

Voici également un aperçu plus détaillé de certaines métriques qui peuvent t’aider à évaluer les performances du modèle :

• Précision moyenne (mAP) : Cette métrique mesure la précision globale du modèle dans la détection des animaux de toutes les classes, en calculant la moyenne des scores de précision à différents niveaux de rappel.
• Précision : Elle représente le pourcentage de détections correctes, calculé en divisant le nombre de vrais positifs détectés par le nombre total de détections effectuées.
• Rappel : Il indique le pourcentage d’animaux réellement présents dans les images que le modèle a correctement identifiés, et reflète sa capacité à repérer toutes les instances pertinentes.

Ces métriques d’évaluation peuvent t’aider à affiner le modèle afin d’améliorer sa précision avant de l’utiliser dans des applications réelles.

Exécuter des inférences avec ton modèle Ultralytics YOLO11 personnalisé entraîné#

Maintenant qu’Ultralytics YOLO11 a été entraîné et évalué, il est temps de l’utiliser pour analyser des images et exécuter des inférences. Tu peux utiliser les images de test du jeu de données ou de nouvelles images provenant d’autres sources.

Nous allons utiliser l’extrait de code suivant pour exécuter le modèle sur une image du jeu de données de test. Il importe les modules nécessaires depuis la bibliothèque Ultralytics. Il définit ensuite le chemin d’accès au fichier des meilleurs poids du modèle (« best.pt »), enregistré dans le répertoire des résultats. Le modèle YOLO11 personnalisé entraîné est chargé à l’aide de ces poids.

Ensuite, le chemin d’accès à une image du jeu de données de test African Wildlife est défini. Le modèle traite cette image pour détecter les objets, génère les résultats et enregistre le résultat (par exemple, les objets détectés ou les annotations).

from ultralytics import YOLO, settings

best_model_path = results.save_dir / "weights/best.pt"
model = YOLO(best_model_path)
image_path = f"{settings['datasets_dir']}/african-wildlife/test/images/1 (168).jpg"
img_results = model(image_path, save=True)

L’image de sortie ci-dessous sera enregistrée dans le dossier « predict », situé dans le répertoire runs/detect. Pour les tests suivants, de nouveaux dossiers, comme « predict2 », « predict3 », etc., seront créés pour stocker les images.

Fig. 4. Exécution d’une inférence sur une image de test avec le modèle Ultralytics YOLO11 affiné.

Pour tester des images provenant de différentes sources, tu peux utiliser le code ci-dessous. Nous avons utilisé une image de Pexels. Tu peux utiliser la même image ou toute autre image pertinente.

from ultralytics import YOLO

best_model_path = results.save_dir / "weights/best.pt"
model = YOLO(best_model_path)
img2_results = model("https://images.pexels.com/photos/18341011/pexels-photo-18341011/free-photo-of-elephant-and-zebras-in-savannah.png", save=True)

L’image de sortie ci-dessous sera enregistrée dans le dossier approprié.

Fig. 5. Détection de la faune sur une image inédite avec le modèle Ultralytics YOLO11 affiné.

L’IA au service de la conservation de la faune : applications concrètes#

Les modèles comme Ultralytics YOLO11 peuvent détecter et suivre automatiquement les animaux, ce qui permet de nombreuses applications pratiques. Voici quelques domaines clés dans lesquels l’IA visuelle peut contribuer aux efforts de conservation de la faune :

• Suivi des espèces : L’IA visuelle peut traiter des données visuelles comme des images et des vidéos afin d’identifier précisément les espèces, de compter les populations et de suivre leurs déplacements au fil du temps.
• Alertes des caméras intelligentes : Dans les zones isolées, la vision par ordinateur peut classer les animaux en continu et envoyer des alertes en temps réel, permettant aux autorités chargées de la faune de réagir rapidement aux menaces telles qu’un comportement animal anormal ou les conflits entre humains et animaux sauvages.
• Analyse des comportements : En surveillant les migrations, les habitudes alimentaires et les interactions sociales, les systèmes d’IA visuelle peuvent fournir des informations détaillées sur les dynamiques entre espèces.
• Prévention du braconnage : L’IA visuelle peut servir à détecter la présence humaine non autorisée et les signes de braconnage, tout en exploitant l’apprentissage automatique et les données historiques pour localiser les zones à haut risque.

Points clés à retenir#

Les modèles de vision par ordinateur comme Ultralytics YOLO11 peuvent jouer un rôle clé dans la conservation de la faune en automatisant la détection et le suivi des animaux. Grâce à l’IA visuelle, nous pouvons traiter de grands volumes d’images et de vidéos provenant de diverses sources, ce qui permet de réaliser des évaluations précises de la faune.

Ultralytics YOLO11 est particulièrement adapté à la détection d’objets en temps réel, ce qui en fait un excellent choix pour des tâches comme la surveillance contre le braconnage, l’analyse des comportements et le suivi des écosystèmes. En intégrant des modèles basés sur l’IA aux efforts de conservation, nous pouvons mieux protéger les espèces, améliorer le suivi de la biodiversité et prendre des décisions plus éclairées pour préserver la faune menacée.

Rejoins notre communauté et explore le dépôt GitHub pour en savoir plus sur la vision par ordinateur. Découvre d’autres applications de l’IA dans le domaine de la santé et de la vision par ordinateur dans l’industrie manufacturière sur nos pages consacrées aux solutions. Consulte les options de licence Ultralytics pour te lancer dans l’IA visuelle.