Traveaux Pratiques

TP Classification de Fruits - Machine Learning

TP Pratique : Classification de Fruits avec scikit-learn

Apprenez à construire un classifieur de fruits à partir de leurs caractéristiques physiques

📋 Objectifs du TP

Comprendre le processus complet d'un projet de machine learning
Manipuler des données réelles de caractéristiques de fruits
Implémenter plusieurs algorithmes de classification
Évaluer et comparer les performances des modèles
Visualiser les résultats et les frontières de décision

🍎 Dataset Fruits

Nous utiliserons un jeu de données contenant des mesures de fruits avec leurs étiquettes de classe.

Description des caractéristiques : masse, largeur, hauteur, couleur (valeurs RGB moyennes)

Aperçu des données

Fruit Masse (g) Largeur (cm) Hauteur (cm) Couleur (R) Couleur (G) Couleur (B)
Pomme 192 8.4 7.3 215 30 35
Orange 180 7.3 7.1 255 165 0
Citron 120 5.8 6.2 255 255 0
Banane 150 3.5 8.2 255 225 0
Visualisation des données fruits
Distribution des fruits dans l'espace des caractéristiques

🧑‍💻 Partie Pratique

1. Préparation de l'environnement

Installez les bibliothèques nécessaires :

pip install numpy pandas matplotlib scikit-learn

2. Chargement des données

import pandas as pd from sklearn.model_selection import train_test_split # Charger le dataset url = "https://raw.githubusercontent.com/selva86/datasets/master/fruits.csv" data = pd.read_csv(url) # Afficher les premières lignes print(data.head()) # Séparation features/cible X = data.drop('fruit_label', axis=1) y = data['fruit_label'] # Séparation entraînement/test X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

3. Exploration des données

import matplotlib.pyplot as plt import seaborn as sns # Statistiques descriptives print(data.describe()) # Visualisation des distributions sns.pairplot(data, hue='fruit_name', vars=['mass', 'width', 'height']) plt.show() # Matrice de corrélation plt.figure(figsize=(10, 8)) sns.heatmap(data.corr(), annot=True, cmap='coolwarm') plt.title('Matrice de Corrélation') plt.show()
À noter : L'exploration des données est cruciale pour comprendre les relations entre variables et détecter d'éventuels problèmes.

4. Prétraitement des données

from sklearn.preprocessing import StandardScaler from sklearn.compose import ColumnTransformer # Séparation des caractéristiques numériques et catégorielles numeric_features = ['mass', 'width', 'height', 'color_score'] categorical_features = [] # Création du préprocesseur preprocessor = ColumnTransformer( transformers=[ ('num', StandardScaler(), numeric_features), ('cat', OneHotEncoder(), categorical_features) ]) # Application aux données X_train = preprocessor.fit_transform(X_train) X_test = preprocessor.transform(X_test)

🤖 Implémentation des Modèles

K-Nearest Neighbors (KNN)

from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score # Initialisation du modèle knn = KNeighborsClassifier(n_neighbors=3) # Entraînement knn.fit(X_train, y_train) # Prédiction et évaluation y_pred = knn.predict(X_test) print(f"Accuracy KNN: {accuracy_score(y_test, y_pred):.2f}")

Arbre de Décision

from sklearn.tree import DecisionTreeClassifier from sklearn import tree # Initialisation et entraînement dt = DecisionTreeClassifier(max_depth=3, random_state=42) dt.fit(X_train, y_train) # Visualisation de l'arbre plt.figure(figsize=(15, 10)) tree.plot_tree(dt, feature_names=X.columns, class_names=data['fruit_name'].unique(), filled=True) plt.show()

SVM

from sklearn.svm import SVC # Initialisation et entraînement svm = SVC(kernel='rbf', C=1.0, gamma='scale') svm.fit(X_train, y_train) # Évaluation y_pred = svm.predict(X_test) print(f"Accuracy SVM: {accuracy_score(y_test, y_pred):.2f}")

Forêt Aléatoire

from sklearn.ensemble import RandomForestClassifier # Initialisation et entraînement rf = RandomForestClassifier(n_estimators=100, random_state=42) rf.fit(X_train, y_train) # Importance des caractéristiques importances = rf.feature_importances_ plt.barh(X.columns, importances) plt.title("Importance des Caractéristiques") plt.show()

📊 Évaluation des Modèles

from sklearn.metrics import classification_report, confusion_matrix import seaborn as sns # Fonction pour évaluer un modèle def evaluate_model(model, X_test, y_test): y_pred = model.predict(X_test) # Rapport de classification print(classification_report(y_test, y_pred)) # Matrice de confusion cm = confusion_matrix(y_test, y_pred) plt.figure(figsize=(8, 6)) sns.heatmap(cm, annot=True, fmt='d', xticklabels=data['fruit_name'].unique(), yticklabels=data['fruit_name'].unique()) plt.title('Matrice de Confusion') plt.ylabel('Vérité terrain') plt.xlabel('Prédictions') plt.show() # Évaluation du KNN print("Évaluation KNN:") evaluate_model(knn, X_test, y_test)
Bonnes pratiques : Toujours comparer plusieurs métriques (précision, rappel, F1-score) et ne pas se contenter de l'accuracy.

🔍 Amélioration du Modèle

1. Validation Croisée

from sklearn.model_selection import cross_val_score # Validation croisée pour KNN scores = cross_val_score(knn, preprocessor.fit_transform(X), y, cv=5) print(f"Scores de validation croisée: {scores}") print(f"Moyenne: {scores.mean():.2f} (±{scores.std():.2f})")

2. Optimisation des Hyperparamètres

from sklearn.model_selection import GridSearchCV # Grille de paramètres pour KNN param_grid = { 'n_neighbors': range(1, 15), 'weights': ['uniform', 'distance'], 'metric': ['euclidean', 'manhattan'] } # Recherche par grille grid_search = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5) grid_search.fit(X_train, y_train) # Meilleurs paramètres print(f"Meilleurs paramètres: {grid_search.best_params_}") print(f"Meilleur score: {grid_search.best_score_:.2f}")

3. Visualisation des Frontières de Décision

from sklearn.decomposition import PCA import numpy as np # Réduction en 2D avec PCA pca = PCA(n_components=2) X_pca = pca.fit_transform(X_train) # Création d'une grille pour la visualisation x_min, x_max = X_pca[:, 0].min() - 1, X_pca[:, 0].max() + 1 y_min, y_max = X_pca[:, 1].min() - 1, X_pca[:, 1].max() + 1 xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), np.arange(y_min, y_max, 0.02)) # Entraînement sur les composantes principales knn.fit(X_pca, y_train) # Prédiction sur la grille Z = knn.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) # Visualisation plt.contourf(xx, yy, Z, alpha=0.4) plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_train, s=20, edgecolor='k') plt.title("Frontières de Décision (KNN)") plt.xlabel("Première Composante Principale") plt.ylabel("Deuxième Composante Principale") plt.show()

🎯 Conclusion et Aller Plus Loin

Ce que nous avons appris

  • Chargement et exploration de données
  • Prétraitement des caractéristiques
  • Implémentation de plusieurs classifieurs
  • Évaluation rigoureuse des performances
  • Optimisation des hyperparamètres

Pour aller plus loin

  • Essayer d'autres algorithmes (XGBoost, MLP)
  • Ajouter des caractéristiques supplémentaires
  • Traiter un déséquilibre de classes
  • Déployer le modèle avec Flask/FastAPI
Ressources : Documentation scikit-learn • Datasets Kaggle • Google Colab

Commentaires

Enregistrer un commentaire