หลาย ๆ คนที่อยู่ในวงการ Data Science น่าจะเคยได้ยินชื่อ Kaggle มาบ้างแล้วนะครับ
Kaggle คือ การแข่งขันทำโจทย์ทางด้าน Data Science ที่คนทั่วโลกต่างเข้ามาแข่งขันกันผ่าน https://www.kaggle.com ซึ่งในปัจจุบันนี้ ผู้เข้าแข่งขันส่วนใหญ่ใน Kaggle ต่างพัฒนาฝีมือในการแข่งขันของตนเองมาอย่างหลากหลายรูปแบบ และหนึ่งในเทคนิคที่ใช้กันอย่างแพร่หลายมากที่สุดก็คือ เทคนิคการ Ensemble ซึ่งเป็นวิธีการในทำ Machine Learning ที่ทำการรวมหลายๆ โมเดลเข้าด้วยกัน เพื่อที่จะทำให้โมเดลมีประสิทธิภาพสูงขึ้นและสามารถทำนายผลได้แม่นยำมากขึ้น ตัวอย่างของโมเดล Ensemble ได้แก่ Random Forest, AdaBoost และ XGBoost เป็นต้น
ในการแข่งขัน Kaggle ในเดือนมีนาคม ปี ค.ศ. 2012 เพื่อทำนายราคาพันธบัตรนั้น ผู้เข้าแข่งขัน Kaggle 2 คนชื่อ Rie Johnson และ Tong Zhang ได้คิดนำเสนอ Algorithm ที่มีชื่อว่า Regularized Greedy Forest (RGF) ซึ่งทำให้พวกเขาได้อันดับที่ 1 ในการแข่งขันครั้งนั้น โดยมีคะแนนที่ค่อนข้างต่างกับอันดับที่ 2 อย่างเห็นได้ชัด
ดังนั้น วันนี้เราจะมาเล่าถึง Algorithm RGF นี้ให้ฟัง โดยอิงมาจาก Paper ของ Rie และ Tong ในหัวข้อ “Learning Nonlinear Function Using Regularized Greedy Forest” เพื่อให้เพื่อน ๆ ที่สนใจได้มีโอกาสลองนำ Algorithm นี้ไปใช้แข่งขันหรือประยุกต์ใช้กับการทำงานในชีวิตประจำวันกัน
Paper นี้อธิบายถึงหลักการของ RGF และการที่ RGF เข้ามาช่วยแก้ไขข้อจำกัดของ Gradient Boosted Decision Tree (GBDT) นอกจากนี้ในช่วงสุดท้ายของ Paper พวกเขายังได้นำเสนอตัวอย่างในการนำ RGF ไปประยุกต์ใช้งานจริงอีกด้วย
โดยหลักการของ RGF นั้น คือ มันจะทำการสร้าง Decision Forest (ดังภาพ 3) ซึ่งเกิดจากการ Ensemble ของ Decision Trees หรือฟังก์ชันพื้นฐาน จำนวน k trees (T1, T2, …, TK) ประกอบกับการใช้ Greedy Method และ Explicit Regularization เข้ามาช่วย
ก่อนอื่น เรามารู้จัก GBDT ซึ่งเป็นเทคนิคที่ RGF อิงตามกันก่อน GBDT นั้นจะทำการสร้างโมเดลที่มีความสามารถในการทำนายอีกรูปแบบหนึ่ง โดยอาศัยหลักการ Ensemble แบบ Boosting ของโมเดล Base หรือ ฟังก์ชันพื้นฐานดังภาพ (ใครสนใจอ่านเพิ่มเติมเกี่ยวกับ GBDT อ่านได้ที่นี่)
แต่อย่างไรก็ดี Rie และ Tong ได้สังเกตเห็นถึงข้อจำกัดของ GBDT ดังนี้
- GBDT ไม่มีตัว Regularization ที่ชัดเจน โดยมีการตั้งสมมติฐานว่า จำนวน Node ในแต่ละ Tree เป็นตัว Regularization
- GBDT จำเป็นต้องใช้ค่า Shrinkage Parameter หรือ Learning Rate ที่เล็กมากๆ เพื่อให้ได้ผลลัพธ์ของโมเดลที่ดี ทำให้เปลือง Computational Power ในการรันโมเดลค่อนข้างมาก
- GBDT เป็นโมเดลแบบ Black Box ซึ่งไม่สามารถอธิบายให้เข้าใจหลักการทำงานภายในได้
ข้อจำกัดเหล่านี้สามารถถูกกำจัดไป เมื่อเราใช้ RGF เนื่องจาก RGF ใช้วิธีการแบบ Greedy ทำให้เราไม่ต้องลดค่า Shrinkage Parameter ให้น้อยมากซึ่งเป็นเหตุทำให้โมเดลมีขนาดใหญ่ และเปลือง Computational Power อย่างมาก แต่อย่างไรก็ตาม วิธีการแบบ Greedy จะทำให้เกิดปัญหา Overfitting ซึ่งสามารถถูกแก้ไขด้วยวิธีการ Explicit Regularization ใน RBF นั่นเอง
สมการฟังก์ชัน Regularized Loss ของ RBF จึงสามารถเขียนได้ดังนี้
โดยที่ Q = ฟังก์ชัน Regularized Loss ซึ่งเป็นฟังก์ชันของ Decision Forest; h() = โมเดล Decision Forest; X = ค่า Input ของโมเดล; h(X) = ค่าทำนายจาก Decision Forest; Y = ผลเฉลยที่แท้จริง; L() = ฟังก์ชัน Loss; R() = ฟังก์ชัน Regularized (ในที่นี้ใช้ L2 Regularization เป็นหนึ่งในตัวอย่าง)
เป้าหมายของ Algorithm นี้ คือ การสร้าง Forest ซึ่งทำให้ค่า Q มีค่าต่ำที่สุด และเนื่องจากการหาผลเฉลยที่ดีที่สุดนั้นสามารถทำได้ยาก เราจึงเลือกฟังก์ชันพื้นฐานและ Weights ที่ดีที่สุดด้วยวิธีการแบบ Greedy อธิบายโดยง่าย Algorithm ของ RGF ประกอบไปด้วย 2 ส่วนหลัก ๆ (ดูตัวอย่างได้จากภาพ 5)
1. คงที่ค่า Weights และปรับโครงสร้างของ Forest เพื่อให้ค่า Q ลดลงมากที่สุด
2. คงที่โครงสร้างของ Forest และปรับ Weights เพื่อทำให้ Q มีค่าต่ำที่สุด
RGF จะทำงานวนไปจนกระทั้งได้ผลลัพธ์ที่ทำให้ค่าฟังก์ชัน Regularized Loss มีค่าน้อยที่สุด หรือจนกว่าเราจะพอใจ
ในส่วนของการนำไปใช้นั้นเราสามารถใช้ได้เหมือนใน Format Sklearn โดยทำการ Pip Install rgf_python ตามบรรทัดด้านล่าง
pip install rgf_pythonจากนั้นก็สามารถนำไปใช้งานได้ตามปกติ ดังตัวอย่างด้านล่างนี้
from sklearn import datasets
from sklearn.utils.validation import check_random_state
from sklearn.model_selection import StratifiedKFold, cross_val_score
from rgf.sklearn import RGFClassifieriris = datasets.load_iris()
rng = check_random_state(0)
perm = rng.permutation(iris.target.size)
iris.data = iris.data[perm]
iris.target = iris.target[perm]rgf = RGFClassifier(max_leaf=400,
algorithm="RGF_Sib",
loss='LS',
verbose=True)
rgf.fit(iris.data,iris.target)
score_proba = rgf.predict_proba(iris.data)
โดยชุดคำสั่งต่าง ๆ นั้นจะมีความคล้าย Sklearn Libary เช่น Predict, Predict_Proba, Fit เป็นต้น
สรุป
ในส่วนข้อแตกต่างสำคัญของ RGF กับ Random Forest คือ RGF จะมี Weights ในแต่ละ Leaf ทำให้ลด Loss ได้เร็วแต่แลกมากับความเสี่ยงที่จะเกิด Overfitting
ถึงแม้ RGF จะมีการใช้งานมานานกว่า 7 ปีแล้วแต่ก็ยังคงสามารถทำงานได้ดี เวลานำมา Ensemble กับ LightGBM , XGBoost หรือ Random Forest เป็นเพราะว่าการทำงานของโมเดลที่เป็นเอกลักษณ์นั้นเอง
จากที่อ่าน Paper สามารถสรุปข้อดีและข้อเสียของ RGF ได้ ดังนี้
ข้อดี
- RGF เป็น Algorithm ที่สนใจโครงสร้างของ Forest เนื่อจากมีการอัพเดต Weights ของ Tree ตลอดเวลา ซึ่งส่งผลให้โมเดลมีเอกลักษณ์แตกต่างจากโมเดลอื่น ทำให้เราสามารถนำไป Ensemble กับโมเดลอื่นได้ดี และเพิ่มความแม่นยำของผลลัพธ์
- โมเดลของ RGF มีขนาดเล็กลง เมื่อเทียบกับ GBDT ทำให้ทำงานได้รวดเร็วมากขึ้น ใช้เวลาในการรันน้อยลง
ข้อเสีย
- ยังคงมีโอกาสเกิด Overfitting ได้ง่าย เพราะโมเดลมีการใส่ Weights ในทุก Tree
หลังจากที่ Paper นี้ออกมา Tianqi Chen และ Carlos Guestrin ได้นำแนวคิดของ RGF ไปพัฒนาต่อจนกลายเป็น XGBoost ที่หลาย ๆ คนรู้จักกันนี่เอง
สำหรับเพื่อน ๆ ที่สนใจโมเดล RGF สามารถนำไปประยุกต์ใช้กับข้อมูลทั่วไปได้ ถือเป็นอีกทางเลือกหนึ่งสำหรับคนที่ใช้ Decision Tree Model ในการทดลอง Algorithm ใหม่ๆ
