Meisterklasse Iris-Klassifizierung mit SVM

Einführung

In diesem Projekt lernst du, wie du den Iris-Datensatz mit einem Support Vector Classifier (SVC)-Modell klassifizierst. Der Iris-Datensatz ist ein klassisches Machine-Learning-Datenset, das Informationen über verschiedene Iris-Arten enthält, einschließlich ihrer Kelchblätchenlänge, Kelchblätchenbreite, Blütenblattlänge und Blütenblattbreite.

🎯 Aufgaben

In diesem Projekt wirst du lernen:

Wie du die erforderlichen Bibliotheken importierst und den Iris-Datensatz lädst
Wie du den Datensatz in Trainings- und Testsets aufteilst
Wie du ein Support Vector Classifier-Modell erstellst und trainst
Wie du Vorhersagen mit dem trainierten Modell machst
Wie du die Leistung des Modells mit der Genauigkeit und dem Klassifizierungsbericht bewertest

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

Die scikit-learn-Bibliothek zum Umgang mit dem Iris-Datensatz zu verwenden
Einen Datensatz in Trainings- und Testsets aufzuteilen
Ein Support Vector Classifier-Modell zu erstellen und zu trainieren
Vorhersagen mit einem trainierten Modell zu machen
Die Leistung eines Modells mit der Genauigkeit und dem Klassifizierungsbericht zu bewerten

Importiere erforderliche Bibliotheken und lade Datensatz

In diesem Schritt lernst du, wie du die erforderlichen Bibliotheken importierst und den Iris-Datensatz lädst. Folge den Schritten unten, um diesen Schritt abzuschließen:

In iris_classification_svm.py importiere die erforderlichen Bibliotheken, einschließlich der für das Laden des Datensatzes, das Teilen der Daten, das Erstellen des SVM-Modells und die Bewertung seiner Leistung.

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

Lade die Iris-Daten aus sklearn.datasets und teile den Datensatz in Trainings- und Testsets auf. Der Datensatz wird mit einem 80-20-Verhältnis für das Training und die Tests aufgeteilt, mit einem Zufallszahlengenerator von 42 für die Reproduzierbarkeit.

## Weiter in derselben Datei
def load_and_split_data() -> tuple:
    """
    Returns:
        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

Dieser Code lädt den Iris-Datensatz und teilt ihn in Trainings- und Testsets für Machine-Learning-Zwecke auf. Hier ist eine Aufteilung jedes Teils:

Importieren der erforderlichen Bibliotheken:
- sklearn.datasets wird verwendet, um Datensets zu laden, einschließlich des Iris-Datensatzes.
- sklearn.model_selection bietet Hilfsmittel zum Teilen von Datensets in Trainings- und Testsets.
- sklearn.svm enthält Klassen für Support Vector Machines (SVM), einen Typ von Machine-Learning-Algorithmus.
- sklearn.metrics umfasst Werkzeuge zur Bewertung der Leistung von Modellen, wie Genauigkeit und Klassifizierungsberichte.
Funktionsdefinition: Eine Funktion namens load_and_split_data wird definiert. Diese Funktion führt die folgenden Aufgaben aus:
- Laden des Iris-Datensatzes: load_iris() ist eine Funktion von sklearn.datasets, die den Iris-Blumen-Datensatz lädt, ein beliebter Datensatz für Klassifizierungsaufgaben. Er enthält Messungen von 150 Iris-Blumen aus drei verschiedenen Arten.
- Datenauftrennung: Der Datensatz wird in Merkmale (X) und Zielbezeichnungen (y) getrennt. In diesem Fall wäre X die 4-dimensionale Messung der Iris-Blumen und y die entsprechenden Artbezeichnungen (0, 1 oder 2).
- Teilen der Daten: train_test_split aus sklearn.model_selection wird verwendet, um die Daten in Trainings- und Testuntermengen aufzuteilen. Der Parameter test_size=0.2 bedeutet, dass 20% der Daten für das Testen verwendet werden, während die verbleibenden 80% für das Training verwendet werden. random_state=42 gewährleistet die Reproduzierbarkeit der Aufteilung; das Verwenden derselben Zufallszahl (hier 42) liefert jede Zeit die gleiche Aufteilung, wenn der Code ausgeführt wird.
- Rückgabewerte: Die Funktion gibt ein Tupel zurück, das X_train, X_test, y_train und y_test enthält, die die Merkmals- und Zielsets für sowohl die Trainings- als auch die Testdaten sind.

Erstelle und trainiere das SVM-Modell

In diesem Schritt lernst du, wie du ein Support Vector Classifier-Modell erstellst und es auf den Trainingsdaten trainiert.

## Weiter in derselben Datei
def create_and_train_SVM(X_train: list, y_train: list) -> SVC:
    """
    Args:
        X_train: [features for training]
        y_train: [labels for training]

    Returns:
        SVC: [Trained Support Vector Classifier model]
    """
    svm = SVC()
    svm.fit(X_train, y_train)
    return svm

Diese Funktion, create_and_train_SVM, ist dazu gedacht, ein Support Vector Classifier (SVM)-Modell mithilfe der Klasse sklearn.svm.SVC zu instanziieren und dann auf den bereitgestellten Trainingsdaten zu trainieren. Hier ist eine detaillierte Erklärung:

Funktionssignatur: Die Funktion nimmt zwei Argumente entgegen:
- X_train: Ein Listen- oder arrayähnliches Objekt, das die Merkmale (Eingabevariablen) für den Trainingsdatensatz enthält.
- y_train: Ein Listen- oder arrayähnliches Objekt, das die entsprechenden Labels (Ausgabevariablen) für den Trainingsdatensatz enthält.
Instanzieren eines SVM-Modells: Innerhalb der Funktion wird SVC() ohne Parameter aufgerufen. Dies erstellt ein Standard-Support Vector Classifier-Modell. Die SVC-Klasse in scikit-learn bietet verschiedene Parameter, um das Modell anzupassen, wie z. B. den Kerntyp, die Regularisierung usw., aber in diesem einfachen Beispiel werden Standardwerte verwendet.
Trainieren des Modells: Die fit-Methode des svm-Objekts wird mit X_train und y_train aufgerufen. Hier findet das tatsächliche Training statt – das Modell lernt Muster aus den Merkmalen (X_train), die mit ihren jeweiligen Klassenlabels (y_train) assoziiert sind.
Rückgabe des trainierten Modells: Nach dem Training gibt die Funktion das trainierte SVC-Modell zurück. Dieses Modell kann dann verwendet werden, um Vorhersagen für neue, bisher nicht gesehenen Daten zu machen oder um seine Leistung mit einem Testdatensatz zu bewerten.

Mache Vorhersagen

In diesem Schritt lernst du, wie du Vorhersagen mit dem trainierten SVM-Modell machst.

## Weiter in derselben Datei
def make_predictions(model: SVC, X_test: list) -> list:
    """
    Args:
        model: [Trained Support Vector Classifier model]
        X_test: [features for testing]

    Returns:
        list: [Predictions]
    """
    predictions = model.predict(X_test)
    return predictions

Die Funktion make_predictions nimmt ein trainiertes SVM-Modell und einen Satz von Testmerkmalen als Eingaben entgegen und gibt eine Liste von vorhergesagten Labels für die Testdaten zurück. Hier ist eine Aufteilung:

Funktionsargumente:
- model: Dies ist eine Instanz der SVC-Klasse (Support Vector Classifier), die bereits auf einem Datensatz trainiert wurde. Es wird angenommen, dass das Modell weiß, wie es neue Instanzen basierend auf den Mustern klassifiziert, die es während der Trainingsphase gelernt hat.
- X_test: Ein Listen- oder arrayähnliches Objekt, das die Merkmale (Eingabevariablen) für den Testdatensatz enthält. Dies sind die bisher nicht gesehenen Beispiele, für die das Modell Labels vorherzusagen hat.
Treffen von Vorhersagen: Innerhalb der Funktion wird die predict-Methode des model mit X_test als Argument aufgerufen. Die predict-Methode wendet das gelerntes Modell auf jede Instanz im Testset an, um ihre Klasslabels zu schätzen. Sie erfordert nicht die wahren Labels (y_test), nur die Eingabemerkmale.
Rückgabe von Vorhersagen: Die Funktion gibt dann diese geschätzten Labels als Liste zurück. Jedes Element in der zurückgegebenen Liste entspricht dem vorhergesagten Klasslabel der jeweiligen Instanz im X_test-Datensatz.

计算模型评估

Bewerte das Modell, indem du die Genauigkeit berechnest und den Klassifizierungsbericht anzeigst.

## Weiter in derselben Datei
if __name__ == "__main__":
    ## Lade und teile die Daten auf
    X_train, X_test, y_train, y_test = load_and_split_data()

    ## Erstelle und trainiere das SVM-Modell
    svm_model = create_and_train_SVM(X_train, y_train)

    ## Mache Vorhersagen
    predictions = make_predictions(svm_model, X_test)

    ## Bewerte das Modell
    accuracy = accuracy_score(y_test, predictions)
    print(f"Genauigkeit: {accuracy:.2f}")

    ## Zeige den Klassifizierungsbericht an
    print("Klassifizierungsbericht:")
    print(classification_report(y_test, predictions))

Führe nun das Skript aus der Kommandozeile aus:

python iris_classification_svm.py

Die Ausgabe sollte wie folgt sein:

Genauigkeit: 1.00
Klassifizierungsbericht:
              Präzision    Recall  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

    Genauigkeit                           1.00        30
   macro avg       1.00      1.00      1.00        30
weighted avg       1.00      1.00      1.00        30

Indem du diese Schritte folgst, hast du das Projekt abgeschlossen, um den Iris-Datensatz mit einem Support Vector Classifier (SVC)-Modell zu klassifizieren.

Zusammenfassung

Herzlichen Glückwunsch! Du hast dieses Projekt abgeschlossen. Du kannst in LabEx weitere Übungen absolvieren, um deine Fähigkeiten zu verbessern.

Klassifizierung von Iris mit SVM