Classification de Feuilles (Lisse vs Dentée)

Projet de classification d'images utilisant PyTorch pour distinguer les feuilles lisses des feuilles dentées.

Résultats

• Accuracy: ~88%
• Precision: ~92%
• Recall: ~83%
• F1-Score: ~87%
• AUC-ROC: ~95%

Objectif

Ce projet implémente un CNN (Convolutional Neural Network) pour classifier automatiquement des images de feuilles en deux catégories:

• 🌿 Feuilles Lisses : Bords réguliers et arrondis
• 🍁 Feuilles Dentées : Bords dentelés et irréguliers

Structure du Projet

Feuilles-Segementation/
├── data/
│   └── feuilles_plantes/          # Dataset (dente/ et lisse/)
├── src/
│   ├── __init__.py
│   ├── data.py                    # Gestion des données
│   ├── model.py                   # Architecture CNN
│   ├── train.py                   # Entraînement
│   ├── evaluate.py                # Évaluation et métriques
│   └── predict.py                 # Prédictions
├── scripts/
│   ├── train_model.py             # Script d'entraînement
│   └── evaluate_model.py          # Script d'évaluation
├── web_app/
│   └── app.py                     # Application Streamlit
├── models/
│   └── best_model.pth             # Modèle entraîné (généré)
├── results/
│   ├── metrics.json               # Métriques (généré)
│   ├── confusion_matrix.png       # Visualisations (générées)
│   ├── roc_curve.png
│   └── precision_recall.png
├── notebooks/
│   └── TP_Etudiants_Classification_Feuille.ipynb
├── requirements.txt
└── README.md

⚠️ IMPORTANT - Téléchargement des Données

Les données ne sont PAS incluses dans ce repository !

📥 Télécharger le Dataset

Le dataset est hébergé sur Google Drive (trop volumineux pour GitHub)

🔗 CLIQUEZ ICI POUR TÉLÉCHARGER LES DONNÉES

📂 Installation du Dataset

Après téléchargement, suivez ces étapes :

1. Téléchargez le dossier complet depuis Google Drive
2. Extrayez le fichier (si compressé)
3. Placez le dossier feuilles_plantes à la racine du projet

Structure attendue :

Feuilles-Segementation/
├── feuilles_plantes/          ⬅️ PLACEZ LE DOSSIER ICI
│   └── feuilles_plantes/
│       ├── dente/            (images de feuilles dentées)
│       └── lisse/            (images de feuilles lisses)
├── src/
├── scripts/
├── web_app/
└── README.md

✅ Vérification

Pour vérifier que le dataset est correctement installé :

# Le dossier doit exister
ls feuilles_plantes/feuilles_plantes/

# Vous devriez voir : dente/ et lisse/

Informations sur le Dataset

• Classes : 2 (dentée, lisse)
• Nombre d'images : ~6,900 images
• Format : Images RGB (JPG/PNG)
• Taille après extraction : ~500 MB
• Split automatique : 70% train, 15% val, 15% test (stratifié)

⚠️ Sans ces données, vous ne pourrez pas entraîner le modèle !

🚀 Installation

Prérequis

AVANT DE COMMENCER : Assurez-vous d'avoir téléchargé les données (voir section ci-dessus) !

• Python 3.8 ou supérieur
• pip
• Dataset depuis Google Drive (voir section précédente)

Installation des dépendances

pip install -r requirements.txt

Dépendances principales

• torch>=2.0.0 - Framework de deep learning
• torchvision>=0.15.0 - Vision computer avec PyTorch
• numpy>=1.24.0 - Calcul numérique
• matplotlib>=3.7.0 - Visualisations
• scikit-learn>=1.3.0 - Métriques de performance
• streamlit>=1.28.0 - Application web
• Pillow>=10.0.0 - Traitement d'images

Utilisation

1. Entraînement du Modèle

Pour entraîner le modèle depuis zéro:

python scripts/train_model.py

Paramètres par défaut:

• Époques: 10
• Learning rate: 1e-3
• Batch size (train): 32
• Batch size (eval): 64
• Split: 70% train, 15% val, 15% test

Le modèle entraîné sera sauvegardé dans models/best_model.pth.

2. Évaluation du Modèle

Pour évaluer le modèle sur l'ensemble de test:

python scripts/evaluate_model.py

Génère:

• Métriques complètes (JSON)
• Matrice de confusion
• Courbe ROC
• Courbe Precision-Recall

Les résultats sont sauvegardés dans le dossier results/.

3. Application Web

Pour lancer l'interface web interactive:

streamlit run web_app/app.py

L'application permet de:

• Charger une image de feuille
• Obtenir une prédiction en temps réel
• Visualiser les probabilités par classe
• Afficher la confiance de la prédiction

4. Prédiction Programmatique

Exemple de code pour faire une prédiction:

from src.model import load_model
from src.predict import predict_single_image

# Charger le modèle
model = load_model("models/best_model.pth")
classes = ['dente', 'lisse']

# Prédire
predicted_class, confidence, all_probas = predict_single_image(
    model, "path/to/image.jpg", classes
)

print(f"Classe: {predicted_class}")
print(f"Confiance: {confidence:.2%}")
print(f"Probabilités: {all_probas}")

Architecture du Modèle

CNN

Architecture CNN compacte composée de:

Total de paramètres: ~2.1M

Dataset

• Source: Images de feuilles botaniques
• Classes: 2 (dentée, lisse)
• Format: Images RGB de tailles variables (redimensionnées à 128×128)
• Split: 70% train, 15% validation, 15% test (stratifié)

Prétraitement

Entraînement:

• Redimensionnement: 128×128
• Augmentation: Flip horizontal aléatoire (p=0.5)
• Normalisation ImageNet

Validation/Test:

• Redimensionnement: 128×128
• Normalisation ImageNet

🐛 Problèmes Connus

Si vous rencontrez des problèmes:

1. Vérifiez que toutes les dépendances sont installées
2. Assurez-vous que le dataset est dans le bon dossier
3. Vérifiez les chemins dans les scripts

Pour signaler un bug, créez une issue sur GitHub mohamed.

---