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.