Comment entraîner des modèles Ultralytics YOLO à détecter des animaux dans la nature

La faune de notre planète est incroyablement diversifiée, des abeilles bourdonnantes aux éléphants imposants, et la préservation de cette biodiversité est essentielle au maintien d'un écosystème équilibré. Cependant, les efforts de conservation deviennent plus difficiles en raison de la perte d'habitat, du braconnage et du changement climatique. Tous ces facteurs affectent négativement les populations sauvages.

Les méthodes traditionnelles de suivi des animaux, comme l'analyse manuelle des images de pièges photographiques et la réalisation d'études sur le terrain, peuvent être lentes et nécessiter beaucoup de ressources. Ces efforts échouent souvent à couvrir efficacement de vastes zones et de grandes populations.

Pour surmonter ces limitations, l'intelligence artificielle (IA) peut être utilisée comme un outil percutant dans la conservation de la faune. Plus précisément, des modèles de vision par ordinateur comme Ultralytics YOLO11 peuvent analyser des données visuelles comme des images et des vidéos pour 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 YOLO11, sont très utiles ici. En analysant les données visuelles, ces tâches nous aident à collecter des données cruciales, à identifier des modèles écologiques et à réagir plus efficacement aux menaces environnementales.

Dans cet article, nous allons parcourir le processus d'entraînement de YOLO11 pour détecter des animaux. Commençons !

Link to this sectionDémarrer avec Ultralytics YOLO11#

Avant de plonger dans le tutoriel, jetons un coup d'œil aux différentes options de configuration et aux outils dont tu auras besoin pour entraîner et utiliser YOLO11.

L'outil principal dont tu auras besoin est le paquet Python Ultralytics, qui facilite le travail avec les 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 paquet Ultralytics, tu devras configurer un environnement pour exécuter ton code, et il existe diverses options parmi lesquelles tu peux choisir.

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

• Interface de ligne de commande (CLI) : La CLI, aussi connue sous le nom de terminal, est un outil textuel qui te permet d'interagir avec ton ordinateur en tapant des commandes. Contrairement aux interfaces graphiques (GUI), où tu cliques sur des boutons et utilises une souris, la CLI exige que tu tapes des instructions textuelles pour exécuter des programmes ou effectuer des tâches.
• Jupyter Notebooks : Ces carnets te permettent d'écrire et d'exécuter du code par petits morceaux appelés cellules. C'est interactif, ce qui signifie que tu peux voir le résultat de ton code immédiatement, ce qui facilite les tests et le débogage.
• Google Colab : Google Colab est une plateforme basée sur le cloud qui fonctionne comme Jupyter Notebooks mais offre un accès gratuit à de puissants GPU. C'est facile à configurer et tu n'as rien à installer sur ton ordinateur.

Bien qu'il existe d'autres options pour configurer ton environnement que tu peux explorer dans la documentation officielle Ultralytics, les trois options mentionnées ci-dessus nécessitent très peu de configuration et sont faciles à utiliser, ce qui les rend idéales pour démarrer rapidement.

Dans ce tutoriel, nous montrerons comment configurer et entraîner YOLO11 en utilisant Google Colab, Jupyter Notebooks ou un simple fichier Python, car les étapes sont très similaires dans tous ces environnements.

Link to this sectionComprendre le jeu de données African Wildlife Dataset#

Après avoir sélectionné un environnement de développement, pour entraîner YOLO11 à détecter spécifiquement des animaux sauvages, nous avons besoin d'un jeu de données de haute qualité d'images étiquetées. Chaque image doit montrer clairement où se trouvent les animaux et de quel type ils sont, afin que le modèle puisse apprendre à les reconnaître grâce à l'apprentissage supervisé.

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

Fig 1. Un aperçu du African Wildlife Dataset.

Voici quelques caractéristiques clés du African Wildlife Dataset :

• Échelle : Le jeu de données se compose de 1504 images divisées en trois sous-ensembles : 1052 pour l'entraînement, 225 pour la validation et 227 pour les tests. Cette séparation garantit que le modèle apprend efficacement et est minutieusement évalué.
• Intégration transparente : Ultralytics fournit un fichier de configuration YAML qui définit les chemins du jeu de données, les classes et d'autres détails, facilitant son utilisation lors de l'entraînement des modèles YOLO.
• Licence ouverte : Ce jeu de données est distribué sous la licence AGPL-3.0, encourageant la transparence et la collaboration.

Link to this sectionEntraîner Ultralytics YOLO11 pour la détection d'animaux#

Maintenant que nous avons exploré le African Wildlife Dataset, nous pouvons commencer à entraîner un modèle YOLO11 pour détecter des animaux dans des images. Le processus implique la configuration de l'environnement de développement, l'entraînement du modèle YOLO11 et l'évaluation des performances du modèle.

Link to this sectionÉtape 1 : Configuration de l'environnement#

Pour commencer, nous allons préparer un environnement pour entraîner et tester le modèle. Google Colab, Jupyter Notebooks ou un simple fichier Python peuvent être utilisés, selon ta préférence. Crée un nouveau notebook Google Colab, Jupyter Notebook ou un fichier Python en conséquence.

Si tu utilises Google Colab, l'environnement s'exécute par défaut sur un CPU (unité centrale), ce qui peut ralentir l'entraînement. Pour accélérer le processus, surtout pour les modèles plus grands, tu peux changer l'exécution pour utiliser un GPU. Dans Google Colab, tu peux naviguer vers l'onglet "Exécution" dans le menu, sélectionner "Changer le type d'exécution" et régler l'accélérateur matériel sur un GPU (de préférence un GPU T4). C'est important pour réduire les temps d'entraînement.

Ensuite, peu importe l'environnement que tu utilises, tu dois installer le paquet Python Ultralytics. Si tu utilises un environnement basé sur un carnet (Google Colab ou Jupyter), exécute la commande suivante avec un point d'exclamation (!) au début.

pip install ultralytics

Link to this sectionÉtape 2 : Chargement de YOLO11 et préparation du jeu de données#

Une fois le paquet Ultralytics installé, l'étape suivante consiste à charger le modèle YOLO11 et à préparer le jeu de données pour l'entraînement. Premièrement, nous chargeons le modèle YOLO11, qui est déjà pré-entraîné sur des tâches de détection d'objets générales. Ce modèle pré-entraîné nous donne un bon point de départ, car il a déjà appris à détecter divers objets.

Ensuite, nous spécifions le jeu de données en utilisant 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 African Wildlife Dataset est pris en charge par le paquet Ultralytics, donc il se téléchargera automatiquement lorsque tu lanceras l'entraînement, t'épargnant la peine de le configurer manuellement.

Une fois que le jeu de données est prêt, le modèle commence son entraînement. Le modèle parcourra le jeu de données plusieurs fois, un processus appelé entraînement sur plusieurs époques, pour améliorer sa capacité à reconnaître les animaux dans les images. Au cours de ce processus, les images seront redimensionnées à une taille cohérente pour le traitement, et le modèle travaillera avec un nombre défini d'images à la fois, appelé batch. Cela aide le modèle à apprendre plus efficacement.

En résumé, le modèle est chargé, le jeu de données est automatiquement téléchargé et l'entraînement commence pour détecter les animaux basés sur le African Wildlife Dataset 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)

Link to this sectionÉtape 3 : Parcours de l'entraînement YOLO11#

Une fois l'extrait de code ci-dessus exécuté, le modèle commence l'entraînement basé sur les paramètres que nous lui avons donnés. Nous avons indiqué au modèle via le code de parcourir les images d'entraînement 30 fois. Cela signifie que le modèle regardera toutes les images du jeu de données 30 fois, apprenant un peu plus à chaque fois.

Imagine que tu essaies d'apprendre à dessiner un animal. La première fois que tu dessines, ça pourrait ne pas être beau, mais après avoir pratiqué encore et encore, tu commences à t'améliorer. Chaque fois que tu réessaies, tu apprends de ce qui n'a pas fonctionné et tu le corriges. C'est ce que fait chaque époque pour le modèle - il regarde les images, fait des erreurs, en tire des leçons et s'améliore à chaque fois dans la reconnaissance des animaux.

Si le code d'entraînement s'exécute avec succès, tu verras la sortie suivante au fur et à mesure que l'entraînement progresse :

• Configuration de l'entraînement : La première partie montre la version d'Ultralytics, de PyTorch et le matériel utilisé (CPU dans ce cas), ainsi que la configuration de l'entraînement, incluant le modèle (yolo11n.pt), la taille du batch, les époques et la taille de l'image.
• Résumé du modèle : Il fournit des informations sur la complexité du modèle, comme le nombre de couches et de paramètres, montrant quelle est la taille du modèle.
• Optimiseur et taux d'apprentissage : Il mentionne l'optimiseur (ex. AdamW) et le taux d'apprentissage, qui contrôlent la façon dont le modèle ajuste ses paramètres pendant l'entraînement.
• Analyse du jeu de données : Le modèle scanne le jeu de données, montrant combien d'images sont valides et prêtes pour l'entraînement. Il confirme qu'il n'y a aucun problème avec le jeu de données.
• Progression de l'entraînement : La sortie se met à jour après chaque époque (cycle d'entraînement), montrant la progression de l'entraînement ainsi que les valeurs de perte clés (box_loss, cls_loss, dfl_loss), qui indiquent à quel point le modèle apprend bien.
• Métriques de performance : Après chaque époque, tu verras des métriques de performance comme la précision, le rappel et le mAP (précision moyenne moyenne). Ces valeurs montrent à quel point le modèle est précis pour détecter et classer les objets.
• Utilisation de la mémoire GPU : Si tu utilises un GPU, la sortie montre l'utilisation de la mémoire pour suivre l'utilisation du matériel.

Fig 2. La sortie que tu verras pendant que l'entraînement du modèle est en cours.

Link to this sectionÉtape 4 : Évaluer les performances du modèle personnalisé#

Une fois le processus d'entraînement terminé, tu peux examiner et valider les métriques de performance du modèle. Dans Google Colab, tu peux naviguer vers le dossier "runs", puis vers le dossier "detect" et enfin vers le dossier "train", où tu trouveras des journaux affichant les indicateurs de performance clés.

Pour les utilisateurs dans un environnement Python, les résultats de l'entraînement sont enregistrés par défaut dans le répertoire “runs/train/” au sein de ton répertoire de travail actuel. Chaque cycle d'entraînement crée un nouveau sous-répertoire (ex. runs/train/exp, runs/train/exp2, etc.), où tu peux trouver les journaux et autres sorties liées à l'entraînement.

Si tu utilises la CLI, tu peux facilement accéder à ces résultats et paramètres en utilisant la commande “yolo settings”, qui te permet de voir ou de modifier les chemins et d'autres configurations liées aux journaux d'entraînement et aux détails de l'expérience.

Parmi les journaux, tu trouveras également des graphiques que tu peux consulter pour voir comment s'est déroulé le processus d'entraînement du modèle. Ces graphiques, créés une fois l'entraînement terminé, montrent 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, montrant comment la perte (la différence entre les prédictions du modèle et les valeurs réelles) a diminué et comment la précision a augmenté pendant l'entraînement. Cela t'aide à comprendre à quel point 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. Un exemple des graphiques que tu peux analyser pour évaluer ton modèle.

Link to this sectionMétriques clés d'évaluation des performances#

Aussi, voici un examen plus approfondi de certaines des métriques que tu peux utiliser pour évaluer les performances du modèle :

• Précision moyenne moyenne (mAP) : Cette métrique mesure la précision globale du modèle dans la détection des animaux sur toutes les classes en faisant la moyenne des scores de précision à différents niveaux de rappel.
• Précision : Cela représente le pourcentage de détections qui sont correctes, calculé en divisant le nombre de détections vraies positives par le nombre total de détections effectuées.
• Rappel : Il indique le pourcentage d'animaux réels dans les images qui ont été correctement identifiés par le modèle, reflétant sa capacité à capturer toutes les instances pertinentes.

Ces métriques d'évaluation peuvent aider à affiner le modèle pour améliorer la précision avant de l'utiliser dans des applications du monde réel.

Link to this sectionExécuter des inférences en utilisant ton modèle YOLO11 personnalisé#

Maintenant que nous avons entraîné et évalué YOLO11, 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 de différentes sources.

Nous utiliserons 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 vers le fichier des meilleurs poids du modèle ("best.pt") stocké dans le répertoire des résultats. Le modèle YOLO11 personnalisé est chargé en utilisant ces poids.

Après cela, le chemin vers une image du jeu de données de test African Wildlife est défini. Le modèle est appliqué à cette image pour la détection d'objets, les résultats sont générés et la sortie (comme les objets détectés ou les annotations) est enregistrée.

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 affichée ci-dessous sera enregistrée dans le dossier "predict" situé dans le répertoire runs/detect. Pour les tests ultérieurs, de nouveaux dossiers comme "predict2", "predict3", etc., seront créés pour stocker les images.

Fig 4. Exécuter une inférence en utilisant le modèle YOLO11 affiné sur une image de test.

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 affichée ci-dessous sera enregistrée dans le dossier approprié.

Fig 5. Détecter la faune en utilisant le modèle YOLO11 affiné sur une image non vue.

Link to this sectionL'IA pour la conservation de la faune : Applications réelles#

Des modèles comme YOLO11 peuvent automatiquement détecter et suivre des animaux, ce qui permet une variété d'applications pratiques. Voici un aperçu de certains des domaines clés où l'IA visuelle peut être utilisée pour soutenir les efforts de conservation de la faune :

• Suivi des espèces : L'IA visuelle peut être utilisée pour traiter des données visuelles comme des images et des vidéos afin d'identifier précisément les espèces, compter les populations et suivre leurs mouvements au fil du temps.
• Alertes de caméra intelligente : Dans les zones reculées, la vision par ordinateur peut être utilisée pour classer en continu les animaux et envoyer des alertes en temps réel, permettant aux autorités de la faune de réagir rapidement aux menaces comme un comportement animal anormal ou des conflits homme-faune.
• Analyse du comportement : En surveillant la migration, les habitudes alimentaires et les interactions sociales, les systèmes d'IA visuelle peuvent fournir des aperçus complets sur la dynamique inter-espèces.
• Prévention du braconnage : L'IA visuelle peut être exploitée pour détecter la présence humaine non autorisée et les signes de braconnage tout en utilisant l'apprentissage automatique et les données historiques pour identifier les points chauds de risque.

Link to this sectionPoints clés#

Des modèles de vision par ordinateur comme YOLO11 peuvent jouer un rôle clé dans la conservation de la faune en automatisant la détection et le suivi des animaux. Avec l'IA visuelle, nous pouvons traiter de grands volumes d'images et de vidéos provenant de diverses sources, rendant possible l'exécution d'évaluations précises de la faune.

Ultralytics YOLO11, en particulier, est un excellent choix pour la détection d'objets en temps réel, ce qui en fait un ajustement parfait pour des tâches telles que la surveillance anti-braconnage, l'analyse comportementale et le suivi des écosystèmes. En intégrant des modèles basés sur l'IA dans les 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 sauvegarder la faune menacée.

Rejoins notre communauté et explore le référentiel GitHub pour en apprendre davantage sur la vision par ordinateur. Découvre plus d'applications liées à l'IA dans la santé et la vision par ordinateur dans la fabrication sur nos pages de solutions. Consulte les options de licence Ultralytics pour démarrer avec l'IA visuelle.