Comment entraîner les modèlesYOLO 'Ultralytics à détecter les 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 ont un impact négatif sur les populations d'animaux sauvages. 

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

Pour surmonter ces limites, l'intelligence artificielle (IA) peut être utilisée comme un outil ayant un impact sur la conservation de la faune et de la flore. 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 pour automatiser l'identification et le suivi des animaux en temps réel. 

Les tâches de vision par ordinateur telles que 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 à la détection des animaux. Commençons !

Dé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 te former et utiliser YOLO11. 

Le principal outil dont tu auras besoin est le packageUltralytics Python , qui permet de travailler facilement avec des modèles YOLO pour des tâches telles que l'entraînement, la détection d'objets et l'exécution d'inférences. Pour utiliser le package Ultralytics , tu devras configurer un environnement pour exécuter ton code, et tu peux choisir parmi plusieurs options.

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

• Interface de ligne de commande (CLI): La CLI, également 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 te demande de taper des instructions textuelles pour lancer des programmes ou exécuter des tâches.
  ‍
• Carnets de notes Jupyter: Ces carnets te permettent d'écrire et d'exécuter du code en petits morceaux appelés cellules. C'est interactif, ce qui signifie que tu peux voir immédiatement la sortie de ton code, 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 qui offre un accès gratuit à de puissants GPU. Elle est facile à configurer et tu n'as pas besoin d'installer quoi que ce soit sur ton ordinateur.

Bien qu'il existe d'autres options pour configurer ton environnement que tu peux explorer dans la documentation officielle d'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 allons présenter 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.

Comprendre le jeu de données sur la faune africaine

Après avoir sélectionné un environnement de développement, pour entraîner YOLO11 à détecter spécifiquement les animaux sauvages, nous avons besoin d'un ensemble de données de haute qualité composé d'images étiquetées. Chaque image doit indiquer 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 jeu de données sur la faune africaine. Il est pris en charge par le packagePython Ultralytics et est spécifiquement conçu pour détecter les animaux que l'on trouve couramment 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.

‍

Voici quelques caractéristiques clés de la base de données sur la faune africaine :

• Échelle : L'ensemble de données se compose de 1504 images divisées en trois sous-ensembles : 1052 pour la formation, 225 pour la validation et 227 pour le test. Cette répartition permet de s'assurer que le modèle apprend efficacement et qu'il est évalué de manière approfondie.
  
  
• Intégration transparente : 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 lors de la formation des modèles YOLO .
  
  
• Licence ouverte : Cet ensemble de données est distribué sous la licence AGPL-3.0 , qui encourage la transparence et la collaboration.

Entraîne Ultralytics YOLO11 à la détection des animaux

Maintenant que nous avons exploré l'ensemble de données sur la faune africaine, nous pouvons commencer à entraîner un modèle YOLO11 pour détecter les animaux dans les images. Le processus consiste à configurer l'environnement de développement, à entraîner le modèle YOLO11 et à évaluer les performances du modèle.

Étape 1 : Mise en place 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 tes préférences. Crée un nouveau carnet Google Colab, un carnet Jupyter ou un fichier Python en conséquence.

Si tu utilises Google Colab, l'environnement fonctionne par défaut sur un CPU (Central Processing Unit), ce qui peut ralentir la formation. Pour accélérer le processus, en particulier pour les modèles plus importants, tu peux basculer le temps d'exécution pour utiliser un GPU. Dans Google Colab, tu peux naviguer jusqu'à l'onglet "Runtime" dans le menu, sélectionner "Change runtime type" 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 de formation.

Ensuite, quel que soit l'environnement que tu utilises, tu dois installer le paquetagePython Ultralytics . Si tu utilises un environnement basé sur un carnet de notesGoogle Colab ou Jupyter), exécute la commande suivante avec un point d'exclamation ( !) au début.

pip install ultralytics

‍

Étape 2 : Chargement de YOLO11 et préparation du jeu de données

Une fois le package Ultralytics installé, l'étape suivante consiste à charger le modèle YOLO11 et à préparer l'ensemble de données pour l'entraînement. Tout d'abord, nous chargeons le modèle YOLO11 , qui est déjà pré-entraîné sur des tâches générales de détection d'objets. 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 l'ensemble 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 l'ensemble de données et quels objets il doit apprendre à reconnaître. 

L'ensemble de données sur la faune africaine est pris en charge par le progiciel Ultralytics , il sera donc automatiquement téléchargé lorsque tu lanceras la formation, ce qui t'évitera de le configurer manuellement.

Une fois que l'ensemble de données est prêt, le modèle commence à s'entraîner. Le modèle parcourra l'ensemble 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. 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é lot. Cela permet au modèle d'apprendre plus efficacement.

En bref, le modèle est chargé, l'ensemble de données est automatiquement téléchargé et l'entraînement commence à fonctionner pour détecter les animaux en fonction de l'ensemble de données sur la faune africaine 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)

‍

Étape 3 : Formation à YOLO11

Une fois que l'extrait de code ci-dessus est exécuté, le modèle commence à s'entraîner en fonction des paramètres que nous lui avons donnés. Nous avons demandé au modèle, par l'intermédiaire du code, d'examiner les images d'entraînement 30 fois. Cela signifie donc que le modèle examinera toutes les images de l'ensemble de données 30 fois, en apprenant à chaque fois un peu plus.

Imagine que tu essaies d'apprendre à dessiner un animal. La première fois que tu dessines, ça n'a peut-être pas l'air bien, mais après t'être entraîné encore et encore, tu commences à t'améliorer. Chaque fois que tu essaies à nouveau, tu apprends ce qui n'a pas fonctionné et tu le corriges. C'est ce que chaque époque fait pour le modèle - il regarde les images, fait des erreurs, en tire des leçons et s'améliore à chaque fois pour reconnaître les animaux.

Si le code de formation s'exécute correctement, tu verras les résultats suivants au fur et à mesure que la formation progresse :

• Configuration de l'entraînement: La première partie montre la version d'Ultralytics, PyTorch et le matériel utiliséCPU dans ce cas), ainsi que la configuration de l'entraînement, y compris le modèle (yolo11n.pt), la taille du lot, 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 ainsi la taille du modèle.
  ‍
• Optimiseur et taux d'apprentissage: Il mentionne l'optimiseur (par exemple, 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 de l'ensemble des données: Le modèle scanne l'ensemble de données, montrant ainsi combien d'images sont valides et prêtes pour l'entraînement. Il confirme que l'ensemble de données ne pose aucun problème.
  ‍
• Progression de l'apprentissage: La sortie se met à jour après chaque époque (cycle de formation), montrant la progression de la formation ainsi que les principales valeurs de perte (box_loss, cls_loss, dfl_loss), qui indiquent la qualité de l'apprentissage du modèle.

• Mesures de performance: Après chaque époque, tu verras apparaître des mesures de performance telles que la précision, le rappel et la mAP (précision moyenne). Ces valeurs montrent à quel point le modèle est précis dans la détection et la classification des objets.
  ‍
• Utilisation de la mémoire duGPU : Si tu utilises un GPU, la sortie indique l'utilisation de la mémoire pour suivre l'utilisation du matériel.

‍

Étape 4 : Évaluer les performances du modèle formé sur mesure

Une fois le processus de formation terminé, tu peux examiner et valider les mesures 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 clés de performance.

Pour les utilisateurs d'un environnement Python , les résultats de la formation sont enregistrés par défaut dans le répertoire "runs/train/" dans ton répertoire de travail actuel. Chaque formation crée un nouveau sous-répertoire (par exemple, runs/train/exp, runs/train/exp2, etc.), dans lequel tu peux trouver les journaux et autres résultats liés à la formation.

Si tu utilises l'CLI, tu peux facilement accéder à ces résultats et paramètres en utilisant la commande "yolo settings", qui te permet d'afficher ou de modifier les chemins et 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 pourras consulter pour voir si le processus de formation du modèle s'est bien déroulé. Ces graphiques, créés une fois la formation terminée, 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 les progrès du modèle, en 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é au cours de la formation. 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 la formation.

‍

Principales mesures d'évaluation des performances

De plus, voici un examen plus approfondi de certaines des mesures que tu peux utiliser pour é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 dans toutes les classes en faisant 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 vraies détections 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, ce qui reflète sa capacité à capturer toutes les instances pertinentes.

Ces mesures d'évaluation peuvent aider à affiner le modèle pour en améliorer la précision avant de l'utiliser dans des applications réelles.

Effectuer des déductions à l'aide de ton modèle YOLO11 personnalisé

Maintenant que nous avons entraîné et évalué YOLO11, il est temps de l'utiliser pour analyser les images et faire des déductions. Tu peux utiliser les images de test de l'ensemble de données ou de nouvelles images provenant de sources différentes.

Nous utiliserons l'extrait de code suivant pour exécuter le modèle sur une image de l'ensemble de données de test. Il importe les modules nécessaires de la bibliothèque Ultralytics . Il définit ensuite le chemin d'accès au fichier des poids du meilleur modèle ("best.pt") stocké dans le répertoire des résultats. Le modèle YOLO11 entraîné sur mesure est chargé à l'aide de ces poids. 

Ensuite, le chemin d'accès à une image de l'ensemble de données de test de la faune africaine 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 sauvegardée.

from ultralytics import settings

best_model_path = results.save_dir / "weights/best.pt"

model = YOLO(best_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 illustrée ci-dessous sera enregistrée dans le dossier "predict" situé dans le répertoire runs/detect. Pour les tests suivants, de nouveaux dossiers tels que "predict2", "predict3", et ainsi de suite, seront créés pour stocker les images.

‍

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

best_model_path = results.save_dir / "weights/best.pt"

model = YOLO(best_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 illustrée ci-dessous sera enregistrée dans le dossier approprié.

‍

L'IA pour la conservation de la faune et de la flore : Applications dans le monde réel

Des modèles comme YOLO11 peuvent détecter et suivre automatiquement les animaux, ce qui permet une variété d'applications pratiques. Voici un aperçu de quelques-uns des principaux domaines dans lesquels Vision AI peut être utilisée pour soutenir les efforts de conservation de la faune et de la flore:

• Suivi des espèces : L'IA de la vision peut être utilisée pour traiter des données visuelles comme des images et des vidéos afin d'identifier avec précision les espèces, de compter les populations et de suivre leurs mouvements au fil du temps.
  ‍
• Alertes par caméra intelligente : Dans les zones reculées, la vision par ordinateur peut être utilisée pour classer les animaux en continu et envoyer des alertes en temps réel, ce qui permet aux autorités responsables de la faune de réagir rapidement aux menaces telles qu'un comportement animal anormal ou des conflits entre l'homme et la faune.
  ‍
• Analyse du comportement : En surveillant la migration, les habitudes alimentaires et les interactions sociales, les systèmes d'IA de vision peuvent fournir des informations complètes sur la dynamique entre les espèces.
  ‍
• Prévention du braconnage : Vision AI peut être exploitée pour détecter la présence humaine non autorisée et les signes de braconnage tout en tirant parti de l'apprentissage automatique et des données historiques pour localiser les points chauds à risque.

Principaux enseignements

Les modèles de vision artificielle comme 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 à Vision AI, nous pouvons traiter de grands volumes d'images et de vidéos provenant de diverses sources, ce qui permet d'effectuer des é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 le rend parfaitement adapté à des tâches telles que la surveillance anti-braconnage, l'analyse comportementale et la surveillance des écosystèmes. En intégrant des modèles pilotés par 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 sauvegarder les espèces sauvages menacées.

Rejoins notre communauté et explore le dépôt GitHub pour en savoir plus sur la vision par ordinateur. Découvre d'autres applications liées à l'IA dans les soins de santé et à la vision par ordinateur dans la fabrication sur nos pages de solutions. Jette un œil aux options de licence d'Ultralytics pour commencer à utiliser l'IA par vision.