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

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

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

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

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

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

เอกสารการออกแบบทางเทคนิคสำหรับแอปพลิเคชันมือถือ

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)

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

การโหวตเสียงข้างมาก

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

การลงคะแนนแบบถ่วงน้ำหนัก

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

ค่าเฉลี่ยอย่างง่าย

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

ฟังก์ชั่น c ++ อื่นที่ไม่ใช่ main ถูกดำเนินการ:

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 ของขั้นตอนการซ้อนสรุปได้ดังนี้:

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 ด้านบนชุดข้อมูลการฝึกอบรมสำหรับอัลกอริทึม Combiner ถูกสร้างขึ้นโดยใช้เอาต์พุตของอัลกอริทึมพื้นฐาน ใน 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): 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 โดยที่จำนวนองค์ประกอบในแต่ละชุดข้อมูลคือ m Python-esque pseudocode ต่อไปนี้แสดงการสุ่มตัวอย่าง bootstrap:

rtl-sdr . คืออะไร

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

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

pseudocode โดยรวมมีลักษณะดังนี้:

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 ใช้การเลือกคุณสมบัติแบบสุ่มและอัลกอริทึมพื้นฐานของมันคืออัลกอริธึมแผนผังการตัดสินใจ

ที่เกี่ยวข้อง: บทช่วยสอนการเรียนรู้เชิงลึก: จาก Perceptrons ไปจนถึง Deep Networks

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

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

ความแตกต่างระหว่างโหนด js และ javascript

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

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)

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

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

สรุป

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

ที่เกี่ยวข้อง:

• บทนำเกี่ยวกับทฤษฎีแมชชีนเลิร์นนิงและการประยุกต์ใช้: บทช่วยสอนแบบภาพพร้อมตัวอย่าง
• เครื่องจักรและความน่าเชื่อถือ: วิธีลดอคติของ AI