514 lines
16 KiB
Markdown
514 lines
16 KiB
Markdown
Modèle prêt à l’emploi pour plantes
|
||
|
||
Un modèle YOLOv8s “Leaf Detection & Classification” est disponible sur Hugging Face.
|
||
Il peut détecter et classer différents types de feuilles de plantes directement, sans entraînement préalable.
|
||
|
||
1) Prérequis / Installation
|
||
|
||
Ouvre un terminal et installe ces dépendances :
|
||
|
||
python3 -m venv venv
|
||
source venv/bin/activate
|
||
|
||
pip install ultralyticsplus==0.0.28 ultralytics==8.0.43 opencv-python matplotlib
|
||
|
||
ultralytics : bibliothèque YOLOv8
|
||
|
||
ultralyticsplus : extension recommandée
|
||
|
||
opencv-python + matplotlib : affichage images
|
||
|
||
2) Exemple de script Python detect_plants.py
|
||
|
||
Crée un fichier detect_plants.py :
|
||
|
||
from ultralyticsplus import YOLO, render_result
|
||
import cv2
|
||
|
||
# 1) Charger le modèle
|
||
model = YOLO("foduucom/plant-leaf-detection-and-classification")
|
||
|
||
# 2) Paramètres de détection
|
||
model.overrides['conf'] = 0.25
|
||
model.overrides['iou'] = 0.45
|
||
model.overrides['max_det'] = 1000
|
||
|
||
# 3) Chargement d’une image
|
||
image_path = "ma_plante.jpg"
|
||
|
||
# 4) Prédiction (détection + classification de feuilles)
|
||
results = model.predict(image_path)
|
||
|
||
# 5) Récupération des boîtes détectées
|
||
boxes = results[0].boxes
|
||
class_ids = results[0].boxes.cls
|
||
scores = results[0].boxes.conf
|
||
|
||
print("Détections :", len(boxes))
|
||
for i, box in enumerate(boxes):
|
||
print(f"- Classe {class_ids[i]}, score {scores[i]:.2f}")
|
||
|
||
# 6) Annoter l’image
|
||
annotated = render_result(model=model, image=image_path, result=results[0])
|
||
|
||
# 7) Afficher l’image annotée
|
||
annotated.show()
|
||
|
||
Points clés :
|
||
|
||
YOLO("foduucom/...") charge le modèle leaf detection YOLOv8.
|
||
|
||
predict(image_path) exécute l’inférence sur l’image locale.
|
||
|
||
3) Mode batch / dossier complet
|
||
|
||
Si tu veux traiter plusieurs images dans un dossier :
|
||
|
||
import glob
|
||
|
||
for file in glob.glob("images/*.jpg"):
|
||
results = model.predict(file)
|
||
|
||
print(f"== Résultats pour {file} ==")
|
||
for box in results[0].boxes:
|
||
print(box.cls, box.conf)
|
||
|
||
render_result(model=model, image=file, result=results[0]).show()
|
||
4) Comment adapter au “type de plante”
|
||
|
||
Le modèle d’origine peut classifier 46 classes de feuilles courantes (pommes, tomates, blé…) avec étiquette.
|
||
|
||
Si tu as ton propre dataset spécifique (autres plantes, fleurs, fruits) → il faut :
|
||
|
||
créer un dataset annoté en format YOLO
|
||
|
||
fine-tuner YOLOv8 dessus
|
||
|
||
utiliser train() de la bibliothèque ultralytics
|
||
|
||
📌 Feuille de consignes (Checklist)
|
||
📌 A) Préparation
|
||
|
||
Python 3.10+ installé
|
||
|
||
GPU disponible si possible (beaucoup + rapide)
|
||
|
||
Images bien cadrées (feuilles principales visibles)
|
||
|
||
📌 B) Installation
|
||
pip install ultralyticsplus ultralytics opencv-python matplotlib
|
||
📌 C) Tester une image
|
||
|
||
Place ma_plante.jpg dans le même dossier
|
||
|
||
Lance :
|
||
|
||
python detect_plants.py
|
||
📌 D) Résultats
|
||
|
||
Vérifier :
|
||
|
||
nombre de feuilles détectées
|
||
|
||
classes attribuées
|
||
|
||
score de confiance
|
||
|
||
📌 E) Prochaine étape (facultative)
|
||
|
||
Si tu veux augmenter la précision :
|
||
|
||
🔹 collecter plus d’images
|
||
🔹 annoter avec LabelImg ou Roboflow
|
||
🔹 entraîner/fine-tuner YOLOv8
|
||
🔹 tester sur mobile/web
|
||
|
||
Limitations à connaître
|
||
|
||
ce modèle est spécifique aux feuilles (pas fleurs/fruit complets).
|
||
|
||
performances variables selon qualité photo.
|
||
|
||
nécessite parfois GPU pour performance fluide.
|
||
|
||
Si tu veux, je peux aussi te fournir une version prête à l’emploi pour entraîner toi-même sur tes propres photos (annotation automatique + scripts d’entraînement YOLO).
|
||
Modèle prêt à l’emploi pour plantes
|
||
|
||
Un modèle YOLOv8s “Leaf Detection & Classification” est disponible sur Hugging Face.
|
||
Il peut détecter et classer différents types de feuilles de plantes directement, sans entraînement préalable.
|
||
|
||
1) Prérequis / Installation
|
||
|
||
Ouvre un terminal et installe ces dépendances :
|
||
|
||
python3 -m venv venv
|
||
source venv/bin/activate
|
||
|
||
pip install ultralyticsplus==0.0.28 ultralytics==8.0.43 opencv-python matplotlib
|
||
|
||
ultralytics : bibliothèque YOLOv8
|
||
|
||
ultralyticsplus : extension recommandée
|
||
|
||
opencv-python + matplotlib : affichage images
|
||
|
||
2) Exemple de script Python detect_plants.py
|
||
|
||
Crée un fichier detect_plants.py :
|
||
|
||
from ultralyticsplus import YOLO, render_result
|
||
import cv2
|
||
|
||
# 1) Charger le modèle
|
||
model = YOLO("foduucom/plant-leaf-detection-and-classification")
|
||
|
||
# 2) Paramètres de détection
|
||
model.overrides['conf'] = 0.25
|
||
model.overrides['iou'] = 0.45
|
||
model.overrides['max_det'] = 1000
|
||
|
||
# 3) Chargement d’une image
|
||
image_path = "ma_plante.jpg"
|
||
|
||
# 4) Prédiction (détection + classification de feuilles)
|
||
results = model.predict(image_path)
|
||
|
||
# 5) Récupération des boîtes détectées
|
||
boxes = results[0].boxes
|
||
class_ids = results[0].boxes.cls
|
||
scores = results[0].boxes.conf
|
||
|
||
print("Détections :", len(boxes))
|
||
for i, box in enumerate(boxes):
|
||
print(f"- Classe {class_ids[i]}, score {scores[i]:.2f}")
|
||
|
||
# 6) Annoter l’image
|
||
annotated = render_result(model=model, image=image_path, result=results[0])
|
||
|
||
# 7) Afficher l’image annotée
|
||
annotated.show()
|
||
|
||
Points clés :
|
||
|
||
YOLO("foduucom/...") charge le modèle leaf detection YOLOv8.
|
||
|
||
predict(image_path) exécute l’inférence sur l’image locale.
|
||
|
||
3) Mode batch / dossier complet
|
||
|
||
Si tu veux traiter plusieurs images dans un dossier :
|
||
|
||
import glob
|
||
|
||
for file in glob.glob("images/*.jpg"):
|
||
results = model.predict(file)
|
||
|
||
print(f"== Résultats pour {file} ==")
|
||
for box in results[0].boxes:
|
||
print(box.cls, box.conf)
|
||
|
||
render_result(model=model, image=file, result=results[0]).show()
|
||
4) Comment adapter au “type de plante”
|
||
|
||
Le modèle d’origine peut classifier 46 classes de feuilles courantes (pommes, tomates, blé…) avec étiquette.
|
||
|
||
Si tu as ton propre dataset spécifique (autres plantes, fleurs, fruits) → il faut :
|
||
|
||
créer un dataset annoté en format YOLO
|
||
|
||
fine-tuner YOLOv8 dessus
|
||
|
||
utiliser train() de la bibliothèque ultralytics
|
||
|
||
📌 Feuille de consignes (Checklist)
|
||
📌 A) Préparation
|
||
|
||
Python 3.10+ installé
|
||
|
||
GPU disponible si possible (beaucoup + rapide)
|
||
|
||
Images bien cadrées (feuilles principales visibles)
|
||
|
||
📌 B) Installation
|
||
pip install ultralyticsplus ultralytics opencv-python matplotlib
|
||
📌 C) Tester une image
|
||
|
||
Place ma_plante.jpg dans le même dossier
|
||
|
||
Lance :
|
||
|
||
python detect_plants.py
|
||
📌 D) Résultats
|
||
|
||
Vérifier :
|
||
|
||
nombre de feuilles détectées
|
||
|
||
classes attribuées
|
||
|
||
score de confiance
|
||
|
||
📌 E) Prochaine étape (facultative)
|
||
|
||
Si tu veux augmenter la précision :
|
||
|
||
🔹 collecter plus d’images
|
||
🔹 annoter avec LabelImg ou Roboflow
|
||
🔹 entraîner/fine-tuner YOLOv8
|
||
🔹 tester sur mobile/web
|
||
|
||
Limitations à connaître
|
||
|
||
ce modèle est spécifique aux feuilles (pas fleurs/fruit complets).
|
||
|
||
performances variables selon qualité photo.
|
||
|
||
nécessite parfois GPU pour performance fluide.
|
||
|
||
Si tu veux, je peux aussi te fournir une version prête à l’emploi pour entraîner toi-même sur tes propres photos (annotation automatique + scripts d’entraînement YOLO).
|
||
Voici des outils et méthodes open-source que tu peux utiliser pour annoter automatiquement ou semi-automatiquement un dataset d’images (pour entraîner YOLOv8 ou tout autre modèle de détection), y compris pour des plantes, feuilles, fleurs, etc. :
|
||
|
||
🧩 Outils d’annotation (semi-automatique et automatique)
|
||
📌 1) Roboflow Annotate
|
||
|
||
Plateforme web qui propose des outils d’assistance par IA pour accélérer l’annotation :
|
||
|
||
Possibilité d’importer tes images et de générer des annotations avec de l’assistance IA (Label Assist / Auto Label).
|
||
|
||
Permet d’exporter les annotations en formats compatibles YOLO.
|
||
|
||
Gratuit jusqu’à certaines limites, fonctionne via interface web.
|
||
|
||
Pas besoin d’héberger toi-même un serveur.
|
||
|
||
📌 2) Auto-Annotation avec Autodistill + Grounding DINO
|
||
|
||
Une approche plus avancée pour annoter automatiquement des images :
|
||
|
||
Utilise des modèles de type Grounding DINO pour détecter des objets selon un texte (ex : “feuille”, “fleur”, “fruit”).
|
||
|
||
Génère ensuite automatiquement des fichiers d’annotation cachés au format YOLO.
|
||
|
||
Cette méthode diminue le travail humain car elle produit d’abord des étiquettes automatiques que l’on peut ensuite corriger.
|
||
|
||
C’est pratique si tu as beaucoup d’images brutes à annoter.
|
||
|
||
📌 3) CVAT (Computer Vision Annotation Tool)
|
||
|
||
Outil open source complet pour annotations :
|
||
|
||
Interface web pour annoter images et vidéos.
|
||
|
||
Supporte la pré-annotation automatique à partir de modèles pré-entraînés (tu peux importer un modèle YOLO).
|
||
|
||
Permet d’économiser du temps en générant des boîtes automatiquement puis en les corrigeant.
|
||
|
||
Convient bien pour des datasets de plantes.
|
||
|
||
👉 CVAT est l’un des outils les plus utilisés dans la communauté CV pour annotation manuelle assistée par IA ou modèles pré-entraînés.
|
||
|
||
📌 4) Outils open-source d’annotation classiques
|
||
|
||
Si tu veux annoter manuellement ou semi-manuellement :
|
||
|
||
LabelImg – outil graphique pour créer des boîtes et exporter en YOLO.
|
||
|
||
Label Studio – annotation flexible multi-tâches (mais souvent plus généraliste).
|
||
|
||
Autres outils listés (Yolo_Label, Make Sense, Scalabel, etc.) pour différents formats et workflows.
|
||
|
||
🧠 Méthodes d’annotation automatique (workflow avancé)
|
||
|
||
Voici comment automatiser ton annotation avant d’entraîner YOLO :
|
||
|
||
1. Pré-annotation automatique avec modèle existant
|
||
|
||
Charge un modèle de vision comme YOLOv8 ou un autre détecteur pré-entraîné.
|
||
|
||
Passe tes images au modèle pour générer des boîtes et labels provisoires.
|
||
|
||
Convertis ces détections en fichiers .txt YOLO.
|
||
|
||
Révise / corrige les erreurs ensuite (important car l’auto-annotation n’est pas parfaite).
|
||
|
||
2. Utiliser Segment Anything / Autodistill
|
||
|
||
Combine Segment Anything (SAM) avec un modèle de détection (ex : Grounding DINO).
|
||
|
||
Segment Anything fournit des masques / régions intéressantes.
|
||
|
||
Grounding DINO relie ces régions à des classes par texte.
|
||
|
||
Autodistill convertit ensuite ce résultat en étiquettes format YOLO.
|
||
|
||
Utile pour réduire le travail manuel et créer rapidement un dataset.
|
||
|
||
🔎 Résumé des possibilités
|
||
Outil / Méthode Automatique possible Semi-Automatique Export YOLO
|
||
Roboflow Annotate ✔️ (modèles IA intégrés) ✔️ ✔️
|
||
Autodistill + DINO ✔️ ⬜ ✔️
|
||
CVAT ✔️ (pré-annotation) ✔️ ✔️
|
||
LabelImg / Label Studio ⬜ ✔️ ✔️
|
||
⚠️ Conseils importants
|
||
|
||
Auto-annotation n’est jamais parfaite — vérifie et corrige toujours les annotations manuellement pour que le modèle que tu entraine apprenne bien.
|
||
|
||
L’annotation est souvent le goulot d’étranglement des projets CV : mieux les étiquettes sont, meilleur sera ton modèle.
|
||
|
||
Si tu veux, je peux te générer un script Python qui intègre Autodistill + Grounding DINO pour auto-annoter ton dossier d’images plantes en format YOLO. Veux-tu un tel script prêt à l’emploi ? (Si oui, dis-moi le système d’exploitation que tu utilises : Linux, Windows ou macOS.)
|
||
|
||
Voici un script Python auto-hôte complet pour annoter automatiquement ton propre dataset d’images (par exemple feuilles/fleurs/plantes) au format YOLO, en utilisant Autodistill + un modèle de type Grounding DINO pour générer automatiquement les fichiers d’annotation avant entraînement YOLOv8.
|
||
|
||
Ce workflow utilise l’outil Autodistill, qui combine des « base models » (par exemple GroundedSAM/Grounding DINO) pour auto-labeler des images et génère ensuite un dataset prêt à l’entraînement YOLOv8 — sans annotation manuelle préalable.
|
||
|
||
✅ 1) Installation des dépendances
|
||
|
||
Dans un terminal, crée un environnement Python propre et installe les librairies nécessaires :
|
||
|
||
python3 -m venv venv
|
||
source venv/bin/activate
|
||
|
||
pip install autodistill autodistill-grounded-sam autodistill-yolov8 ultralytics opencv-python
|
||
|
||
autodistill : framework principal pour auto-annotation
|
||
|
||
autodistill-grounded-sam : combine Grounding DINO + SAM pour auto-labeling
|
||
|
||
autodistill-yolov8 : plugin pour entraîner YOLOv8 après génération
|
||
|
||
ultralytics, opencv-python : pour l’entraînement et le test YOLOv8
|
||
|
||
📁 2) Organisation du dataset
|
||
|
||
Place toutes tes images non annotées dans un dossier unique, par exemple :
|
||
|
||
dataset/
|
||
raw_images/
|
||
photo1.jpg
|
||
photo2.jpg
|
||
...
|
||
🧠 3) Script Python d’auto-annotation + préparation YOLO
|
||
|
||
Crée un fichier auto_annotate_and_export.py :
|
||
|
||
from autodistill_grounded_sam import GroundedSAM
|
||
from autodistill.detection import CaptionOntology
|
||
import os
|
||
import json
|
||
|
||
# =========================
|
||
# 1) Définir l'ontologie
|
||
# =========================
|
||
# Chaque clé est une **description textuelle** que le modèle tentera
|
||
# de repérer dans l'image. La valeur est l'étiquette qui sera utilisée.
|
||
# Tu peux ajouter autant de classes que nécessaire :
|
||
ontology_map = {
|
||
"leaf of a plant": "leaf",
|
||
"flower of a plant": "flower",
|
||
"fruit of a plant": "fruit"
|
||
}
|
||
|
||
base_model = GroundedSAM(ontology=CaptionOntology(ontology_map))
|
||
|
||
# =========================
|
||
# 2) Folder paths
|
||
# =========================
|
||
INPUT_FOLDER = "./dataset/raw_images"
|
||
OUTPUT_FOLDER = "./dataset/auto_labeled"
|
||
|
||
os.makedirs(OUTPUT_FOLDER, exist_ok=True)
|
||
|
||
# =========================
|
||
# 3) Auto-label all images
|
||
# =========================
|
||
print("⏳ Auto-labeling images with GroundedSAM (Grounding DINO + SAM)...")
|
||
base_model.label_folder(
|
||
input_folder=INPUT_FOLDER,
|
||
output_folder=OUTPUT_FOLDER
|
||
)
|
||
|
||
print("🟢 Auto-labeling terminé !")
|
||
print(f"Annotations générées dans : {OUTPUT_FOLDER}")
|
||
📌 Ce que fait le script
|
||
|
||
Il lance GroundedSAM (basé sur Grounding DINO + SAM) pour analyser chaque image.
|
||
|
||
Il utilise les prompts textuels que tu définis dans la variable ontology_map pour associer chaque objet détecté à une classe.
|
||
|
||
Il écrit automatiquement les fichiers d’annotation au format YOLO dans le dossier auto_labeled.
|
||
|
||
Le résultat est un dataset prêt à l’entraînement YOLOv8.
|
||
|
||
📝 4) Vérifier les résultats
|
||
|
||
Après ce script, ton dossier dataset/auto_labeled doit contenir :
|
||
|
||
dataset/auto_labeled/
|
||
images/
|
||
photo1.jpg
|
||
photo2.jpg
|
||
...
|
||
labels/
|
||
photo1.txt
|
||
photo2.txt
|
||
...
|
||
|
||
Chaque .txt contient des lignes du type :
|
||
|
||
0 0.4532 0.3124 0.1824 0.2763
|
||
|
||
(correspondant à <class_id> <x_center> <y_center> <w> <h> au format YOLO)
|
||
|
||
🚀 5) Entraînement YOLOv8 sur les données générées
|
||
|
||
Ensuite, tu peux entraîner YOLOv8 avec ces annotations :
|
||
|
||
✍ Crée un fichier data.yaml :
|
||
path: dataset/auto_labeled
|
||
train: images
|
||
val: images
|
||
|
||
names:
|
||
0: leaf
|
||
1: flower
|
||
2: fruit
|
||
|
||
Assure-toi que l’ordre des noms correspond à l’ordre utilisé dans ontology_map.
|
||
|
||
🎓 Lance l’entraînement
|
||
|
||
Dans ton terminal :
|
||
|
||
yolo task=detect mode=train model=yolov8n.pt data=data.yaml epochs=50 imgsz=640
|
||
|
||
model=yolov8n.pt : YOLOv8-nano (léger, rapide)
|
||
|
||
epochs=50 : nombre d’itérations d’entraînement
|
||
|
||
imgsz=640 : taille des images
|
||
|
||
📌 6) Tester ton modèle
|
||
|
||
Après entraînement, test :
|
||
|
||
yolo task=detect mode=predict model=runs/detect/train/weights/best.pt source="test_images/"
|
||
|
||
Les images annotées seront enregistrées sous runs/detect/predict.
|
||
|
||
🧾 Résumé des étapes
|
||
Étape Description
|
||
1 Installer Autodistill & plugins
|
||
2 Mettre toutes les images brutes dans un dossier
|
||
3 Lancer le script d’auto-annotation
|
||
4 Vérifier images + .txt générés
|
||
5 Entraîner YOLOv8 avec ces données
|
||
6 Tester le modèle entraîné
|
||
⚠️ Conseils & limitations
|
||
|
||
L’auto-annotation n’est pas parfaite : certains objets peuvent être mal classés ou mal localisés — revise au besoin.
|
||
|
||
Les prompts textuels (ontology_map) doivent être précis et adaptés à ce que tu veux détecter (feuilles, fleurs, etc.).
|
||
|
||
Un GPU rend l’entraînement YOLOv8 bien plus rapide.
|
||
|
||
Si tu veux, je peux générer une version complète du data.yaml prête à l’emploi ou adapter ce pipeline à des situations spécifiques (ex : dataset grand public, interface graphique simple, intégration mobile). Dis-moi juste le cas d’usage que tu vises. |