Machine Learning Academy · บทเรียน

แบบจำลองพื้นฐาน: ต้องดีกว่า DummyClassifier เสมอ

ผู้เรียนจะสร้าง DummyClassifier เป็นค่าพื้นฐานขั้นต่ำ และยืนยันว่าแบบจำลองจริงทุกแบบต้องมีประสิทธิภาพเหนือกว่าแบบจำลองนี้ก่อนจึงจะถือว่ามีประโยชน์

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

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

เหตุผลที่คุณต้องมีค่าพื้นฐาน

เมื่อคุณรายงานว่าแบบจำลองมีความแม่นยำ 92% ตัวเลขนี้ไม่มีความหมายหากไม่มีบริบท ความแม่นยำ 92% น่าประทับใจหรือน่าผิดหวัง? คำตอบขึ้นอยู่กับว่ากลยุทธ์ที่ เรียบง่ายที่สุดเท่าที่เป็นไปได้จะทำได้เท่าใดกับปัญหาเดียวกัน

แบบจำลองค่าพื้นฐานคือระดับขั้นต่ำที่แบบจำลองจริงทุกแบบต้องทำให้ดีกว่า จึงจะถือว่ามีประโยชน์ หากไม่มีค่าพื้นฐาน คุณอาจดีใจกับความแม่นยำ 92% บนชุดข้อมูลที่แบบจำลองซึ่งทำนายว่า “ไม่ใช่การฉ้อโกง” เสมอทำได้ถึง 95% ซึ่งหมายความว่าแบบจำลอง ML อันซับซ้อนของคุณแย่กว่าการไม่ทำอะไรเลย

DummyClassifier: เครื่องมือค่าพื้นฐานของ scikit-learn

scikit-learn มี DummyClassifier ซึ่งเป็นตัวจำแนกประเภทแบบพื้นฐานที่ทำนายโดยใช้กฎง่าย ๆ และไม่สนใจคุณลักษณะอินพุตโดยสิ้นเชิง นี่คือเครื่องมืออย่างเป็นทางการสำหรับกำหนดค่าพื้นฐานก่อนเริ่มสร้างแบบจำลองจริง

DummyClassifier ไม่ใช่เรื่องล้อเล่นหรือตัวแทนชั่วคราว แต่เป็นการตรวจสอบความสมเหตุสมผลอย่างเคร่งครัด หากแบบจำลองจริงของคุณทำได้ไม่ดีกว่า DummyClassifier แสดงว่ามีบางอย่างผิดปกติในระดับพื้นฐาน: คุณลักษณะของคุณอาจทำนายผลไม่ได้ pipeline ของคุณอาจมีข้อผิดพลาด หรือปัญหาอาจยากกว่าที่คาดไว้

from sklearn.dummy import DummyClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Most frequent baseline: always predicts the majority class
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
baseline_acc = dummy.score(X_test, y_test)
print(f'Baseline accuracy (always predict majority class): {baseline_acc:.3f}')

กลยุทธ์ของ DummyClassifier

DummyClassifier รองรับกลยุทธ์ค่าพื้นฐานหลายแบบ:

most_frequent: ทำนายคลาสที่ปรากฏบ่อยที่สุดในการฝึกเสมอ เหมาะที่สุดสำหรับชุดข้อมูลที่คลาสไม่สมดุล
stratified: ทำนายแต่ละคลาสแบบสุ่ม โดยความน่าจะเป็นเท่ากับความถี่ของคลาสนั้นในการฝึก รักษาสัดส่วนของคลาส
uniform: ทำนายแต่ละคลาสแบบสุ่มด้วยความน่าจะเป็นเท่ากัน เหมาะเมื่อทุกคลาสมีจำนวนใกล้เคียงกัน
constant: ทำนายคลาสค่าคงที่ที่ระบุเสมอ ใช้ทดสอบผลลัพธ์เมื่อทำนายคลาสบวกเสมอ

from sklearn.dummy import DummyClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score
import numpy as np

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

for strategy in ['most_frequent', 'stratified', 'uniform', 'prior']:
    dummy = DummyClassifier(strategy=strategy, random_state=42)
    dummy.fit(X_train, y_train)
    acc = dummy.score(X_test, y_test)
    print(f'strategy={strategy}: accuracy={acc:.3f}')

ความขัดแย้งของความแม่นยำในการใช้งานจริง

ความขัดแย้งของความแม่นยำเห็นได้ชัดที่สุดในชุดข้อมูลที่คลาสไม่สมดุล ลองพิจารณาการฉ้อโกงบัตรเครดิตซึ่งธุรกรรม 99% ถูกต้องตามกฎหมาย DummyClassifier แบบ most_frequent จะทำนายว่า “ไม่ใช่การฉ้อโกง” สำหรับทุกธุรกรรม และได้ความแม่นยำ 99% แบบจำลอง ML จริงที่ได้ความแม่นยำ 97% จะ ดูแย่กว่าค่าพื้นฐานนี้เมื่อวัดด้วยความแม่นยำ แม้ว่าจะตรวจจับกรณีฉ้อโกงจริงได้เกือบทั้งหมดก็ตาม

นี่คือเหตุผลที่ต้องประเมินค่าพื้นฐานจาก DummyClassifier ด้วย ตัวชี้วัดเดียวกันกับที่จะใช้ประเมินแบบจำลองจริง สำหรับปัญหาที่คลาสไม่สมดุล ให้ใช้ F1 ความแม่นยำเชิงบวก หรืออัตราการตรวจพบ — ไม่ใช่ความแม่นยำ

from sklearn.dummy import DummyClassifier
from sklearn.metrics import f1_score, accuracy_score
import numpy as np

# Simulate 99% negative class (not fraud)
np.random.seed(42)
n = 10000
y_true = np.array([0]*9900 + [1]*100)
X_fake = np.random.randn(n, 5)  # random features (not predictive)

# Baseline always predicts not-fraud
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_fake, y_true)
y_pred_dummy = dummy.predict(X_fake)

print(f'Dummy Accuracy: {accuracy_score(y_true, y_pred_dummy):.3f}')  # 0.990
print(f'Dummy F1-score: {f1_score(y_true, y_pred_dummy):.3f}')         # 0.000
print('Dummy catches 0 fraud cases despite 99% accuracy!')

DummyRegressor: ค่าพื้นฐานสำหรับการถดถอย

สำหรับปัญหาการถดถอย scikit-learn มี DummyRegressor พร้อมกลยุทธ์ดังนี้:

mean: ทำนายค่าเฉลี่ยของชุดฝึกเสมอ นี่คือค่าพื้นฐานมาตรฐาน — R² วัดว่าแบบจำลองของคุณดีกว่าการทำนายค่าเฉลี่ยเพียงใด
median: ทำน่าค่ามัธยฐานของชุดฝึกเสมอ ทนต่อค่าผิดปกติได้ดีกว่า
quantile: ทำนายควอนไทล์ที่ระบุของค่าผลลัพธ์ในการฝึกเสมอ
constant: ทำนายค่าคงที่ที่ระบุเสมอ

แบบจำลองการถดถอยที่มีค่า R² ต่ำกว่า 0 แย่กว่าการทำนายค่าเฉลี่ยเสมอจริง ๆ ซึ่งเป็นสัญญาณชัดเจนว่ามีบางอย่างผิดพลาดในการฝึก

from sklearn.dummy import DummyRegressor
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split

X, y = fetch_california_housing(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

dummy_reg = DummyRegressor(strategy='mean')
dummy_reg.fit(X_train, y_train)
y_pred_d = dummy_reg.predict(X_test)

print(f'DummyRegressor MAE: {mean_absolute_error(y_test, y_pred_d):.3f}')
print(f'DummyRegressor R2:  {r2_score(y_test, y_pred_d):.3f}')  # exactly 0.0

แบบจำลองของคุณเทียบกับค่าพื้นฐาน

ตอนนี้ให้เปรียบเทียบแบบจำลองจริงกับค่าพื้นฐานโดยใช้ตัวชี้วัดเดียวกัน การปรับปรุงเมื่อเทียบกับค่าพื้นฐานจะบอกว่าแบบจำลอง ML ของคุณเพิ่มคุณค่าได้มากเพียงใด การเปรียบเทียบนี้ควรเป็นผลลัพธ์แรกที่คุณรายงานในโครงการ ML ทุกโครงการ

หากการปรับปรุงมีน้อย (เช่น แบบจำลองจริงได้ F1=0.65 เทียบกับค่าพื้นฐาน F1=0.60) ให้พิจารณาว่าความซับซ้อนและต้นทุนของแบบจำลอง ML คุ้มค่ากับการปรับปรุง 5% หรือไม่ บางครั้งระบบตามกฎที่เรียบง่ายมีต้นทุนต่ำกว่าและแม่นยำเพียงพอ

from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import f1_score
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Baseline
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
baseline_f1 = f1_score(y_test, dummy.predict(X_test))

# Real model
pipeline = Pipeline([('scaler', StandardScaler()), ('clf', LogisticRegression(max_iter=1000))])
pipeline.fit(X_train, y_train)
real_f1 = f1_score(y_test, pipeline.predict(X_test))

print(f'Baseline F1: {baseline_f1:.3f}')
print(f'Real model F1: {real_f1:.3f}')
print(f'Improvement over baseline: {real_f1 - baseline_f1:.3f}')

ประสิทธิภาพระดับมนุษย์ในฐานะค่าพื้นฐานที่สอง

สำหรับปัญหาในโลกจริงหลายประเภท เกณฑ์ประสิทธิภาพระดับมนุษย์มีความเกี่ยวข้องมากกว่าค่าพื้นฐานแบบง่าย ตัวอย่างเช่น อัตราข้อผิดพลาดของรังสีแพทย์ในการตรวจหาเนื้องอก ความแม่นยำของผู้คัดกรองสแปมที่เป็นมนุษย์ หรือข้อผิดพลาดในการประเมินราคาบ้านของผู้ประเมินผู้เชี่ยวชาญ

ประสิทธิภาพของมนุษย์เป็นเสมือนเพดาน: หากแบบจำลองของคุณทำได้เท่ากับหรือดีกว่ามนุษย์ ก็ถือว่าคุณแก้ปัญหาได้แล้ว หากแบบจำลองของคุณยังต่ำกว่ามนุษย์มาก ก็ยังมีโอกาสพัฒนาได้อีก หากแบบจำลองใกล้เคียงกับมนุษย์มาก การปรับปรุงเพิ่มเติมอาจต้องใช้ความพยายามอย่างมากเพื่อผลตอบแทนที่ลดลง

ระบบเดิมในฐานะค่าพื้นฐาน

ในภาคอุตสาหกรรม ค่าพื้นฐานที่เกี่ยวข้องที่สุดมักเป็น ระบบเดิมที่มีอยู่ซึ่งแบบจำลองของคุณกำลังจะเข้ามาแทนที่ หากระบบที่ใช้งานอยู่ในปัจจุบันใช้กฎที่สร้างขึ้นด้วยมือ ระบบนั้นคือเป้าหมายที่ต้องทำให้ดีกว่า หากมีการนำแบบจำลอง ML รุ่นก่อนมาใช้งานแล้ว ตัวชี้วัดจากการใช้งานจริงของแบบจำลองนั้นคือค่าพื้นฐานของคุณ

เมื่อรายงานผลต่อผู้มีส่วนได้ส่วนเสีย ให้เปรียบเทียบกับระบบปัจจุบันเสมอ ไม่ใช่แค่ DummyClassifier คุณค่าทางธุรกิจเกิดจากการปรับปรุงเมื่อเทียบกับสภาพปัจจุบัน การปรับปรุง 2% จากระบบปัจจุบันอาจมีมูลค่าหลายล้านบาทจากการลดความสูญเสียจากการฉ้อโกง แม้จะดูเล็กน้อยในเชิงตัวเลขก็ตาม

ค่าพื้นฐานสำหรับการจำแนกประเภทหลายคลาส

สำหรับปัญหาหลายคลาส ค่าพื้นฐานของ DummyClassifier ขึ้นอยู่กับความสมดุลของคลาส เมื่อมี K คลาสที่สมดุล กลยุทธ์ most_frequent จะได้ความแม่นยำ 1/K หากคลาสไม่สมดุล กลยุทธ์นี้จะได้สัดส่วนของคลาสที่พบบ่อยที่สุด

สำหรับตัวชี้วัดอย่าง F1 แบบเฉลี่ยมาโคร (ซึ่งให้น้ำหนักทุกคลาสเท่ากัน) ตัวจำแนกแบบสุ่มจะได้คะแนนต่ำกว่ามากในคลาสที่พบได้น้อย ให้เปรียบเทียบตัวชี้วัดรายคลาสระหว่างแบบจำลองจริงกับค่าพื้นฐานเสมอ เพื่อทำความเข้าใจว่าการปรับปรุงเกิดขึ้นจากจุดใด

from sklearn.dummy import DummyClassifier
from sklearn.metrics import classification_report
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
y_pred = dummy.predict(X_test)

print('DummyClassifier (most_frequent) on Iris:')
print(classification_report(y_test, y_pred,
      target_names=['setosa', 'versicolor', 'virginica']))
print('Notice: only the majority class has non-zero precision/recall')

ตัวจำแนกแบบกฎศูนย์: ค่าพื้นฐานที่ง่ายที่สุด

ตัวจำแนกที่ง่ายกว่า DummyClassifier คือกฎศูนย์ (Zero-Rule หรือ ZeroR) ซึ่งเป็นค่าพื้นฐานที่ใช้กันทั่วไปในการแข่งขันด้านวิทยาศาสตร์ข้อมูล สำหรับการจำแนกประเภท ZeroR จะทำนายคลาสส่วนใหญ่เสมอ ส่วนการถดถอยจะทำนายค่าเฉลี่ยเสมอ ZeroR แทนระดับต่ำสุดอย่างแท้จริงที่แบบจำลองทุกแบบต้องทำให้ดีกว่าจึงจะมีประโยชน์

หากคุณทำให้ดีกว่า ZeroR ไม่ได้ แสดงว่าคุณลักษณะของคุณไม่มีข้อมูลเกี่ยวกับตัวแปรเป้าหมาย การวินิจฉัยนี้ทำได้รวดเร็วและไม่เสียค่าใช้จ่ายในการคำนวณ และควรเป็นขั้นตอนแรกเสมอในโครงการ ML ใหม่ทุกโครงการ ก่อนใช้เวลากับแบบจำลองที่ซับซ้อน

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ZeroR: manually compute
majority_class = np.bincount(y_train).argmax()
y_pred_zeror = np.full(len(y_test), majority_class)

print(f'Majority class in training: {majority_class}')
print(f'ZeroR Accuracy: {accuracy_score(y_test, y_pred_zeror):.3f}')
print(f'ZeroR F1 (pos): {f1_score(y_test, y_pred_zeror):.3f}')

ค่าพื้นฐานแบบแบ็กกิงในโครงการ ML ของคุณ

เวิร์กโฟลว์การประเมินค่าฐานที่สมบูรณ์สำหรับโครงการ ML ใด ๆ:

คำนวณค่าฐานจาก DummyClassifier (most_frequent) หรือ DummyRegressor (mean)
หากมีระบบปัจจุบัน ให้คำนวณ ค่าฐานของระบบปัจจุบัน โดยใช้การพยากรณ์จากชุดทดสอบของคุณ
ค้นคว้า ประสิทธิภาพระดับมนุษย์ จากชุดข้อมูลมาตรฐานหรือเอกสารวิชาการ
ฝึกแบบจำลอง ML แบบง่ายแบบแรกของคุณ (การถดถอยโลจิสติกหรือต้นไม้ตัดสินใจแบบตื้น) แล้วเปรียบเทียบทั้งสามค่า
ดำเนินการต่อไปยังแบบจำลองที่ซับซ้อนก็ต่อเมื่อแบบจำลองแบบง่ายมีประสิทธิภาพสูงกว่าค่าฐานอย่างมีนัยสำคัญเท่านั้น — ความซับซ้อนควรมีเหตุผลรองรับจากการปรับปรุงที่วัดผลได้

from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer
import numpy as np

X, y = load_breast_cancer(return_X_y=True)

models = {
    'DummyClassifier': DummyClassifier(strategy='most_frequent'),
    'LogisticRegression': Pipeline([('sc', StandardScaler()), ('clf', LogisticRegression(max_iter=1000))]),
    'DecisionTree(d=5)': DecisionTreeClassifier(max_depth=5),
    'RandomForest': RandomForestClassifier(random_state=42),
}

for name, model in models.items():
    score = cross_val_score(model, X, y, cv=5, scoring='f1').mean()
    print(f'{name}: F1={score:.3f}')

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

ทดสอบความเข้าใจแนวคิดการเรียนรู้ของเครื่องด้วย Python จากบทเรียนนี้

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

ทบทวนบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า DummyClassifier กำหนดระดับประสิทธิภาพขั้นต่ำที่แบบจำลองจริงทุกแบบต้องทำให้สูงกว่าเพื่อสร้างคุณค่า, ค่าฐานจากความแม่นยำทำให้เข้าใจผิดสำหรับชุดข้อมูลที่มีสัดส่วนไม่สมดุล — ควรใช้ตัวชี้วัดเดียวกันเสมอในการเปรียบเทียบค่าฐานกับแบบจำลองจริง และ ค่าฐานที่สมบูรณ์ประกอบด้วยตัวจำแนกแบบพื้นฐาน ระบบที่ใช้งานจริงในปัจจุบัน และประสิทธิภาพระดับมนุษย์เมื่อมีข้อมูล บทถัดไปเราจะเริ่มหลักสูตรกระบวนการเตรียมข้อมูล โดยเริ่มจากวิธีจัดการค่าที่หายไปอย่างเป็นระบบด้วยเทคนิคการเติมค่า

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

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

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

คอร์ส: 30
บทเรียน: 120

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “แบบจำลองพื้นฐาน: ต้องดีกว่า DummyClassifier เสมอ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “แบบจำลองพื้นฐาน: ต้องดีกว่า DummyClassifier เสมอ”

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

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

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

บทเรียน “แบบจำลองพื้นฐาน: ต้องดีกว่า DummyClassifier เสมอ” ใช้เวลานานแค่ไหน

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

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

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

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

เหตุใดจึงประเมินผลด้วยข้อมูลฝึกไม่ได้
train_test_split: สัดส่วน เมล็ดสุ่ม และการแบ่งแบบแบ่งชั้น
ความแลกเปลี่ยนระหว่างอคติกับความแปรปรวน: การปรับไม่พอดีเทียบกับการปรับมากเกินไป
แบบจำลองพื้นฐาน: ต้องดีกว่า DummyClassifier เสมอ

← กลับไปที่ Machine Learning Academy