LightGBM: การเติบโตแบบใบและข้อได้เปรียบด้านความเร็ว
ผู้เรียนจะเปรียบเทียบประสิทธิภาพของ LightGBM กับ XGBoost บนชุดข้อมูลขนาดใหญ่ เข้าใจการเติบโตของต้นไม้แบบใบเทียบกับแบบระดับ และใช้การรองรับคุณลักษณะเชิงกลุ่ม
LightGBM: การเติบโตแบบใบและข้อได้เปรียบด้านความเร็ว เป็นบทเรียน Machine Learning Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Machine Learning Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน
LightGBM คืออะไร
LightGBM (Light Gradient Boosting Machine) เป็นไลบรารี gradient boosting ที่ Microsoft พัฒนาขึ้นในปี 2017 โดยออกแบบมาเพื่อแก้ข้อจำกัดด้านความเร็วและหน่วยความจำของ XGBoost เมื่อทำงานกับชุดข้อมูลขนาดใหญ่ LightGBM นำนวัตกรรมด้านอัลกอริทึมที่สำคัญสองประการมาใช้ ได้แก่ Gradient-based One-Side Sampling (GOSS) เพื่อลดจำนวนอินสแตนซ์ข้อมูลที่นำมาพิจารณาในแต่ละรอบ และ Exclusive Feature Bundling (EFB) เพื่อลดจำนวนคุณลักษณะด้วยการรวมคุณลักษณะแบบกระจัดกระจายที่ไม่เกิดร่วมกันเข้าด้วยกัน เมื่อนำมารวมกัน นวัตกรรมเหล่านี้ทำให้ LightGBM เร็วกว่า XGBoost อย่างมากเมื่อทำงานกับชุดข้อมูลแบบตารางขนาดใหญ่
การเติบโตของต้นไม้แบบระดับเทียบกับแบบใบ
การใช้งาน gradient boosting ส่วนใหญ่ (รวมถึง XGBoost ในค่าเริ่มต้น) จะสร้างต้นไม้แบบ ระดับ: โหนดทั้งหมดที่ความลึก 1 จะถูกแบ่งก่อนโหนดใด ๆ ที่ความลึก 2 วิธีนี้ทำให้ต้นไม้สมดุล แต่สิ้นเปลืองการคำนวณกับการแบ่งที่ลดค่าความสูญเสียได้เพียงเล็กน้อย LightGBM สร้างต้นไม้แบบ ใบ: ในแต่ละขั้นตอน จะค้นหา ใบเดียว ทั่วทั้งต้นไม้ที่หากแบ่งแล้วจะลดค่าความสูญเสียได้มากที่สุด โดยไม่คำนึงถึงระดับความลึก จากนั้นจึงแบ่งใบนั้น ผลลัพธ์คือต้นไม้ที่ไม่สมดุล แต่ลดค่าความสูญเสียต่อการแบ่งได้เร็วกว่า จึงใช้การแบ่งน้อยครั้งกว่าเพื่อให้ได้ความแม่นยำเท่ากัน
ความเสี่ยงของการเรียนรู้เกินจากการเติบโตแบบใบ
การเติบโตแบบใบอาจทำให้เกิดการเรียนรู้เกินกับชุดข้อมูลขนาดเล็ก เพราะมุ่งลดค่าความสูญเสียที่มากที่สุดอย่างเข้มข้น จนอาจจดจำตัวอย่างแต่ละรายการไว้ในใบที่ลึกมาก วิธีแก้คือพารามิเตอร์ num_leaves (จำนวนใบทั้งหมดสูงสุดในต้นไม้หนึ่งต้น) การกำหนด num_leaves อย่างเหมาะสมจะจำกัดความซับซ้อนของต้นไม้ได้แม่นยำกว่าการใช้ max_depth เพียงอย่างเดียว กฎโดยประมาณที่ใช้กันทั่วไปคือ num_leaves = 2^(max_depth) / 2 หากเทียบเท่ากับ max_depth เท่ากับ 6 ให้ลองใช้ num_leaves ประมาณ 32-50
import lightgbm as lgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
for nl in [8, 16, 31, 64, 128]:
model = lgb.LGBMClassifier(n_estimators=100, num_leaves=nl, learning_rate=0.1,
random_state=42, verbose=-1)
score = cross_val_score(model, X, y, cv=5).mean()
print(f'num_leaves={nl:4d}: CV accuracy={score:.4f}')การติดตั้งและการใช้งาน LightGBM เบื้องต้น
ติดตั้ง LightGBM ได้ด้วย pip install lightgbm เช่นเดียวกับ XGBoost ไลบรารีนี้มี API ที่เข้ากันได้กับ scikit-learn ผ่าน LGBMClassifier และ LGBMRegressor กำหนด verbose=-1 เพื่อระงับผลลัพธ์การฝึก (โดยค่าเริ่มต้น LightGBM จะแสดงข้อมูลจำนวนมาก) ไฮเปอร์พารามิเตอร์หลักคล้ายกับของ XGBoost ได้แก่ n_estimators, learning_rate, num_leaves (ใช้แทน max_depth) และ subsample
# Install: pip install lightgbm
import lightgbm as lgb
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)
model = lgb.LGBMClassifier(
n_estimators=200,
learning_rate=0.05,
num_leaves=31,
random_state=42,
verbose=-1
)
model.fit(X_train, y_train)
print('LightGBM test accuracy:', model.score(X_test, y_test))การวัดประสิทธิภาพด้านความเร็ว: LightGBM เทียบกับ XGBoost
โดยทั่วไป LightGBM เร็วกว่า XGBoost 5-10 เท่าเมื่อทำงานกับชุดข้อมูลขนาดใหญ่ ขณะเดียวกันก็ให้ความแม่นยำใกล้เคียงกันหรือดีกว่า ข้อได้เปรียบด้านความเร็วเกิดจาก: (1) การค้นหาจุดแบ่งด้วยฮิสโตแกรม (จัดกลุ่มค่าคุณลักษณะแบบต่อเนื่องเป็นช่วงไม่ต่อเนื่อง ลดการคำนวณจุดแบ่งที่เป็นไปได้จาก O(n) เป็น O(bins)); (2) การเติบโตแบบใบ (ต้องใช้การแบ่งน้อยกว่า); (3) GOSS (ฝึกจากตัวอย่างที่มีเกรเดียนต์สูงและตัวอย่างที่มีเกรเดียนต์ต่ำซึ่งสุ่มเลือกมาเท่านั้น) ข้อได้เปรียบด้านความเร็วจะเห็นได้ชัดที่สุดกับชุดข้อมูลที่มีมากกว่า 100,000 แถว หรือมากกว่า 1,000 คุณลักษณะ
import lightgbm as lgb
import xgboost as xgb
from sklearn.datasets import fetch_california_housing
import time, numpy as np
X, y = fetch_california_housing(return_X_y=True)
lgb_model = lgb.LGBMRegressor(n_estimators=300, verbose=-1, random_state=42)
xgb_model = xgb.XGBRegressor(n_estimators=300, eval_metric='rmse', verbosity=0, random_state=42)
for name, m in [('LightGBM', lgb_model), ('XGBoost', xgb_model)]:
start = time.time()
m.fit(X, y)
print(f'{name}: {round(time.time()-start, 2)}s')การรองรับคุณลักษณะเชิงหมวดหมู่
ข้อได้เปรียบเชิงปฏิบัติที่สำคัญประการหนึ่งของ LightGBM คือ การรองรับคุณลักษณะเชิงหมวดหมู่โดยตรง แทนที่จะต้องเข้ารหัสแบบ one-hot คุณสามารถส่งดัชนีคอลัมน์เชิงหมวดหมู่ให้กับพารามิเตอร์ categorical_feature ได้ LightGBM จะเรียนรู้จุดแบ่งที่เหมาะสมโดยทดสอบการจัดกลุ่มหมวดหมู่ทั้งหมด ซึ่งแสดงความสัมพันธ์ได้มากกว่าการแบ่งแบบ one-hot ทวิภาค และหลีกเลี่ยงการเพิ่มขึ้นอย่างมากของจำนวนคุณลักษณะจากการเข้ารหัส one-hot เมื่อคุณลักษณะมีหมวดหมู่นับร้อย วิธีนี้มีประโยชน์อย่างยิ่งกับชุดข้อมูลอีคอมเมิร์ซที่มีรหัสสินค้า หรือรหัสสถานที่
import lightgbm as lgb
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
np.random.seed(42)
n = 1000
df = pd.DataFrame({'color': np.random.choice(['red', 'blue', 'green'], n),
'size': np.random.randint(1, 10, n),
'label': np.random.randint(0, 2, n)})
df['color'] = df['color'].astype('category')
X, y = df[['color', 'size']], df['label']
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2)
model = lgb.LGBMClassifier(n_estimators=50, verbose=-1)
model.fit(X_tr, y_tr, categorical_feature=['color'])
print('Accuracy with native categoricals:', round(model.score(X_te, y_te), 4))การหยุดก่อนกำหนดใน LightGBM
LightGBM รองรับการหยุดก่อนกำหนดผ่าน callback โดยส่ง callback early_stopping พร้อมจำนวนรอบที่ยอมให้ไม่ดีขึ้น และ callback log_evaluation เพื่อควบคุมรายละเอียดที่แสดง โมเดลในสถานะที่ดีที่สุด (best_iteration_) จะถูกนำไปใช้สำหรับการทำนายโดยอัตโนมัติ เช่นเดียวกับ XGBoost วิธีนี้ทำให้คุณกำหนด n_estimators ไว้สูงมากได้ แล้วปล่อยให้การหยุดก่อนกำหนดค้นหาจุดที่เหมาะสมโดยไม่เกิดการเรียนรู้เกิน
import lightgbm as lgb
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_tr, X_val, y_tr, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
model = lgb.LGBMClassifier(n_estimators=1000, learning_rate=0.05, num_leaves=31, random_state=42)
model.fit(X_tr, y_tr,
eval_set=[(X_val, y_val)],
callbacks=[lgb.early_stopping(stopping_rounds=20), lgb.log_evaluation(0)])
print('Best iteration:', model.best_iteration_)
print('Val accuracy:', round(model.score(X_val, y_val), 4))ไฮเปอร์พารามิเตอร์สำคัญใน LightGBM
ไฮเปอร์พารามิเตอร์ที่สำคัญที่สุดของ LightGBM ได้แก่ num_leaves (ควบคุมความซับซ้อนและเป็นกลไกหลักในการทำให้เป็นปกติ), learning_rate (ยิ่งต่ำยิ่งต้องใช้ต้นไม้มากขึ้น แต่ทำให้โมเดลใช้งานกับข้อมูลใหม่ได้ดีขึ้น), min_child_samples (จำนวนตัวอย่างขั้นต่ำต่อใบ ควรเพิ่มขึ้นเมื่อใช้ num_leaves เพื่อป้องกันการเรียนรู้เกิน), subsample และ colsample_bytree (การทำให้เป็นปกติแบบสุ่ม) และ reg_alpha/reg_lambda (บทลงโทษแบบ L1/L2) ให้เริ่มจากค่าเริ่มต้น แล้วปรับ num_leaves และ min_child_samples ก่อน
LightGBM สำหรับการถดถอย
LGBMRegressor ทำงานสำหรับงานถดถอยในลักษณะเดียวกัน โดยรองรับฟังก์ชันสูญเสียหลายรูปแบบผ่านพารามิเตอร์ objective: 'regression' (L2), 'regression_l1' (MAE), 'huber' (ทนต่อค่าผิดปกติ) และ 'quantile' (สำหรับช่วงการทำนาย) การถดถอยแบบ quantile ด้วย LightGBM มีประโยชน์อย่างยิ่งในระบบใช้งานจริง โดยฝึกโมเดลหนึ่งสำหรับเปอร์เซ็นไทล์ที่ 10 และอีกโมเดลสำหรับเปอร์เซ็นไทล์ที่ 90 เพื่อสร้างขอบเขตความไม่แน่นอนที่ปรับเทียบแล้วรอบค่าทำนาย
import lightgbm as lgb
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
model = lgb.LGBMRegressor(n_estimators=300, learning_rate=0.05, num_leaves=31,
verbose=-1, random_state=42)
rmse = np.sqrt(-cross_val_score(model, X, y, scoring='neg_mean_squared_error', cv=3).mean())
print('LightGBM Regression RMSE:', round(rmse, 4))การเลือกระหว่าง XGBoost กับ LightGBM
ทั้ง XGBoost และ LightGBM ต่างก็ยอดเยี่ยม แนวทางเชิงปฏิบัติคือ ให้ใช้ LightGBM เมื่อชุดข้อมูลมีขนาดใหญ่ (มากกว่า 100K แถว) ต้องการทดลองและปรับปรุงอย่างรวดเร็ว หรือมีคุณลักษณะเชิงหมวดหมู่ที่มีจำนวนหมวดหมู่สูง ให้ใช้ XGBoost เมื่อชุดข้อมูลมีขนาดเล็กถึงปานกลาง ต้องการการเติบโตแบบระดับที่ระมัดระวังมากกว่าและเกิดการเรียนรู้เกินได้ยากกับข้อมูลที่มีสัญญาณรบกวน หรือทีมมีประสบการณ์กับ XGBoost อยู่แล้ว ในการแข่งขัน มักทดลองใช้ทั้งสองแบบ แล้วเลือกแบบที่ทำงานได้ดีกว่าบนชุดตรวจสอบ CatBoost เป็นอีกทางเลือกที่แข็งแกร่ง และจัดการคุณลักษณะเชิงหมวดหมู่ได้ดียิ่งขึ้น
ความสำคัญของคุณลักษณะใน LightGBM
เช่นเดียวกับ XGBoost LightGBM มีความสำคัญของคุณลักษณะที่เข้าถึงได้ผ่าน model.feature_importances_ (ใช้จำนวนครั้งที่แบ่งเป็นค่าเริ่มต้นใน API ของ sklearn) หรือ model.booster_.feature_importance(importance_type='gain') โดยทั่วไปประเภท gain ให้ข้อมูลมากกว่า เพราะวัดการปรับปรุงค่าเฉลี่ยของความสูญเสียต่อการแบ่งที่ใช้คุณลักษณะนั้น LightGBM ยังรองรับค่า SHAP สำหรับการอธิบายโมเดลโดยไม่ขึ้นกับโมเดล ผ่าน model.predict(X, pred_contrib=True) ใน API ดั้งเดิม ซึ่งให้ค่าการมีส่วนร่วมของคุณลักษณะในระดับละเอียดสำหรับการทำนายแต่ละรายการ
import lightgbm as lgb
import pandas as pd
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
X, y = data.data, data.target
model = lgb.LGBMClassifier(n_estimators=100, verbose=-1, random_state=42)
model.fit(X, y)
importances = pd.Series(model.feature_importances_, index=data.feature_names)
print(importances.sort_values(ascending=False).head(5))ตรวจสอบความเข้าใจอย่างรวดเร็ว
ทดสอบความเข้าใจเกี่ยวกับกลยุทธ์การเติบโตของ LightGBM จากบทเรียนนี้
สรุปบทเรียน
ในบทเรียนนี้ คุณได้เรียนรู้ว่า การเติบโตแบบใบของ LightGBM จะค้นหาใบเดียวที่ดีที่สุดเพื่อแบ่งในแต่ละรอบ ทำให้ลู่เข้าได้เร็วกว่าแบบระดับ num_leaves เป็นตัวควบคุมความซับซ้อนหลักที่ใช้แทน max_depth และ การรองรับคุณลักษณะเชิงหมวดหมู่โดยตรงของ LightGBM ช่วยหลีกเลี่ยงต้นทุนจากการเข้ารหัส one-hot บทถัดไปเราจะสำรวจไฮเปอร์พารามิเตอร์สำคัญอย่าง learning rate, n_estimators และ max_depth โดยละเอียด
เรียนรู้ Python ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 30
- บทเรียน
- 120
คำถามที่พบบ่อย
บทเรียน “LightGBM: การเติบโตแบบใบและข้อได้เปรียบด้านความเร็ว” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “LightGBM: การเติบโตแบบใบและข้อได้เปรียบด้านความเร็ว” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Machine Learning Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “LightGBM: การเติบโตแบบใบและข้อได้เปรียบด้านความเร็ว”
ผู้เรียนจะเปรียบเทียบประสิทธิภาพของ LightGBM กับ XGBoost บนชุดข้อมูลขนาดใหญ่ เข้าใจการเติบโตของต้นไม้แบบใบเทียบกับแบบระดับ และใช้การรองรับคุณลักษณะเชิงกลุ่ม คุณปฏิบัติ Machine Learning Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Machine Learning Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Machine Learning Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “LightGBM: การเติบโตแบบใบและข้อได้เปรียบด้านความเร็ว” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Machine Learning Academy นี้ได้ไหม
ได้ บทเรียน Machine Learning Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- สัญชาตญาณของการบูสต์: การแก้ไขค่าคลาดเคลื่อนตามลำดับ
- XGBoost: การทำให้เป็นระเบียบ การหยุดก่อนกำหนด และความสำคัญของคุณลักษณะ
- LightGBM: การเติบโตแบบใบและข้อได้เปรียบด้านความเร็ว
- พารามิเตอร์ไฮเปอร์ที่สำคัญ: อัตราการเรียนรู้ n_estimators และ max_depth