PricingLoginStart free
Machine Learning Academy · บทเรียน

การปรับสเกลคุณลักษณะ: StandardScaler และ MinMaxScaler

ผู้เรียนจะปรับ StandardScaler และ MinMaxScaler ให้เข้ากับข้อมูลฝึก แปลงข้อมูลทดสอบแยกต่างหาก และเข้าใจว่าเหตุใดการปรับให้เข้ากับข้อมูลทดสอบจึงทำให้เกิดการรั่วไหลของข้อมูล

บทเรียน 2 จาก 413 ขั้นตอน

การปรับสเกลคุณลักษณะ: StandardScaler และ MinMaxScaler เป็นบทเรียน Machine Learning Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Machine Learning Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน

เหตุใดการปรับสเกลคุณลักษณะจึงสำคัญ

อัลกอริทึมการเรียนรู้ของเครื่องจำนวนมากไวต่อ สเกลของคุณลักษณะอินพุต หากคุณลักษณะหนึ่งมีช่วง 0–1000 และอีกคุณลักษณะมีช่วง 0–1 แบบจำลองที่อาศัยระยะห่าง เช่น KNN และ SVM จะถูกครอบงำโดยคุณลักษณะที่มีสเกลใหญ่กว่า อัลกอริทึมการลงตามความชันยังลู่เข้าได้เร็วขึ้นมากเมื่อคุณลักษณะมีสเกลใกล้เคียงกัน แบบจำลองที่ใช้ต้นไม้ เช่น Random Forest และ XGBoost ไม่ไวต่อสเกล จึงไม่จำเป็นต้องปรับสเกล แต่เกือบทุกอัลกอริทึมอื่นจะได้ประโยชน์จากการปรับสเกล

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

StandardScaler แปลงคุณลักษณะแต่ละรายการให้มี ค่าเฉลี่ยเป็นศูนย์และความแปรปรวนเป็นหนึ่ง โดยใช้สูตร z = (x - mean) / std วิธีนี้เรียกว่า การทำให้เป็นมาตรฐาน หรือ การทำให้เป็นมาตรฐานด้วยคะแนน z ค่าที่ได้จะอยู่รอบ 0 โดยไม่มีช่วงตายตัว StandardScaler เป็นตัวเลือกเริ่มต้นสำหรับอัลกอริทึมส่วนใหญ่ รวมถึงการถดถอยโลจิสติก SVM และโครงข่ายประสาท โดยเฉพาะเมื่อการแจกแจงของคุณลักษณะใกล้เคียงการแจกแจงแบบเกาส์

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]

วิธีที่ StandardScaler จัดเก็บสถิติ

หลังจากเรียกใช้ fit() แล้ว StandardScaler จะจัดเก็บสถิติของชุดฝึกไว้ใน scaler.mean_ และ scaler.scale_ (ส่วนเบี่ยงเบนมาตรฐาน) สถิติเดียวกันนี้จะถูกใช้เมื่อคุณเรียก transform() กับข้อมูลใหม่ ซึ่งหมายความว่าชุดทดสอบจะถูกปรับสเกลโดยใช้พารามิเตอร์จากชุดฝึก ไม่ใช่พารามิเตอร์ของชุดทดสอบเอง นี่คือพฤติกรรมที่ถูกต้อง เพราะในการใช้งานจริง คุณจะได้รับตัวอย่างทีละรายการและต้องปรับสเกลโดยใช้สถิติที่คำนวณระหว่างการฝึก

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: การปรับสเกลใหม่ให้อยู่ในช่วงตายตัว

MinMaxScaler บีบคุณลักษณะแต่ละรายการให้อยู่ในช่วงที่กำหนด โดยทั่วไปคือ [0, 1] ด้วยสูตร x_scaled = (x - x_min) / (x_max - x_min) ต่างจาก StandardScaler ตรงที่ยังคงรูปทรงสัมพัทธ์ของการแจกแจงไว้ และทำงานได้ดีกับข้อมูลที่ไม่ได้มีการแจกแจงแบบเกาส์ วิธีนี้ไวต่อค่าผิดปกติ ค่าสุดโต่งเพียงค่าเดียวอาจบีบให้ค่าอื่น ๆ ทั้งหมดเข้าใกล้ศูนย์หรือหนึ่ง MinMaxScaler เป็นที่นิยมสำหรับโครงข่ายประสาทและค่าพิกเซลของภาพ (ปรับสเกลให้อยู่ในช่วง [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: การจัดการค่าผิดปกติ

RobustScaler ปรับสเกลโดยใช้ ค่ามัธยฐานและพิสัยระหว่างควอไทล์ (IQR) แทนค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐาน เนื่องจากค่ามัธยฐานและ IQR ไม่ได้รับอิทธิพลจากค่าสุดโต่ง RobustScaler จึงเป็นตัวเลือกที่ดีกว่าเมื่อข้อมูลของคุณมีค่าผิดปกติจำนวนมาก สูตรคือ x_scaled = (x - median) / IQR ใช้ RobustScaler เมื่อคุณไม่สามารถลบค่าผิดปกติได้ และต้องการให้ค่าดังกล่าวมีอิทธิพลต่อค่าที่ส่งต่อไปยังแบบจำลองหลังปรับสเกลน้อยที่สุด

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

การเลือกตัวปรับสเกลที่เหมาะสม

แนวทางตัดสินใจอย่างรวดเร็วมีดังนี้: ใช้ StandardScaler เมื่อข้อมูลมีการแจกแจงใกล้เคียงแบบเกาส์และไม่มีค่าผิดปกติสุดโต่ง — เป็นค่าเริ่มต้นที่ปลอดภัยที่สุด ใช้ MinMaxScaler เมื่อต้องการให้ค่าอยู่ในช่วงตายตัว เช่น ข้อมูลภาพหรืออัลกอริทึมที่ต้องการอินพุตในช่วง [0, 1] ใช้ RobustScaler เมื่อมีค่าผิดปกติที่มีความหมาย เช่น ข้อมูลการเงินที่มีการพุ่งขึ้นจากการฉ้อโกง สำหรับ แบบจำลองที่ใช้ต้นไม้ (Random Forest, XGBoost, LightGBM) ให้ข้ามการปรับสเกลไปทั้งหมด เพราะไม่มีประโยชน์และเพิ่มความซับซ้อนโดยไม่จำเป็น

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

การฝึกกับข้อมูลทดสอบ: กับดักการรั่วไหล

ข้อผิดพลาดที่พบบ่อยคือการเรียกใช้ fit_transform() กับชุดทดสอบ ซึ่ง คำนวณค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานใหม่จากข้อมูลทดสอบ นี่เป็นรูปแบบหนึ่งของการรั่วไหลของข้อมูล เพราะตัวปรับสเกลได้รับอิทธิพลจากค่าของชุดทดสอบ รูปแบบที่ถูกต้องคือ fit(X_train) → transform(X_train) → transform(X_test) แม้การปรับปรุงความแม่นยำเพียงเล็กน้อยจากการรั่วไหลนี้ ก็อาจนำไปสู่การนำระบบไปใช้งานจริงด้วยความมั่นใจเกินควร และล้มเหลวเมื่อพบข้อมูลที่ไม่เคยเห็นมาก่อนจริง ๆ

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

การปรับสเกลภายในกระบวนการประมวลผล

วิธีที่สะอาดที่สุดในการหลีกเลี่ยงการรั่วไหลจากการปรับสเกล คือฝังตัวปรับสเกลไว้ภายใน Pipeline ของ scikit-learn เมื่อฝึก pipeline ด้วย cross_val_score หรือ GridSearchCV แต่ละชุดย่อยจะฝึกตัวปรับสเกลโดยใช้เฉพาะส่วนฝึกของชุดย่อยนั้นเท่านั้น จะไม่มีการแตะต้องชุดทดสอบระหว่างการฝึกเลย นี่คือรูปแบบที่พร้อมใช้งานจริง โดยรวมขั้นตอนการเตรียมข้อมูลและการสร้างแบบจำลองไว้ด้วยกัน ทำให้การนำไปใช้งานจริงทำได้ง่ายเพียงเรียก 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))

การแปลงกลับ: กลับสู่สเกลเดิม

หลังจากสร้างคำทำนายแล้ว คุณอาจต้องแปลงคำทำนายกลับไปเป็นสเกลเดิม ตัวอย่างเช่น แบบจำลองราคาบ้านที่ฝึกด้วยราคาที่ปรับสเกลแบบลอการิทึมจะต้องแสดงผลเป็นราคาในหน่วยดอลลาร์ ทั้ง StandardScaler และ MinMaxScaler มี inverse_transform() สำหรับย้อนกลับการปรับสเกล ให้แปลงกลับเฉพาะตัวแปรเป้าหมายเท่านั้น หากมีการปรับสเกลตัวแปรนั้นก่อนการฝึก โดยทั่วไปไม่จำเป็นต้องแปลงกลับคุณลักษณะ เพราะแบบจำลองจะนำคุณลักษณะเหล่านั้นไปใช้ภายใน

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)

การปรับสเกลข้อมูลแบบกระจายด้วย MaxAbsScaler

เมทริกซ์แบบกระจาย ซึ่งพบได้บ่อยในการจำแนกข้อความที่ใช้เวกเตอร์ TF-IDF ไม่ควรปรับสเกลด้วย StandardScaler หรือ MinMaxScaler เพราะการจัดให้มีค่าเฉลี่ยอยู่ที่ศูนย์จะทำลายความกระจาย ทำให้ค่าศูนย์ส่วนใหญ่กลายเป็นค่าที่ไม่ใช่ศูนย์และทำให้ข้อดีของการจัดเก็บแบบกระจายหมดไป MaxAbsScaler จะปรับสเกลแต่ละคุณลักษณะด้วยค่าสัมบูรณ์สูงสุดของคุณลักษณะนั้น โดยแมปค่าให้อยู่ในช่วง [-1, 1] โดยไม่จัดให้มีค่าเฉลี่ยอยู่ที่ศูนย์ และ คงโครงสร้างแบบกระจายไว้ ควรใช้ MaxAbsScaler เสมอเมื่อทำงานกับเมทริกซ์คุณลักษณะแบบกระจายจากตัวแปลงเวกเตอร์ เช่น 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

การเปรียบเทียบตัวปรับสเกลกับข้อมูลจริง

หากต้องการเห็นผลในทางปฏิบัติของตัวปรับสเกลแต่ละชนิด ให้เปรียบเทียบการกระจายของผลลัพธ์แบบวางเคียงข้างกัน หลังการปรับสเกล ผลลัพธ์ของ StandardScaler ควรมีการกระจายใกล้เคียง N(0,1) ผลลัพธ์ของ MinMaxScaler ควรครอบคลุมช่วง [0,1] และผลลัพธ์ของ RobustScaler ควรมีค่ามัธยฐานเป็น 0 และมี IQR เท่ากับ 1 การวาดฮิสโตแกรมก่อนและหลังการปรับสเกลช่วยยืนยันว่าการแปลงทำงานได้อย่างถูกต้อง การปรับสเกลคุณลักษณะที่ดีเป็นเงื่อนไขเบื้องต้นของการฝึกแบบจำลองที่เชื่อถือได้ ไม่ใช่ส่วนเสริมที่มีหรือไม่มีก็ได้

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

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจแนวคิด Machine Learning with Python จากบทเรียนนี้

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า เหตุใดการปรับสเกลคุณลักษณะจึงสำคัญ สำหรับอัลกอริทึมที่อาศัยระยะทางและการไล่ระดับลงตามความชัน StandardScaler ปรับมาตรฐานเป็น N(0,1) ได้อย่างไร ขณะที่ MinMaxScaler บีบค่าให้อยู่ในช่วง [0,1] และ กฎสำคัญคือต้องฝึกตัวปรับสเกลด้วยข้อมูลฝึกเท่านั้น เพื่อป้องกันการรั่วไหล บทถัดไปเราจะสำรวจการเข้ารหัสตัวแปรเชิงหมวดหมู่ด้วย OrdinalEncoder และ OneHotEncoder

เริ่มต้นได้ฟรี

เรียนรู้ Python ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
30
บทเรียน
120
เริ่มเรียนฟรีดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “การปรับสเกลคุณลักษณะ: StandardScaler และ MinMaxScaler” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การปรับสเกลคุณลักษณะ: StandardScaler และ MinMaxScaler” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Machine Learning Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การปรับสเกลคุณลักษณะ: StandardScaler และ MinMaxScaler”

ผู้เรียนจะปรับ StandardScaler และ MinMaxScaler ให้เข้ากับข้อมูลฝึก แปลงข้อมูลทดสอบแยกต่างหาก และเข้าใจว่าเหตุใดการปรับให้เข้ากับข้อมูลทดสอบจึงทำให้เกิดการรั่วไหลของข้อมูล คุณปฏิบัติ Machine Learning Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Machine Learning Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Machine Learning Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “การปรับสเกลคุณลักษณะ: StandardScaler และ MinMaxScaler” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Machine Learning Academy นี้ได้ไหม

ได้ บทเรียน Machine Learning Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การจัดการค่าที่หายไป: ลบ เติมค่า และทำเครื่องหมาย
  2. การปรับสเกลคุณลักษณะ: StandardScaler และ MinMaxScaler
  3. การเข้ารหัสตัวแปรเชิงกลุ่ม: OrdinalEncoder และ OneHotEncoder
  4. การรวมขั้นตอนด้วย ColumnTransformer
← กลับไปที่ Machine Learning Academy