Classification des iris à l'aide de SVM

Introduction

Dans ce projet, vous allez apprendre à classifier l'ensemble de données iris à l'aide d'un modèle de classifieur à vecteurs de support (SVC). L'ensemble de données iris est un ensemble de données d'apprentissage automatique classique qui contient des informations sur différentes espèces d'iris, y compris leur longueur de sépale, leur largeur de sépale, leur longueur de pétale et leur largeur de pétale.

🎯 Tâches

Dans ce projet, vous allez apprendre :

• Comment importer les bibliothèques requises et charger l'ensemble de données iris
• Comment diviser l'ensemble de données en ensembles d'entraînement et de test
• Comment créer et entraîner un modèle de classifieur à vecteurs de support
• Comment effectuer des prédictions à l'aide du modèle entraîné
• Comment évaluer les performances du modèle à l'aide du score d'exactitude et du rapport de classification

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

• Utiliser la bibliothèque scikit-learn pour travailler avec l'ensemble de données iris
• Diviser un ensemble de données en ensembles d'entraînement et de test
• Créer et entraîner un modèle de classifieur à vecteurs de support
• Effectuer des prédictions à l'aide d'un modèle entraîné
• Évaluer les performances d'un modèle à l'aide du score d'exactitude et du rapport de classification

Importer les bibliothèques requises et charger l'ensemble de données

Dans cette étape, vous allez apprendre à importer les bibliothèques requises et à charger l'ensemble de données iris. Suivez les étapes ci-dessous pour compléter cette étape :

Dans iris_classification_svm.py, importez les bibliothèques requises, y compris celles pour charger l'ensemble de données, diviser les données, créer le modèle SVM et évaluer ses performances.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report

Chargez les données iris à partir de sklearn.datasets et divisez l'ensemble de données en ensembles d'entraînement et de test. L'ensemble de données est divisé avec un ratio 80-20 pour l'entraînement et le test, avec une graine aléatoire de 42 pour la reproductibilité.

## Continuez dans le même fichier
def load_and_split_data() -> tuple:
    """
    Retourne :
        tuple : [X_train, X_test, y_train, y_test]
    """
    iris = load_iris()
    X, y = iris.data, iris.target
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    return X_train, X_test, y_train, y_test

Ce code charge l'ensemble de données Iris et le divise en ensembles d'entraînement et de test à des fins d'apprentissage automatique. Voici une description de chaque partie :

1. Importation des bibliothèques nécessaires :
   • sklearn.datasets est utilisé pour charger des ensembles de données, y compris l'ensemble de données Iris.
   • sklearn.model_selection fournit des utilitaires pour diviser des ensembles de données en ensembles d'entraînement et de test.
   • sklearn.svm contient des classes pour les Machines à Vecteurs de Support (SVM), un type d'algorithme d'apprentissage automatique.
   • sklearn.metrics inclut des outils pour évaluer les performances des modèles, tels que l'exactitude et les rapports de classification.
2. Définition de la fonction : Une fonction nommée load_and_split_data est définie. Cette fonction effectue les tâches suivantes :
   • Charge l'ensemble de données Iris : load_iris() est une fonction fournie par sklearn.datasets qui charge l'ensemble de données des fleurs Iris, qui est un ensemble de données populaire pour les tâches de classification. Il contient des mesures de 150 fleurs Iris de trois espèces différentes.
   • Séparation des données : L'ensemble de données est séparé en caractéristiques (X) et étiquettes cibles (y). Dans ce cas, X serait les mesures en 4 dimensions des fleurs Iris, et y serait les étiquettes d'espèce correspondantes (0, 1 ou 2).
   • Division des données : train_test_split de sklearn.model_selection est utilisé pour diviser les données en sous-ensembles d'entraînement et de test. Le paramètre test_size=0.2 signifie que 20 % des données seront utilisées pour le test, tandis que les 80 % restantes seront utilisées pour l'entraînement. random_state=42 assure la reproductibilité de la division ; en utilisant la même graine (42 ici), la même division sera obtenue chaque fois que le code est exécuté.
   • Valeurs de retour : La fonction renvoie un tuple contenant X_train, X_test, y_train et y_test, qui sont les ensembles de caractéristiques et de cibles pour les données d'entraînement et de test.

Créer et entraîner le modèle SVM

Dans cette étape, vous allez apprendre à créer un modèle de classifieur à vecteurs de support et à l'entraîner sur les données d'entraînement.

## Continuez dans le même fichier
def create_and_train_SVM(X_train: list, y_train: list) -> SVC:
    """
    Args:
        X_train: [caractéristiques pour l'entraînement]
        y_train: [étiquettes pour l'entraînement]

    Returns:
        SVC: [Modèle de classifieur à vecteurs de support entraîné]
    """
    svm = SVC()
    svm.fit(X_train, y_train)
    return svm

Cette fonction, create_and_train_SVM, est conçue pour instancier un modèle de classifieur à vecteurs de support (SVM) à l'aide de la classe sklearn.svm.SVC puis l'entraîner sur les données d'entraînement fournies. Voici une explication détaillée :

• Signature de la fonction : La fonction prend deux arguments :
  • X_train : Un objet de type liste ou semblable à un tableau contenant les caractéristiques (variables d'entrée) pour l'ensemble de données d'entraînement.
  • y_train : Un objet de type liste ou semblable à un tableau contenant les étiquettes correspondantes (variables de sortie) pour l'ensemble de données d'entraînement.
• Instanciation d'un modèle SVM : À l'intérieur de la fonction, SVC() est appelée sans aucun paramètre. Cela crée un modèle de classifieur à vecteurs de support par défaut. La classe SVC dans scikit-learn offre divers paramètres pour personnaliser le modèle, tels que le type de noyau, la régularisation, etc., mais dans cet exemple de base, des valeurs par défaut sont utilisées.
• Entraînement du modèle : La méthode fit de l'objet svm est appelée avec X_train et y_train. C'est là que l'entraînement réel se produit - le modèle apprend les patrons à partir des caractéristiques (X_train) associées à leurs étiquettes de classe respectives (y_train).
• Retour du modèle entraîné : Après l'entraînement, la fonction renvoie le modèle SVC entraîné. Ce modèle peut ensuite être utilisé pour effectuer des prédictions sur de nouvelles données non vues ou pour évaluer ses performances à l'aide d'un ensemble de données de test.

Effectuer des prédictions

Dans cette étape, vous allez apprendre à effectuer des prédictions à l'aide du modèle SVM entraîné.

## Continuez dans le même fichier
def make_predictions(model: SVC, X_test: list) -> list:
    """
    Args:
        model: [Modèle de classifieur à vecteurs de support entraîné]
        X_test: [caractéristiques pour le test]

    Returns:
        list: [Prédictions]
    """
    predictions = model.predict(X_test)
    return predictions

La fonction make_predictions prend en entrée un modèle SVM entraîné et un ensemble de caractéristiques de test, et elle renvoie une liste d'étiquettes prédites pour les données de test. Voici un détail :

• Arguments de la fonction :
  • model : Il s'agit d'une instance de la classe SVC (classifieur à vecteurs de support) qui a déjà été entraînée sur un ensemble de données. On suppose que le modèle sait classifier de nouvelles instances en se basant sur les modèles qu'il a appris pendant la phase d'entraînement.
  • X_test : Un objet de type liste ou semblable à un tableau contenant les caractéristiques (variables d'entrée) pour l'ensemble de données de test. Ce sont les exemples non vus pour lesquels le modèle prédira les étiquettes.
• Effectuer des prédictions : À l'intérieur de la fonction, la méthode predict du model est appelée avec X_test comme argument. La méthode predict applique le modèle appris à chaque instance du jeu de test pour estimer leurs étiquettes de classe. Elle ne nécessite pas les vraies étiquettes (y_test), seulement les caractéristiques d'entrée.
• Retourner les prédictions : La fonction renvoie ensuite ces étiquettes estimées sous forme d'une liste. Chaque élément de la liste renvoyée correspond à l'étiquette de classe prédite de l'instance respective dans l'ensemble de données X_test.

Évaluer le modèle

Évaluez le modèle en calculant le score d'exactitude et en affichant le rapport de classification.

## Continuez dans le même fichier
if __name__ == "__main__":
    ## Chargez et divisez les données
    X_train, X_test, y_train, y_test = load_and_split_data()

    ## Créez et entraînez le modèle SVM
    svm_model = create_and_train_SVM(X_train, y_train)

    ## Effectuez des prédictions
    predictions = make_predictions(svm_model, X_test)

    ## Évaluez le modèle
    accuracy = accuracy_score(y_test, predictions)
    print(f"Exactitude : {accuracy:.2f}")

    ## Affichez le rapport de classification
    print("Rapport de classification :")
    print(classification_report(y_test, predictions))

Maintenant, exécutez le script à partir du terminal :

python iris_classification_svm.py

La sortie devrait être :

Exactitude : 1.00
Rapport de classification :
              précision    rappel  f1-score   support

           0       1.00      1.00      1.00        10
           1       1.00      1.00      1.00         9
           2       1.00      1.00      1.00        11

    exactitude                           1.00        30
   macro avg       1.00      1.00      1.00        30
weighted avg       1.00      1.00      1.00        30

En suivant ces étapes, vous avez terminé le projet de classification de l'ensemble de données iris à l'aide d'un modèle de classifieur à vecteurs de support (SVC).

Résumé

Félicitations ! Vous avez terminé ce projet. Vous pouvez pratiquer plus de laboratoires dans LabEx pour améliorer vos compétences.