ตัวแยกประเภทป่าแบบสุ่ม: ภาพรวม มันทำงานอย่างไร ข้อดี & ข้อเสีย

คุณเคยสงสัยหรือไม่ว่า Netflix เลือกหนังมาแนะนำให้คุณได้อย่างไร? หรือวิธีที่ Amazon เลือกผลิตภัณฑ์ที่จะแสดงในฟีดของคุณ?

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

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

เราจะครอบคลุมข้อดีและข้อเสียของ sklearn สุ่มป่าและอื่น ๆ อีกมากมายในประเด็นต่อไปนี้

ลักษณนามสุ่มป่า: บทนำ

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

เหตุใดตัวจำแนกป่าสุ่มจึงเรียกว่าป่าสุ่ม

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

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

มันทำงานอย่างไร?

สมมติว่าชุดข้อมูลของคุณมีคุณสมบัติ "m" ฟอเรสต์สุ่มจะสุ่มเลือกคุณสมบัติ "k" โดยที่ k < m ตอนนี้ อัลกอริธึมจะคำนวณโหนดรูทระหว่างคุณลักษณะ k โดยเลือกโหนดที่มีการรับข้อมูลสูงสุด

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

มันเป็นหนึ่งในอัลกอริธึมที่ซับซ้อนที่สุดอย่างแน่นอน เนื่องจากมันสร้างขึ้นจากการทำงานของแผนผังการตัดสินใจ

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

การใช้งาน Python แบบสุ่มของฟอเรสต์นั้นง่ายกว่าและมีประสิทธิภาพมากกว่าอัลกอริธึมที่ไม่ใช่เชิงเส้นอื่น ๆ ที่ใช้สำหรับปัญหาการจำแนกประเภท

ตัวอย่างต่อไปนี้จะช่วยให้คุณเข้าใจว่าคุณใช้ตัวแยกประเภทฟอเรสต์แบบสุ่มในชีวิตประจำวันของคุณอย่างไร:

ตัวอย่าง

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

ที่นี่ Supratik ใช้วิธี Decision Tree เพื่อให้ข้อเสนอแนะตามคำตอบของคุณ หลังจากคำแนะนำของเขา คุณรู้สึกแย่กับคำแนะนำของเขา ดังนั้นคุณจึงถาม Aditya เกี่ยวกับคำแนะนำของเขา และเขาก็ถามคุณเกี่ยวกับความชอบและข้อกำหนดอื่นๆ ของคุณด้วย

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

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

ข้อดีและข้อเสียของตัวแยกประเภทป่าสุ่ม

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

ข้อดี

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

ข้อเสีย

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

ความแตกต่างระหว่างป่าสุ่มและต้นไม้แห่งการตัดสินใจ

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

ในทางกลับกัน ฟอเรสต์สุ่มใช้แผนผังการตัดสินใจหลายแบบ จึงเรียกว่า 'ฟอเรสต์' รวบรวมคะแนนโหวตจากแผนผังการตัดสินใจต่างๆ ที่ใช้ในการทำนายตามที่กำหนด

ดังนั้น ความแตกต่างหลักระหว่างตัวแยกประเภทฟอเรสต์แบบสุ่มและแผนผังการตัดสินใจก็คือ แบบแรกใช้คอลเล็กชันของแบบหลัง นี่คือความแตกต่างเพิ่มเติมระหว่างสองสิ่งนี้:

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

การสร้างอัลกอริทึม (สุ่ม Forest Sklearn)

ในตัวอย่างต่อไปนี้ เราได้ดำเนินการสุ่มนำ Python ฟอเรสต์ไปใช้งานโดยใช้ไลบรารี scikit-learn คุณสามารถทำตามขั้นตอนของบทช่วยสอนนี้เพื่อสร้างตัวแยกประเภทฟอเรสต์แบบสุ่มของคุณเอง

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

ขั้นตอนแรก: นำเข้าไลบรารีและโหลดชุดข้อมูล

ขั้นแรก เราจะต้องนำเข้าไลบรารีที่จำเป็นและโหลดชุดข้อมูลของเราลงในกรอบข้อมูล

ป้อนข้อมูล:

#การนำเข้าห้องสมุดที่จำเป็น

นำเข้าแพนด้าเป็น pd

นำเข้า numpy เป็น np

นำเข้า matplotlib.pyplot เป็น plt

#การนำเข้าชุดข้อมูล

จาก sklearn.datasets นำเข้า load_iris
ชุดข้อมูล = load_iris ()

ขั้นตอนที่สอง: แยกชุดข้อมูลออกเป็นชุดการฝึกและชุดทดสอบ

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

ป้อนข้อมูล:

#ใส่ลักษณนามให้เข้ากับชุดฝึก

จาก sklearn.tree นำเข้า DecisionTreeClassifier

model = DecisionTreeClassifier(เกณฑ์ = 'entropy' , splitter = 'best' , random_state = 0)

model.fit(X_train, y_train)

เอาท์พุท:

DecisionTreeClassifier(class_weight=None, criterion='entropy' , max_depth=None,
max_features=ไม่มี, max_leaf_nodes=ไม่มี,
min_impurity_decrease=0.0, min_impurity_split=ไม่มี,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, presort=False, random_state=0,

splitter='ดีที่สุด')

ขั้นตอนที่สาม: สร้างตัวแยกประเภทฟอเรสต์แบบสุ่ม

ตอนนี้ เราจะสร้างตัวแยกประเภทฟอเรสต์แบบสุ่มโดยใช้ Python และ scikit-learn

ป้อนข้อมูล:

#การประกอบลักษณนามเข้ากับชุดฝึก

จาก sklearn.ensemble นำเข้า RandomForestClassifier

model = RandomForestClassifier(n_estimators=100, เกณฑ์-'เอนโทรปี', random_state = 0)

model.fit(X_train, y_train)

เอาท์พุท:

RandomForestClassifier (bootstrap=True, class_weight=None, เกณฑ์='เอนโทรปี',

max_deep=ไม่มี, max_features='auto', max_leaf_nodes=None,

min_impurity_decrease=0.0, min_impurity_split=ไม่มี,

min_samples_leaf=1, min_sampes_split=2,

min_weight_fraction_leaf=0.0, n_estimators=100, n_jobs=ไม่มี,

oob_score=เท็จ random_state=0, verbose=0, warm_start=False)

ขั้นตอนที่สี่: ทำนายผลลัพธ์และสร้างเมทริกซ์ความสับสน

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

ป้อนข้อมูล:

#ทำนายผลชุดทดสอบ

y_pred = mode.predict(X_test)

#สร้างเมทริกซ์ความสับสน

จาก sklearn.metrics นำเข้าสับสน_matrix

cm = ความสับสน_เมทริกซ์ (y_test, y_pred)

ซม

เอาท์พุต :

อาร์เรย์ ([[16, 0, 0]

[0, 17, 1]

[0, 0, 11]])

อินพุต :

#รับคะแนนสำหรับนางแบบของคุณ

model.score(X_test, y_test)

เอาท์พุต :

0.9777777777777777

บทสรุป

ตัวแยกประเภทฟอเรสต์สุ่มมีการใช้งานมากมาย พวกเขาเป็นหนึ่งในอัลกอริธึมการเรียนรู้ของเครื่องที่แข็งแกร่งที่สุดและเป็นสิ่งที่ต้องมีใน AI และ ML มืออาชีพ

หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับปัญญาประดิษฐ์ โปรดดูโปรแกรม Executive PG ของ IIIT-B และ upGrad ในการเรียนรู้ของเครื่องและ AI ซึ่งออกแบบมาสำหรับมืออาชีพที่ทำงานและมีการฝึกอบรมที่เข้มงวดมากกว่า 450 ชั่วโมง กรณีศึกษาและการมอบหมายมากกว่า 30 รายการ IIIT -B สถานะศิษย์เก่า 5+ โครงการหลักที่ใช้งานได้จริง & ความช่วยเหลืองานกับ บริษัท ชั้นนำ