ทำไมต้องศึกษา Scikit-learn?

3 เสาหลักของ Scikit-learn Objects

BaseEstimator: แม่ของทุกสรรพสิ่ง

คลาสแม่แบบ (Parent Class) ที่ทุกโมเดลใน Scikit-learn สืบทอดมา [1]

from sklearn.base import BaseEstimator

class MyModel(BaseEstimator):
    def __init__(self, param1=1):
        self.param1 = param1  # เก็บค่าพารามิเตอร์

การใช้ Mixins

Scikit-learn ใช้ Multiple Inheritance เพื่อแยกความสามารถ (ISP Principle)

SOLID: SRP ใน Scikit-learn

SOLID: OCP

"เปิดรับการขยาย (Extension) แต่ปิดกั้นการแก้ไข (Modification)"

class OutlierRemover(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        return self
    def transform(self, X):
        # Logic การตัด Outlier ของเราเอง
        return X[X < 100]

SOLID: LSP

"ความสามารถในการแทนที่กันได้ (Interchangeability)"

def evaluate_model(model, X, y):
    model.fit(X, y)
    print(model.score(X, y))

# ส่งอะไรไปก็ได้
evaluate_model(SVC(), X, y)
evaluate_model(RandomForestClassifier(), X, y)

SOLID: DIP

Design Pattern: Composite

การมองกลุ่มของวัตถุ ให้เป็นวัตถุเดียว (Treating a group of objects as a single object)

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA()),
    ('svc', SVC())
])

# เรียกครั้งเดียว ทำงานทั้ง 3 ขั้นตอน
pipe.fit(X, y)

Design Pattern: Strategy

การสลับเปลี่ยนอัลกอริทึมภายใน Object

Design Pattern: Template Method

กฎเหล็กของ __init__

เพื่อให้ OOP ของ Scikit-learn (เช่นการโคลนโมเดล) ทำงานได้ ต้องปฏิบัติตามนี้ [3]:

def __init__(self, param1=1):
    self.param1 = param1
        

Duck Typing คือหัวใจ

"ถ้ามันเดินเหมือนเป็ด และร้องเหมือนเป็ด มันก็คือเป็ด"

การสร้าง Custom Transformer

from sklearn.base import BaseEstimator, TransformerMixin

class MyScaler(BaseEstimator, TransformerMixin):
    def __init__(self, factor=1):
        self.factor = factor
        
    def fit(self, X, y=None):
        # เรียนรู้ค่า mean, etc (ถ้ามี)
        return self
        
    def transform(self, X):
        return X * self.factor

จัดการข้อมูลที่ซับซ้อนด้วย ColumnTransformer

ในโลกความเป็นจริง ข้อมูลมักมีทั้งตัวเลข (Numerical) และตัวหนังสือ (Categorical)

การบันทึกวัตถุ (Persistence)

OOP ช่วยให้เราบันทึกสถานะของ Object (Model ที่เทรนแล้ว) ลงไฟล์ได้

สรุปหลักการก่อนเข้า Lab

เข้าสู่ ห้องปฏิบัติการ

สร้าง Custom Transformer และ Pipeline สำหรับข้อมูล Iris Dataset

Step 1: เตรียม Environment

ติดตั้ง Library ที่จำเป็น

หรือกรณีที่ใช้ uv

import numpy as np
import pandas as pd
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
      

Step 2: โหลดข้อมูล (The Iris Dataset)

# โหลดข้อมูล
iris = load_iris()
X = iris.data
y = iris.target

# แบ่ง Train/Test (80/20)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

Step 3: โครงสร้าง Custom Transformer

สร้างคลาส OutlierClipper ที่สืบทอดจาก BaseEstimator และ TransformerMixin

class OutlierClipper(BaseEstimator, TransformerMixin):
    def __init__(self, factor=1.5):
        self.factor = factor  # ตัวคูณ IQR
        
    def fit(self, X, y=None):
        # คำนวณขอบเขตล่างและบน (Lower/Upper Bound)
        # เดี๋ยวเราจะเติมโค้ดตรงนี้
        return self
        
    def transform(self, X):
        # แทนที่ค่าที่เกินขอบเขต
        # เดี๋ยวเราจะเติมโค้ดตรงนี้
        return X_clipped

Step 4: Implement fit()

ในเมธอด fit เราจะเรียนรู้จากข้อมูล (X) ว่าขอบเขตของข้อมูลควรเป็นเท่าไหร่ (ใช้ IQR Technique)

    def fit(self, X, y=None):
        # X เป็น numpy array
        # คำนวณ Quartile 1 และ 3
        Q1 = np.percentile(X, 25, axis=0)
        Q3 = np.percentile(X, 75, axis=0)
        IQR = Q3 - Q1
        
        # บันทึก State ลงใน Object (Attributes มี _ ต่อท้ายตามธรรมเนียม)
        self.lower_bound_ = Q1 - (self.factor * IQR)
        self.upper_bound_ = Q3 + (self.factor * IQR)
        
        return self  # ต้องคืนค่า self เสมอเพื่อให้ Chain ได้

Step 5: Implement transform()

ใช้ค่า lower_bound_ และ upper_bound_ ที่เรียนรู้มา เพื่อจำกัดค่า (Clip) ข้อมูล

    def transform(self, X):
        # ตรวจสอบว่า fit หรือยัง? (Optional แต่ดี)
        if not hasattr(self, "lower_bound_"):
            raise RuntimeError("This OutlierClipper instance is not fitted yet.")
            
        # ใช้ np.clip เพื่อจำกัดค่าให้อยู่ในช่วง
        return np.clip(X, self.lower_bound_, self.upper_bound_)

Step 6: สร้าง Pipeline

เชื่อมต่อ Custom Transformer ของเราเข้ากับ SVM Classifier

# สร้าง Pipeline: (Preprocessing) -> (Model)
pipeline = Pipeline([
    ('clipper', OutlierClipper(factor=1.5)),
    ('svm', SVC(kernel='linear'))
])

# สั่งเทรนทีเดียว (จะเรียก clipper.fit -> clipper.transform -> svm.fit)
pipeline.fit(X_train, y_train)

print("Training Complete!")

Step 7: ประเมินผล (Evaluation)

ทดสอบ Pipeline กับ Test Set

# ทำนายผล
# (เรียก clipper.transform -> svm.predict)
y_pred = pipeline.predict(X_test)

# ตรวจสอบความแม่นยำ
score = pipeline.score(X_test, y_test)
print(f"Accuracy: {score:.2f}")

Step 8: เปลี่ยนโมเดล (LSP Test)

ลองเปลี่ยนจาก SVC เป็น RandomForestClassifier โดยไม่แก้ Pipeline Logic

from sklearn.ensemble import RandomForestClassifier

# เปลี่ยนแค่ตัวสุดท้ายของ Pipeline
pipeline.steps.pop()  # เอา SVM ออก
pipeline.steps.append(('rf', RandomForestClassifier()))

# Fit ใหม่ได้เลย
pipeline.fit(X_train, y_train)
print(f"New Accuracy: {pipeline.score(X_test, y_test):.2f}")

Step 9: การเข้าถึงพารามิเตอร์

เนื่องจากเราสืบทอด BaseEstimator เราจึงใช้ get_params() ได้ทันที

# ดูพารามิเตอร์ทั้งหมดใน Pipeline
params = pipeline.get_params()
print(params)

# เราจะเห็น 'clipper__factor' อยู่ในนั้น
# ลองเปลี่ยนค่า factor ผ่าน Pipeline
pipeline.set_params(clipper__factor=2.0)
pipeline.fit(X_train, y_train)  # เทรนใหม่ด้วย factor ใหม่

Lab Completed!

"คุณได้สร้าง OOP Component ที่ทำงานร่วมกับ Standard Library ระดับโลกได้"