วิธีการทั้งมวล: เทคนิคที่หรูหราเพื่อสร้างผลลัพธ์การเรียนรู้ของเครื่องที่ดีขึ้น

วิธีการทั้งมวลเป็นเทคนิคที่สร้างแบบจำลองหลายแบบแล้วรวมเข้าด้วยกันเพื่อให้ได้ผลลัพธ์ที่ดีขึ้น วิธีการของ Ensemble มักจะให้ผลลัพธ์ที่แม่นยำกว่าแบบเดียว กรณีนี้เกิดขึ้นแล้วในการแข่งขันแมชชีนเลิร์นนิงหลายครั้ง ซึ่งโซลูชันที่ชนะใช้วิธีการทั้งมวล ในการแข่งขัน Netflix ที่ได้รับความนิยม ผู้ชนะใช้วิธีการรวมกลุ่มเพื่อใช้อัลกอริธึมการกรองการทำงานร่วมกันที่มีประสิทธิภาพ อีกตัวอย่างหนึ่งคือ KDD 2009 ซึ่งผู้ชนะใช้วิธีการทั้งมวล คุณยังสามารถหาผู้ชนะที่ใช้วิธีการเหล่านี้ในการแข่งขัน Kaggle ได้อีกด้วย ตัวอย่างเช่น นี่คือบทสัมภาษณ์ผู้ชนะการแข่งขัน CrowdFlower

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

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

วิธีการลงคะแนนและหาค่าเฉลี่ยตามวิธีการทั้งหมด

การลงคะแนนและการหาค่าเฉลี่ยเป็นวิธีการที่ง่ายที่สุดสองวิธี พวกเขาทั้งเข้าใจง่ายและนำไปใช้ การลงคะแนนใช้สำหรับการจำแนกประเภทและการใช้ค่าเฉลี่ยสำหรับการถดถอย

ในทั้งสองวิธี ขั้นตอนแรกคือการสร้างแบบจำลองการจัดหมวดหมู่/การถดถอยหลายตัวโดยใช้ชุดข้อมูลการฝึก โมเดลพื้นฐานแต่ละแบบสามารถสร้างขึ้นได้โดยใช้การแบ่งชุดข้อมูลการฝึกเดียวกันและอัลกอริทึมเดียวกัน หรือใช้ชุดข้อมูลเดียวกันกับอัลกอริธึมที่ต่างกัน หรือวิธีอื่นใด pseudocode แบบ Python-esque ต่อไปนี้แสดงการใช้ชุดข้อมูลการฝึกอบรมเดียวกันกับอัลกอริธึมที่ต่างกัน

 train = load_csv("train.csv") target = train["target"] train = train.drop("target") test = load_csv("test.csv") algorithms = [logistic_regression, decision_tree_classification, ...] #for classification algorithms = [linear_regression, decision_tree_regressor, ...] #for regression predictions = matrix(row_length=len(target), column_length=len(algorithms)) for i,algorithm in enumerate(algorithms): predictions[,i] = algorithm.fit(train, target).predict(test)

ตามรหัสเทียมด้านบน เราได้สร้างการคาดคะเนสำหรับแต่ละโมเดลและบันทึกไว้ในเมทริกซ์ที่เรียกว่าการคาดคะเน ซึ่งแต่ละคอลัมน์มีการคาดคะเนจากแบบจำลองเดียว

การลงคะแนนเสียงข้างมาก

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

โหวตแบบถ่วงน้ำหนัก

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

การหาค่าเฉลี่ยอย่างง่าย

ในวิธีการหาค่าเฉลี่ยอย่างง่าย สำหรับชุดข้อมูลทดสอบทุกชุด การคาดคะเนเฉลี่ยจะถูกคำนวณ วิธีนี้มักจะลดชุดที่ใส่มากเกินไปและสร้างแบบจำลองการถดถอยที่นุ่มนวลขึ้น รหัสเทียมต่อไปนี้แสดงวิธีการเฉลี่ยอย่างง่ายนี้:

 final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]) )

ค่าเฉลี่ยถ่วงน้ำหนัก

การถัวเฉลี่ยถ่วงน้ำหนักเป็นเวอร์ชันเฉลี่ยธรรมดาที่แก้ไขเล็กน้อย โดยที่การคาดการณ์ของแต่ละโมเดลจะถูกคูณด้วยน้ำหนัก จากนั้นจึงคำนวณค่าเฉลี่ย รหัสเทียมต่อไปนี้แสดงการถัวเฉลี่ยถ่วงน้ำหนัก:

 weights = [..., ..., ...] #length is equal to len(algorithms) final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]*weights) )

ซ้อนโมเดลการเรียนรู้ของเครื่องหลายตัว

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

pseudocode ของกระบวนการ stacking สรุปได้ดังนี้:

 base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): stacking_train_dataset[,i] = base_algorithm.fit(train, target).predict(train) stacking_test_dataset[,i] = base_algorithm.predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

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

 base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): for trainix, testix in split(train, k=10): #you may use sklearn.cross_validation.KFold of sklearn library stacking_train_dataset[testcv,i] = base_algorithm.fit(train[trainix], target[trainix]).predict(train[testix]) stacking_test_dataset[,i] = base_algorithm.fit(train).predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

Bootstrap การรวม

ชื่อ Bootstrap Aggregating หรือที่เรียกว่า "Bagging" สรุปองค์ประกอบหลักของกลยุทธ์นี้ ในอัลกอริทึมการบรรจุถุง ขั้นตอนแรกเกี่ยวข้องกับการสร้างแบบจำลองหลายแบบ โมเดลเหล่านี้สร้างขึ้นโดยใช้อัลกอริธึมเดียวกันกับตัวอย่างย่อยแบบสุ่มของชุดข้อมูลซึ่งดึงมาจากชุดข้อมูลดั้งเดิมแบบสุ่มด้วยวิธีสุ่มตัวอย่างบูตสแตรป ในการสุ่มตัวอย่างแบบบูตสแตรป ตัวอย่างดั้งเดิมบางตัวอย่างปรากฏขึ้นมากกว่าหนึ่งครั้ง และบางตัวอย่างดั้งเดิมไม่ปรากฏในตัวอย่าง หากคุณต้องการสร้างชุดข้อมูลย่อยที่มีองค์ประกอบ m คุณควรเลือกองค์ประกอบสุ่มจากชุดข้อมูลดั้งเดิม m ครั้ง และถ้าเป้าหมายกำลังสร้างชุดข้อมูล n คุณทำตามขั้นตอนนี้ n ครั้ง

ในตอนท้าย เรามีชุดข้อมูล n ชุด โดยที่จำนวนองค์ประกอบในแต่ละชุดข้อมูลคือ m pseudocode แบบ Python-esque ต่อไปนี้แสดงการสุ่มตัวอย่างบูตสแตรป:

 def bootstrap_sample(original_dataset, m): sub_dataset = [] for i in range(m): sub_dataset.append( random_one_element(original_dataset) ) return sub_dataset

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

รหัสเทียมโดยรวมมีลักษณะดังนี้:

 def bagging(n, m, base_algorithm, train_dataset, target, test_dataset): predictions = matrix(row_length=len(target), column_length=n) for i in range(n): sub_dataset = bootstrap_sample(train_dataset, m) predictions[,i] = base_algorithm.fit(original_dataset, target).predict(test_dataset) final_predictions = voting(predictions) # for classification final_predictions = averaging(predictions) # for regression return final_predictions

ในการบรรจุถุง ตัวอย่างย่อยแต่ละรายการสามารถสร้างขึ้นแยกจากกันได้ ดังนั้นการสร้างและการฝึกอบรมจึงสามารถทำได้ควบคู่กันไป

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

การส่งเสริม: การแปลงโมเดลที่อ่อนแอเป็นโมเดลที่แข็งแกร่ง

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

ขั้นตอนทั่วไปของอัลกอริธึมการบูสต์ถูกกำหนดดังนี้:

 def adjust_dataset(_train, errors): #create a new dataset by using the hardest instances ix = get_highest_errors_index(train) return concat(_train[ix], random_select(train)) models = [] _train = random_select(train) for i in range(n): #n rounds model = base_algorithm.fit(_train) predictions = model.predict(_train) models.append(model) errors = calculate_error(predictions) _train = adjust_dataset(_train, errors) final_predictions = combine(models, test)

ฟังก์ชัน adjust_dataset จะส่งกลับชุดข้อมูลใหม่ที่มีอินสแตนซ์ที่ยากที่สุด ซึ่งสามารถใช้เพื่อบังคับให้อัลกอริทึมพื้นฐานเรียนรู้ได้

Adaboost เป็นอัลกอริธึมที่รู้จักกันอย่างแพร่หลายซึ่งเป็นวิธีการส่งเสริม ผู้ก่อตั้ง Adaboost ได้รับรางวัล Godel Prize จากผลงานของพวกเขา ส่วนใหญ่ อัลกอริธึมแผนผังการตัดสินใจเป็นที่ต้องการเป็นอัลกอริธึมพื้นฐานสำหรับ Adaboost และในไลบรารี sklearn อัลกอริทึมพื้นฐานเริ่มต้นสำหรับ Adaboost คือแผนผังการตัดสินใจ (AdaBoostRegressor และ AdaBoostClassifier) ดังที่เราได้กล่าวไปแล้วในย่อหน้าก่อนหน้านี้ วิธีการที่เพิ่มขึ้นแบบเดียวกันนี้ใช้กับ Adaboost ข้อมูลที่รวบรวมในแต่ละขั้นตอนของอัลกอริธึม AdaBoost เกี่ยวกับ 'ความแข็ง' ของตัวอย่างการฝึกแต่ละรายการจะถูกป้อนเข้าในแบบจำลอง ขั้นตอน 'การปรับชุดข้อมูล' แตกต่างจากขั้นตอนที่อธิบายไว้ข้างต้น และขั้นตอน 'การรวมโมเดล' คำนวณโดยใช้การลงคะแนนแบบถ่วงน้ำหนัก

บทสรุป

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