Featureskalering: StandardScaler og MinMaxScaler
Tilpas StandardScaler og MinMaxScaler til træningsdata, transformér testdata separat, og forstå, hvorfor tilpasning til testdata medfører datalækage.
Featureskalering: StandardScaler og MinMaxScaler er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvorfor skalering af features er vigtig
Mange maskinlæringsalgoritmer er følsomme over for skalaen på inputfeatures. Hvis én feature går fra 0 til 1000, og en anden går fra 0 til 1, vil afstandsbaserede modeller som KNN og SVM blive domineret af featuren med den største skala. Algoritmer med gradient descent konvergerer også meget hurtigere, når features har nogenlunde samme skala. Træbaserede modeller som Random Forests og XGBoost er skalauafhængige og kræver ikke skalering, men næsten alle andre algoritmer har fordel af det.
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 distanceStandardScaler: Z-score-normalisering
StandardScaler transformerer hver feature, så den får gennemsnit nul og varians én, ved at anvende formlen: z = (x - mean) / std. Dette kaldes standardisering eller z-score-normalisering. De resulterende værdier er centreret omkring 0 uden et fast interval. StandardScaler er standardvalget for de fleste algoritmer, herunder logistisk regression, SVM'er og neurale netværk, især når featurefordelingen er tilnærmelsesvis gaussisk.
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]Sådan gemmer StandardScaler statistik
Efter kaldet til fit() gemmer StandardScaler træningssættets statistik i scaler.mean_ og scaler.scale_ (standardafvigelsen). De samme statistiske værdier bruges, når du kalder transform() på nye data — det betyder, at testsættet skaleres med parametrene fra træningssættet og ikke med sine egne. Dette er den korrekte fremgangsmåde: I produktion modtager du individuelle observationer én ad gangen og skal skalere dem med den statistik, der blev beregnet under træningen.
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: Skalering til et fast interval
MinMaxScaler komprimerer hver feature til et angivet interval, typisk [0, 1], ved hjælp af formlen: x_scaled = (x - x_min) / (x_max - x_min). I modsætning til StandardScaler bevarer den fordelingens relative form og håndterer ikke-gaussiske data godt. Den er følsom over for outliers: Én ekstrem værdi kan presse alle andre værdier tæt på nul eller én. MinMaxScaler er populær til neurale netværk og billeders pixelværdier (skaleret til [0, 1]).
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: Håndtering af outliers
RobustScaler skalerer ved hjælp af medianen og interkvartilafstanden (IQR) i stedet for middelværdi og standardafvigelse. Da medianen og IQR ikke påvirkes af ekstreme værdier, er RobustScaler et bedre valg, når dine data indeholder betydelige outliers. Formlen er: x_scaled = (x - median) / IQR. Brug RobustScaler, når du ikke kan fjerne outliers og ønsker, at de skal have minimal indflydelse på de skalerede værdier, der sendes til din model.
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())Valg af den rigtige skaleringsmetode
Her er en hurtig vejledning til valget: Brug StandardScaler, når dine data omtrent følger en gaussisk fordeling, og du ikke har ekstreme outliers — det er det sikreste standardvalg. Brug MinMaxScaler, når du har brug for værdier inden for et fast interval, f.eks. til billeddata eller algoritmer, der kræver inputværdier i [0, 1]. Brug RobustScaler, når der findes outliers, som har betydning (f.eks. finansielle data med pludselige svindelrelaterede udsving). For træbaserede modeller (Random Forest, XGBoost, LightGBM) skal du helt undlade skalering — det giver ingen fordel og tilføjer unødvendig kompleksitet.
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 neededTilpasning på testdata: Fælden med datalækage
En almindelig fejl er at kalde fit_transform() på testsættet, hvilket beregner en ny middelværdi og standardafvigelse ud fra testdata. Det er en form for datalækage, fordi skaleren påvirkes af værdierne i testsættet. Det korrekte mønster er: fit(X_train) → transform(X_train) → transform(X_test). Selv en lille forbedring af nøjagtigheden på grund af denne lækage kan føre til overmodige produktionsimplementeringer, som fejler på data, modellen reelt ikke har set før.
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 thisSkalering i en pipeline
Den reneste måde at undgå skaleringslækage på er at indlejre skaleren i en scikit-learn-Pipeline. Når pipelinen tilpasses med cross_val_score eller GridSearchCV, tilpasses skaleren i hvert fold kun på træningsdelen af det pågældende fold. Testfoldet berøres aldrig under tilpasningen. Dette er det produktionsklare mønster: forbehandlings- og modelleringstrinene samles, så implementeringen bliver lige så enkel som at kalde pipeline.predict(X_new).
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))Invers transformation: Tilbage til den oprindelige skala
Efter at have lavet forudsigelser kan det være nødvendigt at konvertere dem tilbage til den oprindelige skala — f.eks. skal en boligprismodel, der er trænet på log-skalerede priser, returnere priser i kroner. Både StandardScaler og MinMaxScaler har inverse_transform(), som ophæver skaleringen. Udfør kun invers transformation på målvariablen, hvis den blev skaleret før træningen. Funktioner behøver typisk ikke at blive transformeret tilbage, fordi modellen bruger dem internt.
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)Skalering af sparsomme data med MaxAbsScaler
Sparsomme matricer — som er almindelige i tekstklassifikation med TF-IDF-vektorer — bør ikke skaleres med StandardScaler eller MinMaxScaler, fordi centrering ødelægger sparsiteten ved at gøre de fleste nuller til værdier, der ikke er nul, hvilket modvirker formålet med sparsomme datastrukturer. MaxAbsScaler skalerer hver funktion med dens største absolutte værdi og afbilder værdierne til intervallet [-1, 1] uden centrering, samtidig med at den bevarer sparsitetens struktur. Brug altid MaxAbsScaler, når du arbejder med sparsomme funktionsmatricer fra vektoriseringsværktøjer som TfidfVectorizer.
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 preservedSammenligning af skaleringsmetoder på reelle data
Hvis du vil se den praktiske effekt af hver skaleringsmetode, kan du sammenligne deres outputfordelinger side om side. Efter skalering bør outputtet fra StandardScaler omtrent følge N(0,1), outputtet fra MinMaxScaler bør spænde over [0,1], og outputtet fra RobustScaler bør have medianen 0 og en IQR på 1. Histogrammer før og efter skalering bekræfter, at transformationen er udført korrekt. God skalering af funktioner er en forudsætning for pålidelig modeltræning, ikke en valgfri tilføjelse.
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()Hurtigt tjek
Test din forståelse af begreberne inden for Machine Learning with Python fra denne lektion.
Opsummering af lektionen
I denne lektion har du lært: hvorfor skalering af funktioner er afgørende for afstandsbaserede algoritmer og algoritmer med gradient descent, hvordan StandardScaler standardiserer til N(0,1), mens MinMaxScaler komprimerer til [0,1], samt den kritiske regel om kun at tilpasse skaleringsmetoder på træningsdata for at forhindre lækage. Næste gang ser vi på kodning af kategoriske variabler med OrdinalEncoder og OneHotEncoder.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Featureskalering: StandardScaler og MinMaxScaler” gratis?
Ja — hele teksten til “Featureskalering: StandardScaler og MinMaxScaler” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Featureskalering: StandardScaler og MinMaxScaler”?
Tilpas StandardScaler og MinMaxScaler til træningsdata, transformér testdata separat, og forstå, hvorfor tilpasning til testdata medfører datalækage. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Machine Learning Academy?
Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Featureskalering: StandardScaler og MinMaxScaler”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?
Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Håndtering af manglende værdier: Fjern, imputér og markér
- Featureskalering: StandardScaler og MinMaxScaler
- Kodning af kategoriske variabler: OrdinalEncoder og OneHotEncoder
- Kombination af trin med ColumnTransformer