Machine Learning Academy · Pelajaran

Penskalaan Ciri: StandardScaler dan MinMaxScaler

Pelajar akan memadankan StandardScaler dan MinMaxScaler dengan data latihan, mengubah data ujian secara berasingan, dan memahami sebab pemadanan pada data ujian menyebabkan kebocoran.

Pelajaran 2 daripada 413 langkah

Penskalaan Ciri: StandardScaler dan MinMaxScaler ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Mengapa Penskalaan Ciri Penting

Banyak algoritma pembelajaran mesin sensitif terhadap skala ciri input. Jika satu ciri merangkumi 0–1000 dan satu lagi merangkumi 0–1, model berasaskan jarak seperti KNN dan SVM akan dikuasai oleh ciri berskala lebih besar. Algoritma penurunan kecerunan juga menumpu jauh lebih pantas apabila ciri berkongsi skala yang serupa. Model berasaskan pepohon seperti Random Forest tidak dipengaruhi skala dan tidak memerlukan penskalaan, tetapi hampir semua algoritma lain mendapat manfaat daripadanya.

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: Penormalan Skor-Z

StandardScaler mengubah setiap ciri supaya mempunyai min sifar dan varians seunit dengan menggunakan formula: z = (x - mean) / std. Ini dipanggil penstandardan atau penormalan skor-z. Nilai yang terhasil berpusat di sekitar 0 tanpa julat tetap. StandardScaler ialah pilihan lalai untuk kebanyakan algoritma termasuk regresi logistik, SVM dan rangkaian neural, khususnya apabila taburan ciri menghampiri Gaussian.

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]

Cara StandardScaler Menyimpan Statistik

Selepas memanggil fit(), StandardScaler menyimpan statistik set latihan dalam scaler.mean_ dan scaler.scale_ (sisihan piawai). Statistik yang sama digunakan apabila anda memanggil transform() pada data baharu — ini bermakna set ujian diskalakan menggunakan parameter set latihan, bukan parameter set itu sendiri. Inilah tingkah laku yang betul: dalam pengeluaran, anda menerima sampel individu satu demi satu dan mesti menskalakannya menggunakan statistik yang dikira semasa latihan.

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: Menskala Semula kepada Julat Tetap

MinMaxScaler memampatkan setiap ciri kepada julat yang ditentukan, biasanya [0, 1], menggunakan formula: x_scaled = (x - x_min) / (x_max - x_min). Tidak seperti StandardScaler, ia mengekalkan bentuk relatif taburan dan mengendalikan data bukan Gaussian dengan baik. Ia sensitif terhadap pencilan: satu nilai ekstrem boleh menghimpit semua nilai lain hampir kepada sifar atau satu. MinMaxScaler popular untuk rangkaian neural dan nilai piksel imej (diskalakan kepada [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: Mengendalikan Pencilan

RobustScaler melakukan penskalaan menggunakan median dan julat antara kuartil (IQR), bukannya min dan sisihan piawai. Oleh sebab median dan IQR tidak dipengaruhi oleh nilai ekstrem, RobustScaler ialah pilihan yang lebih baik apabila data Anda mengandungi pencilan yang ketara. Formulanya ialah: x_scaled = (x - median) / IQR. Gunakan RobustScaler apabila pencilan tidak dapat dibuang dan Anda mahu pencilan tersebut memberi pengaruh minimum terhadap nilai berskala yang dihantar kepada model Anda.

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())

Memilih Penskal yang Tepat

Berikut ialah panduan keputusan ringkas: gunakan StandardScaler apabila data Anda hampir mengikut taburan Gaussian dan tiada pencilan ekstrem — ini ialah pilihan lalai yang paling selamat. Gunakan MinMaxScaler apabila Anda memerlukan nilai dalam julat tetap, seperti untuk data imej atau algoritma yang memerlukan input [0, 1]. Gunakan RobustScaler apabila pencilan wujud dan mempunyai makna (contohnya, data kewangan dengan lonjakan penipuan). Untuk model berasaskan pepohon (Random Forest, XGBoost, LightGBM), jangan lakukan penskalaan — penskalaan tidak memberi manfaat dan hanya menambah kerumitan yang tidak diperlukan.

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

Melakukan Pemasangan pada Data Ujian: Perangkap Kebocoran

Kesilapan yang biasa berlaku ialah memanggil fit_transform() pada set ujian, yang mengira min dan sisihan piawai baharu daripada data ujian. Ini ialah salah satu bentuk kebocoran data kerana penskal dipengaruhi oleh nilai dalam set ujian. Corak yang betul ialah: fit(X_train) → transform(X_train) → transform(X_test). Peningkatan kecil dalam ketepatan akibat kebocoran ini pun boleh menyebabkan penggunaan model dalam pengeluaran yang terlalu yakin, lalu gagal apabila berdepan dengan data yang benar-benar belum pernah dilihat.

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

Penskalaan dalam Saluran Paip

Cara paling kemas untuk mengelakkan kebocoran penskalaan adalah dengan membenamkan penskal di dalam Pipeline scikit-learn. Apabila saluran paip dipasang menggunakan cross_val_score atau GridSearchCV, setiap lipatan memasang penskal hanya pada bahagian latihan lipatan tersebut. Lipatan ujian tidak pernah disentuh semasa pemasangan. Ini ialah corak yang sedia untuk pengeluaran: langkah prapemprosesan dan pemodelan digabungkan, menjadikan penggunaan semudah memanggil 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))

Transformasi Songsang: Kembali kepada Skala Asal

Selepas membuat ramalan, Anda mungkin perlu menukar ramalan kembali kepada skala asal — contohnya, model harga rumah yang dilatih menggunakan harga berskala log perlu mengeluarkan harga dalam dolar. Kedua-dua StandardScaler dan MinMaxScaler menyediakan inverse_transform() untuk membalikkan penskalaan. Hanya lakukan transformasi songsang terhadap pemboleh ubah sasaran jika pemboleh ubah itu diskalakan sebelum latihan. Ciri biasanya tidak perlu melalui transformasi songsang kerana ciri digunakan secara dalaman oleh model.

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)

Menskalakan Data Jarang dengan MaxAbsScaler

Matriks jarang — yang biasa digunakan dalam pengelasan teks dengan vektor TF-IDF — tidak boleh diskalakan menggunakan StandardScaler atau MinMaxScaler kerana pemusatan memusnahkan sifat jarang dengan menjadikan kebanyakan sifar sebagai bukan sifar, sekali gus menafikan tujuan storan jarang. MaxAbsScaler menskalakan setiap ciri berdasarkan nilai mutlak maksimumnya, memetakan nilai kepada julat [-1, 1] tanpa pemusatan, dan mengekalkan struktur jarang. Sentiasa gunakan MaxAbsScaler apabila bekerja dengan matriks ciri jarang daripada pemvektoran seperti 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 preserved

Membandingkan Penskal pada Data Sebenar

Untuk melihat kesan praktikal setiap penskal, bandingkan taburan outputnya secara bersebelahan. Selepas penskalaan, output StandardScaler sepatutnya menghampiri N(0,1), output MinMaxScaler sepatutnya merangkumi [0,1], dan output RobustScaler sepatutnya mempunyai median 0 dengan IQR 1. Melukis histogram sebelum dan selepas penskalaan mengesahkan bahawa transformasi berfungsi dengan betul. Penskalaan ciri yang baik ialah prasyarat untuk latihan model yang boleh dipercayai, bukannya tambahan pilihan.

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()

Semakan Pantas

Uji pemahaman Anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Rumusan Pelajaran

Dalam pelajaran ini Anda telah mempelajari: sebab penskalaan ciri penting untuk algoritma berasaskan jarak dan penurunan kecerunan, cara StandardScaler menyeragamkan kepada N(0,1) manakala MinMaxScaler memampatkan kepada [0,1], serta peraturan penting untuk memasang penskal hanya pada data latihan bagi mengelakkan kebocoran. Seterusnya, kita akan meneroka pengekodan pemboleh ubah kategori dengan OrdinalEncoder dan OneHotEncoder.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Penskalaan Ciri: StandardScaler dan MinMaxScaler” percuma?

Ya — teks penuh “Penskalaan Ciri: StandardScaler dan MinMaxScaler” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Penskalaan Ciri: StandardScaler dan MinMaxScaler”?

Pelajar akan memadankan StandardScaler dan MinMaxScaler dengan data latihan, mengubah data ujian secara berasingan, dan memahami sebab pemadanan pada data ujian menyebabkan kebocoran. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Penskalaan Ciri: StandardScaler dan MinMaxScaler” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?

Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Mengendalikan Nilai Hilang: Gugur, Imputasi dan Tandakan
Penskalaan Ciri: StandardScaler dan MinMaxScaler
Pengekodan Pemboleh Ubah Kategori: OrdinalEncoder dan OneHotEncoder
Menggabungkan Langkah dengan ColumnTransformer

← Kembali ke Machine Learning Academy