Scikit-learn Datenvorverarbeitung

Einführung

Willkommen zum scikit-learn Data Preprocessing Lab. Im maschinellen Lernen wirkt sich die Qualität Ihrer Daten direkt auf die Leistung Ihres Modells aus. Rohdaten sind oft unordentlich, inkonsistent und nicht im optimalen Format für Algorithmen. Datenvorverarbeitung ist ein entscheidender Schritt, der die Bereinigung und Transformation von Daten beinhaltet, um sie für ein maschinelles Lernmodell geeignet zu machen.

In diesem Lab lernen Sie, wie Sie zwei grundlegende Vorverarbeitungsaufgaben mit der scikit-learn-Bibliothek durchführen:

• Feature Scaling: Standardisierung des Bereichs von unabhängigen Variablen oder Merkmalen von Daten.
• Label Encoding: Konvertierung kategorialer Labels in ein numerisches Format.

Wir werden den berühmten Iris-Datensatz verwenden, der bequem in scikit-learn enthalten ist, um diese Techniken zu üben. Am Ende dieses Labs werden Sie ein solides Verständnis dafür haben, wie Sie Ihre Daten für maschinelle Lern-Pipelines vorbereiten.

Daten in Features und Zielvariable aufteilen mit X = iris.data, y = iris.target

In diesem Schritt laden wir zunächst den Iris-Datensatz und trennen ihn in Features und die Zielvariable. Im maschinellen Lernen ist X die übliche Notation für die Features (die Eingabevariablen) und y die Notation für das Ziel (die Ausgabevariable, die Sie vorhersagen möchten).

Die scikit-learn-Bibliothek stellt den Iris-Datensatz über ihr datasets-Modul zur Verfügung. Das geladene Dataset-Objekt verhält sich wie ein Dictionary.

Struktur des Iris-Datensatzes:

• iris.data: Feature-Matrix (150 Samples × 4 Features)
• iris.target: Ziel-Labels (150 Samples)
• iris.feature_names: Namen der 4 Features
• iris.target_names: Namen der 3 Blumenarten

Warum X und y trennen?

• X: Eingabe-Features (wovon das Modell lernt)
• y: Ziel-Labels (was das Modell vorhersagt)
• Dies ist die Standardkonvention im maschinellen Lernen

Öffnen Sie zunächst die Datei preprocess.py im Verzeichnis ~/project über den Dateiexplorer auf der linken Seite. Wir werden unseren Code zu dieser Datei hinzufügen.

Fügen Sie die folgenden Zeilen unter dem Kommentar ## --- Step 1: Split data --- hinzu, um die Features und das Ziel entsprechend X und y zuzuweisen. Wir werden auch ihre Formen ausgeben, um dies zu überprüfen.

## --- Step 1: Split data ---
X = iris.data
y = iris.target

print("Shape of features (X):", X.shape)
print("Shape of target (y):", y.shape)

Speichern Sie nun die Datei und führen Sie sie im Terminal aus, um die Ausgabe zu sehen.

python3 preprocess.py

Sie sollten die folgende Ausgabe sehen, die anzeigt, dass wir 150 Samples und 4 Features haben, zusammen mit 150 entsprechenden Ziel-Labels.

Shape of features (X): (150, 4)
Shape of target (y): (150,)

Features mit StandardScaler aus sklearn.preprocessing skalieren

In diesem Schritt bereiten wir die Skalierung unserer Features vor. Feature-Skalierung ist eine gängige Anforderung für viele Algorithmen des maschinellen Lernens, da diese empfindlich auf die Skalierung der Eingabe-Features reagieren können. StandardScaler ist eine beliebte Technik, die Features standardisiert, indem sie den Mittelwert entfernt und sie auf eine Einheitsvarianz skaliert.

Wie StandardScaler funktioniert:

• Formel: z = (x - u) / s, wobei u der Mittelwert der Trainingssamples und s die Standardabweichung ist
• Effekt: Transformiert Daten so, dass sie einen Mittelwert von 0 und eine Standardabweichung von 1 haben
• Vorteile: Verhindert, dass Features mit größeren Skalen den Lernprozess dominieren

Wichtige Parameter von StandardScaler:

• with_mean=True (Standard): Zentriert die Daten durch Entfernen des Mittelwerts
• with_std=True (Standard): Skaliert die Daten durch Division durch die Standardabweichung

Wir werden den StandardScaler aus sklearn.preprocessing verwenden. Der erste Teil des Prozesses ist die Erstellung einer Instanz des Scalers.

Fügen Sie in Ihrer Datei preprocess.py unter dem Kommentar ## --- Step 2: Initialize the scaler --- den folgenden Code hinzu, um eine Instanz von StandardScaler zu erstellen.

## --- Step 2: Initialize the scaler ---
scaler = StandardScaler()

print("Scaler object created:", scaler)

Speichern Sie die Datei und führen Sie sie erneut aus.

python3 preprocess.py

Die Ausgabe enthält nun eine Zeile, die bestätigt, dass das StandardScaler-Objekt erfolgreich erstellt wurde.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()

Scaler mit scaler.fit(X) anpassen

In diesem Schritt passen wir den StandardScaler an unsere Feature-Daten X an. Die fit()-Methode ist ein grundlegendes Konzept in scikit-learn.

Was fit() tut:

• Berechnet notwendige Statistiken (Mittelwert und Standardabweichung) aus den Trainingsdaten
• Speichert diese Parameter intern für die spätere Verwendung
• Wichtig: Lernt nur aus Daten, transformiert sie aber nicht

Warum fit() und transform() trennen?

• Nur auf Trainingsdaten anpassen (fit): Verhindert Datenlecks, indem Parameter nur aus dem Trainingsdatensatz gelernt werden
• Auf beliebige Daten anwenden (transform): Kann sowohl Trainings- als auch Testdaten mit denselben gelernten Parametern transformieren
• Konsistenz: Stellt sicher, dass dieselbe Transformation auf alle Daten angewendet wird

Best Practice in der Praxis:

• scaler.fit(X_train) - Parameter nur aus Trainingsdaten lernen
• X_train_scaled = scaler.transform(X_train) - Trainingsdaten transformieren
• X_test_scaled = scaler.transform(X_test) - Testdaten mit denselben Parametern transformieren

Fügen Sie Ihrer Datei preprocess.py unter dem Kommentar ## --- Step 3: Fit the scaler --- den folgenden Code hinzu. Wir werden auch das Attribut mean_ des Scalers ausgeben, um zu sehen, was er gelernt hat.

## --- Step 3: Fit the scaler ---
scaler.fit(X)

print("Scaler mean:", scaler.mean_)

Speichern Sie die Datei und führen Sie sie aus.

python3 preprocess.py

Die Ausgabe zeigt nun den Mittelwert für jedes der vier Features, den der Scaler aus den Daten berechnet hat.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]

Daten mit scaler.transform(X) transformieren

In diesem Schritt verwenden wir den angepassten Scaler, um unsere Daten zu transformieren. Die transform()-Methode wendet die Skalierungstransformation auf die Daten an, wobei der Mittelwert und die Standardabweichung verwendet werden, die während des fit()-Schritts berechnet wurden. Dies zentriert unsere Daten um einen Mittelwert von 0 mit einer Standardabweichung von 1.

Wir speichern die transformierten Daten in einer neuen Variablen, X_scaled, um die Originaldaten unverändert zu lassen.

Verständnis des Codes:

• X_scaled = scaler.transform(X): Wendet die gelernte Transformation auf unsere Daten an
• np.set_printoptions(precision=2, suppress=True): Formatiert die Ausgabe für bessere Lesbarkeit
  • precision=2: Zeigt 2 Dezimalstellen an
  • suppress=True: Verwendet wissenschaftliche Notation für sehr kleine/große Zahlen
• np.mean(X, axis=0): Berechnet den Mittelwert entlang der Achse 0 (Spalten)
  • axis=0: Berechnet den Mittelwert für jedes Feature (Spalte) über alle Samples hinweg
  • Ergebnis: Ein Mittelwert pro Feature

Fügen Sie Ihrer Datei preprocess.py unter dem Kommentar ## --- Step 4: Transform the data --- den folgenden Code hinzu. Wir geben den Mittelwert der Original- und der skalierten Daten aus, um den Effekt der Transformation zu beobachten.

## --- Step 4: Transform the data ---
X_scaled = scaler.transform(X)

## Use numpy to set precision for cleaner output
np.set_printoptions(precision=2, suppress=True)
print("Original data mean:", np.mean(X, axis=0))
print("Scaled data mean:", np.mean(X_scaled, axis=0))
print("Scaled data sample:\n", X_scaled[:5])

Speichern Sie die Datei und führen Sie sie aus.

python3 preprocess.py

Sie werden sehen, dass der Mittelwert der skalierten Daten effektiv Null ist und die Beispiel-Datenwerte transformiert wurden.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]
Original data mean: [5.84 3.06 3.76 1.2 ]
Scaled data mean: [-0. -0. -0. -0.]
Scaled data sample:
 [[-0.9   1.02 -1.34 -1.32]
 [-1.14 -0.13 -1.34 -1.32]
 [-1.39  0.33 -1.4  -1.32]
 [-1.51  0.1  -1.28 -1.32]
 [-1.02  1.25 -1.34 -1.32]]

Kategorisches Ziel mit LabelEncoder aus sklearn.preprocessing kodieren

In diesem Schritt werden wir unsere Zielvariable y vorverarbeiten. Die Zielvariable des Iris-Datensatzes ist kategorisch und wird durch die Zahlen 0, 1 und 2 dargestellt, die den drei verschiedenen Iris-Blumenarten entsprechen. Obwohl sie bereits numerisch sind, ist es eine gute Praxis zu verstehen, wie kategorische Labels kodiert werden, insbesondere wenn sie im Zeichenkettenformat vorliegen würden (z. B. 'setosa', 'versicolor').

LabelEncoder erklärt:

• Zweck: Konvertiert kategorische Labels (Zeichenketten oder gemischte Typen) in ganze Zahlen
• Funktionsweise: Weist jeder eindeutigen Kategorie eine eindeutige ganze Zahl zu
• Beispiel: ['cat', 'dog', 'cat'] → [0, 1, 0]

Warum LabelEncoder verwenden?

• Viele ML-Algorithmen erfordern numerische Eingaben
• Effiziente Speicherung und Berechnung
• Behält die kategorische Natur der Daten bei

Wichtige Methoden:

• fit(y): Lernt die Zuordnung von Kategorien zu ganzen Zahlen
• transform(y): Wendet die gelernte Zuordnung an
• fit_transform(y): Kombiniert beide Schritte in einem Aufruf
• inverse_transform(y_encoded): Konvertiert ganze Zahlen zurück in die ursprünglichen Kategorien

Wichtige Hinweise:

• Die Reihenfolge ist willkürlich (basiert auf dem ersten Auftreten oder der Sortierung)
• Nicht geeignet für ordinale Daten, bei denen die Reihenfolge wichtig ist (verwenden Sie stattdessen OrdinalEncoder)
• Für Features (nicht für Zielvariablen) sollten Sie OneHotEncoder für nominale Daten in Betracht ziehen

Fügen Sie Ihrer Datei preprocess.py unter dem Kommentar ## --- Step 5: Encode the target --- den folgenden Code hinzu. Wir erstellen eine Instanz von LabelEncoder und verwenden die Methode fit_transform(), die das Anpassen und Transformieren in einem einzigen Schritt kombiniert.

## --- Step 5: Encode the target ---
encoder = LabelEncoder()
y_encoded = encoder.fit_transform(y)

print("\nOriginal target sample:", y[:5])  ## Show first 5 original labels
print("Encoded target sample:", y_encoded[:5])  ## Show first 5 encoded labels
print("Unique encoded values:", np.unique(y_encoded))  ## Show all unique encoded values

Speichern Sie die Datei und führen Sie sie zum letzten Mal aus.

python3 preprocess.py

Die Ausgabe zeigt, dass die Zielvariable kodiert wurde. Da sie bereits im richtigen Integer-Format vorlag, ist das Ergebnis dasselbe, aber dies demonstriert den Prozess, den Sie für zeichenkettenbasierte Labels verwenden würden.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]
Original data mean: [5.84 3.06 3.76 1.2 ]
Scaled data mean: [-0. -0. -0. -0.]
Scaled data sample:
 [[-0.9   1.02 -1.34 -1.32]
 [-1.14 -0.13 -1.34 -1.32]
 [-1.39  0.33 -1.4  -1.32]
 [-1.51  0.1  -1.28 -1.32]
 [-1.02  1.25 -1.34 -1.32]]

Original target sample: [0 0 0 0 0]
Encoded target sample: [0 0 0 0 0]
Unique encoded values: [0 1 2]

Zusammenfassung

Herzlichen Glückwunsch zum Abschluss des Labs! Sie haben wichtige Datenvorverarbeitungsschritte mit scikit-learn erfolgreich durchgeführt.

In diesem Lab haben Sie gelernt, wie Sie:

• Einen Standarddatensatz aus scikit-learn laden.
• Die Daten in Features (X) und eine Zielvariable (y) aufteilen.
• Numerische Features mit StandardScaler skalieren, indem Sie ihn zuerst mit den Daten fitten, um die Parameter zu lernen, und dann die Daten transformieren.
• Kategorische Zielvariablen mit LabelEncoder in ein maschinenlesbares Integer-Format kodieren.

Diese Vorverarbeitungsschritte sind grundlegend für den Aufbau robuster und leistungsstarker Machine-Learning-Modelle. Sie sind nun besser gerüstet, um Ihre eigenen Datensätze für zukünftige Machine-Learning-Projekte vorzubereiten.