Machine Learning Academy · Lektion

Feature-Skalierung: StandardScaler und MinMaxScaler

Passen Sie StandardScaler und MinMaxScaler an Trainingsdaten an, transformieren Sie Testdaten separat und verstehen Sie, warum das Anpassen an Testdaten zu Data Leakage führt.

Lektion 2 von 413 Schritte

Feature-Skalierung: StandardScaler und MinMaxScaler ist eine kostenlose Machine Learning Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Machine Learning Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Machine Learning Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum die Skalierung von Merkmalen wichtig ist

Viele Algorithmen des maschinellen Lernens reagieren empfindlich auf die Skalierung der Eingabemerkmale. Wenn ein Merkmal Werte von 0 bis 1000 und ein anderes Werte von 0 bis 1 umfasst, werden distanzbasierte Modelle wie KNN und SVM vom Merkmal mit der größeren Skala dominiert. Auch Algorithmen des Gradientenabstiegs konvergieren deutlich schneller, wenn die Merkmale eine ähnliche Skala haben. Baumbasierte Modelle wie Random Forests und XGBoost sind skalierungsinvariant und benötigen keine Skalierung, aber fast jeder andere Algorithmus profitiert davon.

import numpy as np

# Without scaling: 'income' dominates 'age'
X = np.array([
    [25, 50000],
    [35, 80000],
    [45, 120000]
])

# Distance between row 0 and row 1 (Euclidean)
dist = np.sqrt((25-35)**2 + (50000-80000)**2)
print('Distance dominated by income:', dist)
# age contributes 100, income contributes 900,000,000 to squared distance

StandardScaler: Z-Score-Normalisierung

StandardScaler transformiert jedes Merkmal so, dass es einen Mittelwert von null und eine Varianz von eins hat. Dazu wird die Formel z = (x - mean) / std angewendet. Dies wird als Standardisierung oder Z-Score-Normalisierung bezeichnet. Die resultierenden Werte sind um 0 zentriert und haben keinen festen Wertebereich. StandardScaler ist für die meisten Algorithmen die Standardwahl, darunter logistische Regression, SVMs und neuronale Netze, insbesondere wenn die Merkmalsverteilung näherungsweise gaußförmig ist.

from sklearn.preprocessing import StandardScaler
import numpy as np

X = np.array([[25, 50000], [35, 80000], [45, 120000]], dtype=float)

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

print('Scaled data:\n', X_scaled)
print('Mean per feature:', X_scaled.mean(axis=0))  # ~[0, 0]
print('Std per feature:', X_scaled.std(axis=0))    # ~[1, 1]

So speichert StandardScaler Statistiken

Nach dem Aufruf von fit() speichert StandardScaler die Statistiken des Trainingsdatensatzes in scaler.mean_ und scaler.scale_ (Standardabweichung). Dieselben Statistiken werden verwendet, wenn Sie transform() auf neue Daten anwenden – das bedeutet, dass der Testsatz anhand der Parametern des Trainingsdatensatzes skaliert wird und nicht anhand seiner eigenen. Dieses Verhalten ist korrekt: In der Produktion erhalten Sie einzelne Stichproben nacheinander und müssen sie mit den während des Trainings berechneten Statistiken skalieren.

from sklearn.preprocessing import StandardScaler
import numpy as np

X_train = np.array([[1, 200], [2, 400], [3, 600]], dtype=float)
X_test  = np.array([[4, 800]], dtype=float)

scaler = StandardScaler()
scaler.fit(X_train)  # Learn mean and std from training data ONLY

print('Learned mean:', scaler.mean_)
print('Learned scale:', scaler.scale_)

X_train_s = scaler.transform(X_train)
X_test_s  = scaler.transform(X_test)  # Uses SAME training statistics
print('Test scaled:', X_test_s)

MinMaxScaler: Skalierung auf einen festen Wertebereich

MinMaxScaler komprimiert jedes Merkmal mithilfe der Formel x_scaled = (x - x_min) / (x_max - x_min) auf einen festgelegten Wertebereich, typischerweise [0, 1]. Im Gegensatz zu StandardScaler erhält diese Methode die relative Form der Verteilung und eignet sich gut für nicht gaußförmige Daten. Sie reagiert empfindlich auf Ausreißer: Ein einzelner Extremwert kann alle anderen Werte in die Nähe von null oder eins drücken. MinMaxScaler wird häufig für neuronale Netze und Bildpixelwerte verwendet, die auf [0, 1] skaliert werden.

from sklearn.preprocessing import MinMaxScaler
import numpy as np

X = np.array([[10], [20], [30], [40], [50]], dtype=float)

scaler = MinMaxScaler(feature_range=(0, 1))
X_scaled = scaler.fit_transform(X)

print('MinMax scaled:', X_scaled.flatten())
# [0.0, 0.25, 0.5, 0.75, 1.0]

# Custom range: scale to [-1, 1]
scaler2 = MinMaxScaler(feature_range=(-1, 1))
print('[-1,1] scaled:', scaler2.fit_transform(X).flatten())

RobustScaler: Umgang mit Ausreißern

RobustScaler skaliert anhand des Medians und des Interquartilsabstands (IQR) statt anhand von Mittelwert und Standardabweichung. Da Median und IQR nicht durch Extremwerte beeinflusst werden, ist RobustScaler die bessere Wahl, wenn Ihre Daten erhebliche Ausreißer enthalten. Die Formel lautet: x_scaled = (x - median) / IQR. Verwenden Sie RobustScaler, wenn Sie Ausreißer nicht entfernen können und ihren Einfluss auf die an Ihr Modell übergebenen skalierten Werte möglichst gering halten möchten.

from sklearn.preprocessing import RobustScaler
import numpy as np

# Data with outlier at 1000
X = np.array([[1], [2], [3], [4], [1000]], dtype=float)

from sklearn.preprocessing import StandardScaler, RobustScaler

std_s = StandardScaler().fit_transform(X)
rob_s = RobustScaler().fit_transform(X)

print('StandardScaler (outlier squishes others):')
print(std_s.flatten())
print('RobustScaler (outlier isolated):')
print(rob_s.flatten())

Den richtigen Scaler auswählen

Hier ist eine kurze Entscheidungshilfe: Verwenden Sie StandardScaler, wenn Ihre Daten ungefähr gaußförmig verteilt sind und keine extremen Ausreißer enthalten – er ist die sicherste Standardwahl. Verwenden Sie MinMaxScaler, wenn Sie Werte in einem festen Bereich benötigen, etwa für Bilddaten oder Algorithmen, die Eingaben im Bereich [0, 1] erfordern. Verwenden Sie RobustScaler, wenn Ausreißer vorhanden und aussagekräftig sind, beispielsweise Finanzdaten mit Betrugsspitzen. Für baumbasierte Modelle (Random Forest, XGBoost, LightGBM) sollten Sie vollständig auf die Skalierung verzichten – sie bietet keinen Vorteil und erhöht lediglich die unnötige Komplexität.

from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Decision helper
def pick_scaler(has_outliers, needs_fixed_range, is_tree_model):
    if is_tree_model:
        return 'No scaling needed'
    elif has_outliers:
        return 'RobustScaler'
    elif needs_fixed_range:
        return 'MinMaxScaler'
    else:
        return 'StandardScaler'

print(pick_scaler(False, False, False))  # StandardScaler
print(pick_scaler(True, False, False))   # RobustScaler
print(pick_scaler(False, True, False))   # MinMaxScaler
print(pick_scaler(False, False, True))   # No scaling needed

Anpassen an Testdaten: Die Leakage-Falle

Ein häufiger Fehler besteht darin, fit_transform() auf den Testsatz anzuwenden, wodurch ein neuer Mittelwert und eine neue Standardabweichung aus den Testdaten berechnet werden. Dies ist eine Form von Data Leakage, da der Scaler von den Werten des Testsatzes beeinflusst wird. Das korrekte Vorgehen lautet: fit(X_train) → transform(X_train) → transform(X_test). Selbst eine geringfügige Genauigkeitssteigerung durch dieses Leakage kann zu übermäßig selbstsicheren Produktiveinsätzen führen, die bei tatsächlich unbekannten Daten scheitern.

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import numpy as np

X = np.random.randn(100, 3)
y = (X[:, 0] > 0).astype(int)

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

scaler = StandardScaler()

# CORRECT: fit on train, transform both
scaler.fit(X_train)
X_train_s = scaler.transform(X_train)
X_test_s  = scaler.transform(X_test)

# WRONG (leakage):
# scaler.fit_transform(X_test)  <- never do this

Skalierung innerhalb einer Pipeline

Der sauberste Weg, Skalierungs-Leakage zu vermeiden, besteht darin, den Scaler in eine scikit-learn-Pipeline einzubetten. Wenn die Pipeline mit cross_val_score oder GridSearchCV angepasst wird, passt jeder Fold den Scaler ausschließlich an den Trainingsanteil dieses Folds an. Der Test-Fold wird während der Anpassung niemals verwendet. Dies ist das produktionsreife Vorgehen: Vorverarbeitungs- und Modellierungsschritte werden gebündelt, sodass sich das Deployment auf den Aufruf von pipeline.predict(X_new) beschränkt.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', LogisticRegression(max_iter=200))
])

# Scaler fitted only on train fold in each CV iteration
scores = cross_val_score(pipe, X, y, cv=5)
print('CV accuracy:', scores.mean().round(3))

Inverse Transformation: zurück zur ursprünglichen Skala

Nach der Erstellung von Vorhersagen müssen Sie diese möglicherweise wieder in die ursprüngliche Skala umwandeln – beispielsweise muss ein Hauspreismodell, das mit logarithmisch skalierten Preisen trainiert wurde, Preise in Euro ausgeben. Sowohl StandardScaler als auch MinMaxScaler stellen inverse_transform() bereit, um die Skalierung rückgängig zu machen. Wenden Sie die inverse Transformation nur auf die Zielvariable an, wenn diese vor dem Training skaliert wurde. Merkmale müssen normalerweise nicht invers transformiert werden, da sie intern vom Modell verarbeitet werden.

from sklearn.preprocessing import StandardScaler
import numpy as np

y_train = np.array([100000, 200000, 300000, 400000], dtype=float).reshape(-1, 1)

target_scaler = StandardScaler()
y_scaled = target_scaler.fit_transform(y_train)
print('Scaled target:', y_scaled.flatten())

# After predicting in scaled space:
y_pred_scaled = np.array([[0.5]])
y_pred_original = target_scaler.inverse_transform(y_pred_scaled)
print('Prediction in original scale:', y_pred_original)

Skalierung dünn besetzter Daten mit MaxAbsScaler

Dünn besetzte Matrizen – wie sie bei der Textklassifikation mit TF-IDF-Vektoren häufig vorkommen – sollten nicht mit StandardScaler oder MinMaxScaler skaliert werden, da die Zentrierung die Dünnbesetztheit zerstört, indem die meisten Nullen in Werte ungleich null umgewandelt werden. Dadurch wird der Zweck der dünn besetzten Speicherung zunichtegemacht. MaxAbsScaler skaliert jedes Merkmal anhand seines maximalen Absolutwerts auf den Bereich [-1, 1], ohne es zu zentrieren, und erhält die Struktur der Dünnbesetztheit. Verwenden Sie bei dünn besetzten Merkmalsmatrizen aus Vektorisierern wie TfidfVectorizer immer MaxAbsScaler.

from sklearn.preprocessing import MaxAbsScaler
from scipy.sparse import csr_matrix
import numpy as np

# Simulated sparse TF-IDF matrix
X_sparse = csr_matrix(np.array([
    [0, 0.5, 0.3, 0],
    [0.8, 0, 0, 0.4],
    [0, 0.2, 0, 0.6]
]))

scaler = MaxAbsScaler()
X_scaled = scaler.fit_transform(X_sparse)
print('Scaled sparse matrix:\n', X_scaled.toarray())
# All values in [-1, 1], sparsity preserved

Scaler anhand realer Daten vergleichen

Um die praktische Wirkung der einzelnen Scaler zu sehen, vergleichen Sie ihre Ausgabeverteilungen direkt miteinander. Nach der Skalierung sollte die Ausgabe von StandardScaler ungefähr N(0,1) entsprechen, die Ausgabe von MinMaxScaler den Bereich [0,1] umfassen und die Ausgabe von RobustScaler einen Median von 0 sowie einen IQR von 1 aufweisen. Histogramme vor und nach der Skalierung bestätigen, dass die Transformation korrekt funktioniert hat. Eine gute Merkmalskalierung ist eine Voraussetzung für zuverlässiges Modelltraining und keine optionale Ergänzung.

import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
import numpy as np

X = np.random.exponential(scale=100, size=(200, 1))  # Skewed data

scalers = {
    'StandardScaler': StandardScaler(),
    'MinMaxScaler': MinMaxScaler(),
    'RobustScaler': RobustScaler()
}

fig, axes = plt.subplots(1, 4, figsize=(16, 4))
axes[0].hist(X, bins=30); axes[0].set_title('Original')
for ax, (name, sc) in zip(axes[1:], scalers.items()):
    ax.hist(sc.fit_transform(X), bins=30)
    ax.set_title(name)
plt.tight_layout()
plt.show()

Kurzer Test

Testen Sie Ihr Verständnis der Konzepte des maschinellen Lernens mit Python aus dieser Lektion.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt, warum die Skalierung von Merkmalen für distanzbasierte Algorithmen und Algorithmen des Gradientenabstiegs unverzichtbar ist, wie StandardScaler auf N(0,1) standardisiert, während MinMaxScaler auf [0,1] komprimiert, und warum Scaler ausschließlich anhand von Trainingsdaten angepasst werden dürfen, um Leakage zu verhindern. Als Nächstes beschäftigen wir uns mit der Kodierung kategorialer Variablen mithilfe von OrdinalEncoder und OneHotEncoder.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
30
Lektionen
120

Häufig gestellte Fragen

Ist die Lektion „Feature-Skalierung: StandardScaler und MinMaxScaler“ kostenlos?

Ja — der vollständige Text von „Feature-Skalierung: StandardScaler und MinMaxScaler“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Machine Learning Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Machine Learning Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Feature-Skalierung: StandardScaler und MinMaxScaler“?

Passen Sie StandardScaler und MinMaxScaler an Trainingsdaten an, transformieren Sie Testdaten separat und verstehen Sie, warum das Anpassen an Testdaten zu Data Leakage führt. Du übst Machine Learning Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Machine Learning Academy zu starten?

Keine Vorkenntnisse erforderlich. Machine Learning Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Feature-Skalierung: StandardScaler und MinMaxScaler“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Machine Learning Academy-Lektion Code schreiben und ausführen?

Ja. Jede Machine Learning Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Fehlende Werte behandeln: Löschen, imputieren und markieren
  2. Feature-Skalierung: StandardScaler und MinMaxScaler
  3. Kategoriale Variablen codieren: OrdinalEncoder und OneHotEncoder
  4. Schritte mit ColumnTransformer kombinieren
← Zurück zu Machine Learning Academy