คู่มือขั้นสุดท้ายสำหรับอัลกอริทึมฟอเรสต์แบบสุ่มด้วย Python และ Scikit-Learn

บทนำ

อัลกอริทึม Random Forest เป็นหนึ่งในอัลกอริทึมที่ยืดหยุ่น ทรงพลัง และใช้กันอย่างแพร่หลายสำหรับ การจำแนกประเภทและการถดถอย, สร้างเป็น กลุ่มของต้นไม้แห่งการตัดสินใจ.

หากคุณไม่คุ้นเคยกับสิ่งเหล่านี้ ไม่ต้องกังวล เราจะครอบคลุมแนวคิดเหล่านี้ทั้งหมด

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

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

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

ต้นไม้แห่งการตัดสินใจ

คุณจะเติมโหนดของต้นไม้ได้อย่างไร? นี่คือที่ ต้นไม้ตัดสินใจ เข้ามาโฟกัส

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

ด้านล่างนี้เป็นตัวอย่างของต้นไม้ที่ได้รับการอธิบาย:

ในภาพต้นไม้ มี 7 สี่เหลี่ยม สี่เหลี่ยมด้านบนที่มีผู้หญิงทั้งหมด 100 คน สี่เหลี่ยมด้านบนนี้เชื่อมต่อกับสองสี่เหลี่ยมด้านล่าง ซึ่งแบ่งผู้หญิงตามจำนวน 78 คนที่ไม่ตั้งครรภ์และ 22 คนที่กำลังตั้งครรภ์ และ จากช่องสี่เหลี่ยมก่อนหน้าทั้งสองมีสี่ช่อง ทั้งสองเชื่อมต่อกับแต่ละตารางด้านบนที่แบ่งผู้หญิงตามพื้นที่ของพวกเขา สำหรับผู้ที่ไม่ตั้งครรภ์ 45 คนอาศัยอยู่ในเขตเมือง 33 คนอยู่ในเขตชนบท และสำหรับคนท้อง 14 คนอาศัยอยู่ในเขตชนบท และ 8 คนอยู่ในเขตเมือง เพียงแค่ดูที่ต้นไม้ มันก็ง่ายที่จะเข้าใจการแบ่งส่วนเหล่านั้น และดูว่าแต่ละ "เลเยอร์" มาจากอันก่อนหน้าได้อย่างไร เลเยอร์เหล่านั้นคือต้นไม้ ระดับระดับอธิบายถึง ความลึก ของต้นไม้:

สังเกตจากภาพด้านบนว่าต้นไม้ระดับแรกคืออะไร ระดับ 0 ที่มีเพียงตารางเดียวรองลงมา ระดับ 1 ที่มีสองสี่เหลี่ยมและ ระดับ 2 ซึ่งมีสี่ช่องสี่เหลี่ยม มันคือ ความลึก 2 ต้นไม้.

ในระดับ 0 คือช่องสี่เหลี่ยมที่เกิดต้นไม้ อันแรกเรียกว่า รูทโหนดรูทนี้มีสองตัว โหนดลูก ในระดับที่ 1 นั่นคือ โหนดหลัก ไปยังโหนดทั้งสี่ในระดับ 2 ดูว่า "สี่เหลี่ยมจัตุรัส" ที่เราพูดถึงจนถึงตอนนี้นั้นเรียกว่า โหนด; และโหนดก่อนหน้าแต่ละโหนดเป็นพาเรนต์ของโหนดต่อไปนี้ นั่นคือลูกของมัน โหนดลูกของแต่ละระดับที่มีพาเรนต์เดียวกันจะถูกเรียก พี่น้องดังจะเห็นได้จากภาพถัดไป:

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

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

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

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

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

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

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

ทำความเข้าใจกับป่าสุ่ม

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

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

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

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

เกี่ยวกับคำตอบของคำถามเริ่มต้น เรารู้อยู่แล้วว่ามันจะถูกเข้ารหัสในใบไม้ของต้นไม้ – แต่อะไรจะเปลี่ยนไปเมื่อเรามีต้นไม้หลายต้นแทนที่จะเป็นต้นไม้เดียว?

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

Ensemble Learning และ Model Ensembles

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

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

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

ด้วยการใช้งานในวงกว้าง ห้องสมุดเช่น Scikit-Learn ได้นำ wrapper มาใช้ RandomForestRegressorและ RandomForestClassifiers ซึ่งสร้างขึ้นจากการใช้แผนผังการตัดสินใจของตนเอง เพื่อให้นักวิจัยหลีกเลี่ยงการสร้างกลุ่มของตนเอง

ดำดิ่งสู่ป่าสุ่มกันเถอะ!

อัลกอริทึมป่าสุ่มทำงานอย่างไร

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

1. เลือกจำนวนระเบียนแบบสุ่ม อาจเป็นตัวเลขใดก็ได้ เช่น 4, 20, 76, 150 หรือแม้แต่ 2.000 จากชุดข้อมูล (เรียกว่า N บันทึก). จำนวนจะขึ้นอยู่กับความกว้างของชุดข้อมูล ยิ่งกว้าง ยิ่งมาก N เป็นไปได้. นี่คือที่ที่ สุ่ม ส่วนที่มาของชื่ออัลกอริทึมนั้นมาจาก!
2. สร้างแผนผังการตัดสินใจตามสิ่งเหล่านั้น N บันทึกแบบสุ่ม
3. ตามจำนวนของต้นไม้ที่กำหนดไว้สำหรับอัลกอริทึมหรือจำนวนของต้นไม้ในฟอเรสต์ ให้ทำซ้ำขั้นตอนที่ 1 และ 2 สิ่งนี้จะสร้างต้นไม้เพิ่มเติมจากชุดของบันทึกข้อมูลแบบสุ่ม
4. หลังจากขั้นตอนที่ 3 มาถึงขั้นตอนสุดท้ายซึ่งเป็นการทำนายผลลัพธ์:
   • ในกรณีของการจำแนก: ต้นไม้แต่ละต้นในป่าจะทำนายประเภทของบันทึกใหม่ หลังจากนั้น สถิติใหม่จะถูกกำหนดให้กับหมวดหมู่ที่ได้รับเสียงข้างมาก
   • ในกรณีของการถดถอย: ต้นไม้แต่ละต้นในฟอเรสต์ทำนายค่าสำหรับเรคคอร์ดใหม่ และค่าการคาดคะเนขั้นสุดท้ายจะคำนวณโดยใช้ค่าเฉลี่ยของค่าทั้งหมดที่ต้นไม้ทั้งหมดในฟอเรสต์ทำนายไว้

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

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

การสร้างและฝึกอบรมแบบจำลองป่าแบบสุ่มด้วย Scikit-Learn

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

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

จากนั้นข้อมูลที่รวบรวมได้จะถูกจัดระเบียบในไฟล์ค่าที่คั่นด้วยเครื่องหมายจุลภาค (csv) และอัปโหลดไปยัง พื้นที่เก็บข้อมูลการเรียนรู้ของเครื่อง UCI.

นี่คือข้อมูลที่เราจะใช้ในการฝึกฝนและพยายามทำความเข้าใจว่าหญิงตั้งครรภ์มี ต่ำ, กลาง or สูง เสี่ยงต่อการเสียชีวิต

การใช้ป่าสุ่มสำหรับการจำแนกประเภท

เนื่องจากเราอยากทราบว่าผู้หญิงมี ต่ำ, กลาง or สูง ความเสี่ยงต่อการเสียชีวิต หมายความว่าเราจะแบ่งประเภทเป็นสามประเภท เมื่อปัญหามีมากกว่าสองคลาส จะเรียกว่า a มัลติคลาส ปัญหาซึ่งตรงข้ามกับก ไบนารี ปัญหา (ซึ่งโดยทั่วไปแล้วคุณจะเลือกระหว่างสองคลาส 0 และ 1).

ในตัวอย่างแรกนี้ เราจะใช้โมเดลการจัดหมวดหมู่แบบหลายคลาสด้วยตัวแยกประเภท Random Forest และ Scikit-Learn ของ Python

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

การนำเข้าไลบรารี

เราจะใช้ Pandas เพื่ออ่านข้อมูล, Seaborn และ Matplotlib เพื่อให้เห็นภาพ และ NumPy สำหรับวิธีการยูทิลิตี้ที่ยอดเยี่ยม:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

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

รหัสต่อไปนี้นำเข้าชุดข้อมูลและโหลดลงในไพ ธ อน DataFrame:

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

ในการดูข้อมูลห้าบรรทัดแรก เราดำเนินการ head() คำสั่ง:

dataset.head()

ผลลัพธ์นี้:

    Age SystolicBP  DiastolicBP BS      BodyTemp    HeartRate   RiskLevel
0   25  130         80          15.0    98.0        86          high risk
1   35  140         90          13.0    98.0        70          high risk
2   29  90          70          8.0     100.0       80          high risk
3   30  140         85          7.0     98.0        70          high risk
4   35  120         60          6.1     98.0        76          low risk

เราสามารถดูคุณสมบัติทั้งหมดที่รวบรวมระหว่างการวิจัยได้ที่นี่

• อายุ: อายุเป็นปี
• SystolicBP: ค่าสูงสุดของความดันโลหิตเป็น mmHg ซึ่งเป็นคุณลักษณะที่สำคัญในระหว่างตั้งครรภ์
• DiastolicBP: ค่าความดันโลหิตต่ำกว่าในหน่วย mmHg ซึ่งเป็นคุณลักษณะที่สำคัญอีกอย่างหนึ่งในระหว่างตั้งครรภ์
• BS: ระดับน้ำตาลในเลือดในแง่ของความเข้มข้นของโมล, มิลลิโมล/ลิตร
• HeartRate: อัตราการเต้นของหัวใจขณะพักเป็นครั้งต่อนาที
• ระดับความเสี่ยง: ระดับความเสี่ยงระหว่างตั้งครรภ์
• BodyTemp: อุณหภูมิร่างกาย

ตอนนี้เราเข้าใจมากขึ้นเกี่ยวกับสิ่งที่ถูกวัด เราสามารถดูประเภทของข้อมูลได้ด้วย info():

dataset.info()

ผลลัพธ์นี้ใน:

RangeIndex: 1014 entries, 0 to 1013
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   Age          1014 non-null   int64  
 1   SystolicBP   1014 non-null   int64  
 2   DiastolicBP  1014 non-null   int64  
 3   BS           1014 non-null   float64
 4   BodyTemp     1014 non-null   float64
 5   HeartRate    1014 non-null   int64  
 6   RiskLevel    1014 non-null   object 
dtypes: float64(2), int64(4), object(1)
memory usage: 55.6+ KB

จากการดู RangeIndex เราจะเห็นว่ามี 1014 ระเบียนและคอลัมน์ Non-Null Count แจ้งว่าข้อมูลไม่มีค่าใดหายไป ซึ่งหมายความว่าเราไม่ต้องดำเนินการใด ๆ สำหรับข้อมูลที่ขาดหายไป!

ตัว Vortex Indicator ได้ถูกนำเสนอลงในนิตยสาร Dtype คอลัมน์ เราจะเห็นประเภทของตัวแปรแต่ละตัว ปัจจุบัน, float64 คอลัมน์ดังกล่าว BS และ BodyTemp มีค่าตัวเลขที่อาจแตกต่างกันไปในแต่ละช่วง เช่น 15.0, 15.51, 15.76, 17.28 ทำให้ ต่อเนื่องเป็นตัวเลข (คุณสามารถเพิ่ม 0 ให้กับเลขทศนิยมได้เสมอ โฆษณาไม่มีที่สิ้นสุด) ในทางกลับกัน ตัวแปรเช่น Age, SystolicBP, DiastolicBPและ HeartRate เป็นประเภท int64หมายความว่า ตัวเลขเปลี่ยนตามหน่วยเท่านั้น เช่น 11, 12, 13, 14 – เราจะไม่มีอัตราการเต้นของหัวใจที่ 77.78 แต่เป็น 77 หรือ 78 – นั่นคือ ตัวเลขไม่ต่อเนื่อง ค่า และเรายังมี RiskLevel กับ object ประเภท ซึ่งมักจะระบุว่าตัวแปรเป็นข้อความ และเราอาจต้องแปลงเป็นตัวเลข เนื่องจากระดับความเสี่ยงเพิ่มขึ้นจากต่ำไปสูง จึงมีลำดับโดยนัยในหมวดหมู่ ซึ่งบ่งชี้ว่าเป็น a ลำดับอย่างเด็ดขาด ตัวแปร

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

dataset.describe().T 

รหัสด้านบนแสดง:

            count   mean        std         min     25%     50%     75%     max
Age         1014.0  29.871795   13.474386   10.0    19.0    26.0    39.0    70.0
SystolicBP  1014.0  113.198225  18.403913   70.0    100.0   120.0   120.0   160.0
DiastolicBP 1014.0  76.460552   13.885796   49.0    65.0    80.0    90.0    100.0
BS          1014.0  8.725986    3.293532    6.0     6.9     7.5     8.0     19.0
BodyTemp    1014.0  98.665089   1.371384    98.0    98.0    98.0    98.0    103.0
HeartRate   1014.0  74.301775   8.088702    7.0     70.0    76.0    80.0    90.0
RiskLevel   1014.0  0.867850    0.807353    0.0     0.0     1.0     2.0     2.0

โปรดสังเกตว่าสำหรับคอลัมน์ส่วนใหญ่ หมายความ ค่าอยู่ห่างจาก ส่วนเบี่ยงเบนมาตรฐาน (มาตรฐาน) – สิ่งนี้บ่งชี้ว่าข้อมูลไม่จำเป็นต้องเป็นไปตามการแจกแจงทางสถิติที่ประพฤติดี ถ้าเป็นเช่นนั้น มันจะช่วยโมเดลในการทำนายความเสี่ยง สิ่งที่ทำได้คือการประมวลผลข้อมูลล่วงหน้าเพื่อให้เป็นตัวแทนมากขึ้นราวกับว่าเป็นข้อมูลจากประชากรโลกทั้งหมด หรือมากกว่านั้น ปกติ. แต่ข้อได้เปรียบเมื่อใช้โมเดล Random Forest สำหรับ การจัดหมวดหมู่คือโครงสร้างต้นไม้โดยธรรมชาติสามารถจัดการกับข้อมูลที่ยังไม่ได้ทำให้เป็นมาตรฐานได้ดี เมื่อแบ่งตามค่าในแต่ละระดับของต้นไม้สำหรับแต่ละตัวแปร

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

ในกรณีนี้ ขั้นตอนในการประมวลผลข้อมูลล่วงหน้าที่เราสามารถทำได้คือการแปลงหมวดหมู่ RiskLevel คอลัมน์เป็นตัวเลข

การแสดงข้อมูล

ก่อนแปลงร่าง RiskLevelเรายังแสดงภาพข้อมูลอย่างรวดเร็วด้วยการดูที่การรวมกันของจุดสำหรับแต่ละคู่ของคุณลักษณะด้วย Scatterplot และวิธีการกระจายจุดโดยการแสดงภาพเส้นโค้งฮิสโตแกรม ในการทำเช่นนั้นเราจะใช้ของซีบอร์น pairplot() ซึ่งผสมผสานทั้งสองแปลง มันสร้างทั้งสองแปลงสำหรับการรวมคุณสมบัติแต่ละรายการและแสดงรหัสสีของจุดตามระดับความเสี่ยงด้วย hue คุณสมบัติ:

g = sns.pairplot(dataset, hue='RiskLevel')
g.fig.suptitle("Scatterplot and histogram of pairs of variables color coded by risk level", 
               fontsize = 14, 
               y=1.05); 

รหัสด้านบนสร้าง:

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

เมื่อวิเคราะห์ข้อมูลเชิงสำรวจพื้นฐานเสร็จแล้ว เราสามารถประมวลผลล่วงหน้าได้ RiskLevel คอลัมน์.

การประมวลผลข้อมูลล่วงหน้าสำหรับการจำแนกประเภท

เพื่อให้แน่ใจว่ามีเพียงสามคลาสของ RiskLevel ในข้อมูลของเรา และไม่มีการเพิ่มค่าอื่นใดอย่างผิดพลาด เราสามารถใช้ unique() เพื่อแสดงค่าเฉพาะของคอลัมน์:

dataset['RiskLevel'].unique()

ผลลัพธ์นี้:

array(['high risk', 'low risk', 'mid risk'], dtype=object)

ตรวจสอบคลาสแล้ว ขั้นตอนต่อไปคือการแปลงค่าแต่ละค่าเป็นตัวเลข เนื่องจากมีลำดับระหว่างการจัดประเภท เราจึงใช้ค่า 0, 1 และ 2 เพื่อบ่งชี้ได้ ต่ำ, กลาง และ สูง ความเสี่ยง มีหลายวิธีในการเปลี่ยนค่าคอลัมน์ ตามวิธีของ Python ง่ายดีกว่าที่ซับซ้อน คำขวัญ เราจะใช้ .replace() วิธีการและเพียงแค่แทนที่ด้วยการแสดงจำนวนเต็ม:

dataset['RiskLevel'] = dataset['RiskLevel'].replace('low risk', 0).replace('mid risk', 1).replace('high risk', 2)

หลังจากแทนที่ค่าแล้ว เราสามารถแบ่งข้อมูลออกเป็นข้อมูลที่จะใช้ในการฝึกโมเดล คุณสมบัติ or Xและสิ่งที่เราต้องการทำนาย, the ฉลาก or y:

y = dataset['RiskLevel']
X = dataset.drop(['RiskLevel'], axis=1)

เมื่อ X และ y ชุดพร้อมแล้ว เราสามารถใช้ Scikit-Learn's train_test_split() วิธีการแบ่งเพิ่มเติมเป็นชุดรถไฟและชุดทดสอบ:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

ที่นี่เราใช้ข้อมูล 20% สำหรับการทดสอบและ 80% สำหรับการฝึกอบรม

ฝึก RandomForestClassifier

Scikit-Learn ใช้วงดนตรีภายใต้ sklearn.ensemble โมดูล. กลุ่มของโครงสร้างการตัดสินใจที่ใช้สำหรับการจำแนกประเภท ซึ่งใช้การลงคะแนนเสียงข้างมากเป็น RandomForestClassifier.

มีชุดฝึกและชุดทดสอบแล้ว เราสามารถนำเข้า RandomForestClassifier คลาสและสร้างแบบจำลอง ในการเริ่มต้น มาสร้างป่าด้วยต้นไม้ XNUMX ต้น โดยการตั้งค่า n_estimators พารามิเตอร์เป็น 3 และแต่ละทรีมีสามระดับโดยการตั้งค่า max_depthถึง 2:

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=3, 
                             max_depth=2,
                             random_state=SEED)

เพื่อให้พอดีกับโมเดลรอบๆ ข้อมูล เราเรียกว่า fit() วิธีการ การวางคุณสมบัติการฝึกอบรมและป้ายกำกับ:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

ตอนนี้เราสามารถเปรียบเทียบฉลากที่คาดคะเนกับฉลากจริงเพื่อประเมินว่าโมเดลทำได้ดีเพียงใด! ก่อนจะประเมินโมเดล เรามาดูส่วนประกอบทั้งหมดกันก่อน

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

from sklearn import tree

features = X.columns.values 
classes = ['0', '1', '2'] 



for estimator in rfc.estimators_:
    print(estimator)
    plt.figure(figsize=(12,6))
    tree.plot_tree(estimator,
                   feature_names=features,
                   class_names=classes,
                   fontsize=8, 
                   filled=True, 
                   rounded=True)
    plt.show()

รหัสด้านบนแสดงแผนผังต้นไม้:

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

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

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

การประเมิน RandomForestClassifier

Scikit-Learn ทำให้ง่ายต่อการสร้างบรรทัดฐานโดยการให้ a DummyClassifierซึ่งแสดงผลการคาดคะเน โดยไม่ต้องใช้คุณสมบัติการป้อนข้อมูล (ผลลัพธ์แบบสุ่มทั้งหมด) ถ้ารุ่นของคุณดีกว่ารุ่น DummyClassifier, บาง การเรียนรู้กำลังเกิดขึ้น! เพื่อเพิ่มการเรียนรู้ให้สูงสุด คุณสามารถทดสอบไฮเปอร์พารามิเตอร์ต่างๆ ได้โดยอัตโนมัติโดยใช้ a RandomizedSearchCV or GridSearchCV. นอกจากมีพื้นฐานแล้ว คุณยังสามารถประเมินประสิทธิภาพของโมเดลได้จากเลนส์ของเมตริกต่างๆ

เมตริกการจัดประเภทแบบดั้งเดิมบางอย่างที่สามารถใช้ในการประเมินอัลกอริทึม ได้แก่ ความแม่นยำ การเรียกคืน คะแนน f1 ความแม่นยำ และเมทริกซ์ความสับสน นี่คือคำอธิบายสั้น ๆ เกี่ยวกับแต่ละรายการ:

1. ความแม่นยำ: เมื่อเป้าหมายของเราคือการทำความเข้าใจว่าค่าการคาดคะเนใดถูกต้องซึ่งถือว่าถูกต้องโดยตัวแยกประเภทของเรา ความแม่นยำจะแบ่งค่าบวกจริงเหล่านั้นด้วยตัวอย่างที่คาดการณ์ว่าเป็นค่าบวก

$$
ความแม่นยำ = frac{ข้อความ{ผลบวกจริง}}{ข้อความ{ผลบวกจริง} + ข้อความ{ผลบวกเท็จ}}
$$

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

$$
เรียกคืน = frac{ข้อความ{ผลบวกจริง}}{ข้อความ{ผลบวกจริง} + ข้อความ{ผลลบเท็จ}}
$$

3. คะแนน F1: คือความสมดุลหรือ ฮาร์โมนิก ของความแม่นยำและการเรียกคืน ค่าต่ำสุดคือ 0 และค่าสูงสุดคือ 1 เมื่อ f1-score เท่ากับ 1 หมายความว่าทุกคลาสได้รับการทำนายอย่างถูกต้อง – นี่เป็นคะแนนที่ยากมากที่จะได้รับจากข้อมูลจริง (มีข้อยกเว้นเกือบทุกครั้ง)

$$
ข้อความ{f1-score} = 2* frac{text{precision} * text{recall}}{text{precision} + text{recall}}
$$

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

5. ความถูกต้อง: อธิบายจำนวนการคาดคะเนของเราที่ลักษณนามของเราได้ถูกต้อง ค่าความแม่นยำต่ำสุดคือ 0 และค่าสูงสุดคือ 1 ค่านั้นมักจะคูณด้วย 100 เพื่อให้ได้เปอร์เซ็นต์:

$$
ความแม่นยำ = frac{ข้อความ{จำนวนการคาดการณ์ที่ถูกต้อง}}{ข้อความ{จำนวนการคาดการณ์ทั้งหมด}}
$$

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

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk)')

print(classification_report(y_test,y_pred))

ผลลัพธ์จะมีลักษณะดังนี้:

                precision    recall  f1-score   support

           0       0.53      0.89      0.66        80
           1       0.57      0.17      0.26        76
           2       0.74      0.72      0.73        47

    accuracy                           0.58       203
   macro avg       0.61      0.59      0.55       203
weighted avg       0.59      0.58      0.53       203

ในรายงานการจำแนกประเภท สังเกตว่าการเรียกคืนสูง 0.89 สำหรับคลาส 0 ทั้งความแม่นยำและการเรียกคืนสูงสำหรับคลาส 2, 0.74, 0.72 – และสำหรับคลาส 1 มีค่าต่ำ โดยเฉพาะการเรียกคืน 0.17 และความแม่นยำ 0.57 . ความสัมพันธ์ระหว่างการเรียกคืนและความแม่นยำสำหรับคลาสทั้งสามแต่ละคลาสถูกบันทึกไว้ใน F1 คะแนนซึ่งเป็นค่าเฉลี่ยฮาร์มอนิกระหว่างการเรียกคืนและความแม่นยำ - โมเดลกำลังทำอยู่ ถูก สำหรับคลาส 0 ค่อนข้างแย่สำหรับคลาส 1 และดีสำหรับคลาส 2

โมเดลมีช่วงเวลาที่ยากลำบากมากในการระบุ กรณีความเสี่ยงปานกลาง.

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

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

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

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

features_df = pd.DataFrame({'features': rfc.feature_names_in_, 'importances': rfc.feature_importances_ })


features_df_sorted = features_df.sort_values(by='importances', ascending=False)


g = sns.barplot(data=features_df_sorted, x='importances', y ='features', palette="rocket")
sns.despine(bottom = True, left = True)
g.set_title('Feature importances')
g.set(xlabel=None)
g.set(ylabel=None)
g.set(xticks=[])
for value in g.containers:
    g.bar_label(value, padding=2)

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

ในที่สุดก็ถึงเวลาสร้างโมเดลใหม่ที่มีต้นไม้มากขึ้นเพื่อดูว่ามันส่งผลต่อผลลัพธ์อย่างไร มาสร้างกันเถอะ rfc_ ป่าที่มีต้นไม้ 900 ต้น 8 ชั้นและเมล็ดพันธุ์เดียวกัน ผลลัพธ์จะดีขึ้นหรือไม่?

rfc_ = RandomForestClassifier(n_estimators=900, 
                             max_depth=7,
                             random_state=SEED)
rfc_.fit(X_train, y_train)
y_pred = rfc_.predict(X_test)

การคำนวณและการแสดงเมตริก:

cm_ = confusion_matrix(y_test, y_pred)
sns.heatmap(cm_, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk) for 900 trees with 8 levels')

print(classification_report(y_test,y_pred))

ผลลัพธ์นี้:

                precision    recall  f1-score   support

           0       0.68      0.86      0.76        80
           1       0.75      0.58      0.65        76
           2       0.90      0.81      0.85        47

    accuracy                           0.74       203
   macro avg       0.78      0.75      0.75       203
weighted avg       0.76      0.74      0.74       203

สิ่งนี้แสดงให้เห็นว่าการเพิ่มต้นไม้มากขึ้นและต้นไม้พิเศษมากขึ้น (ระดับที่สูงขึ้น) ได้ปรับปรุงเมตริกของเราอย่างไร เรายังคงมีการเรียกคืนคลาส 1 ต่ำ แต่ตอนนี้ความแม่นยำอยู่ที่ 74% คะแนน F1 เมื่อจำแนกกรณีที่มีความเสี่ยงสูงคือ 0.85 ซึ่งหมายความว่ากรณีที่มีความเสี่ยงสูงสามารถระบุได้ง่ายขึ้นเมื่อเทียบกับ 0.73 ในรุ่นก่อนหน้า!

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

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

การใช้ป่าสุ่มสำหรับการถดถอย

ในหัวข้อนี้ เราจะศึกษาวิธีการใช้อัลกอริทึม Random Forest เพื่อแก้ปัญหาการถดถอยโดยใช้ Scikit-Learn ขั้นตอนที่ตามมาเพื่อใช้อัลกอริทึมนี้เกือบจะเหมือนกันกับขั้นตอนที่ดำเนินการสำหรับการจำแนกประเภท นอกเหนือจากประเภทของแบบจำลองและประเภทของข้อมูลที่คาดการณ์ ซึ่งตอนนี้จะเป็นค่าต่อเนื่องกัน มีความแตกต่างเพียงอย่างเดียวในการเตรียมข้อมูล

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

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

นำเข้าไลบรารีและข้อมูล

import pandas as pd
import numpy as np
import maplotlib.pyplot as plt
import seaborn as sns

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

การประมวลผลข้อมูลล่วงหน้าสำหรับการถดถอย

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

from sklearn.model_selection import train_test_split

SEED = 42

y = dataset['BS']
X = dataset.drop(['BS'], axis=1) 

X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

การฝึกอบรม RandomForestRegressor

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

from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor(n_estimators=20, 
                            max_depth=3, 
                            random_state=SEED)

rfr.fit(X_train, y_train)
y_pred = rfr.predict(X_test)

คุณสามารถค้นหารายละเอียดของพารามิเตอร์ทั้งหมดของ RandomForestRegressor ในเอกสารอย่างเป็นทางการ.

เนื่องจากการลงจุดและดูต้นไม้ 20 ต้นต้องใช้เวลาและความทุ่มเทพอสมควร เราจึงสามารถพล็อตแค่ต้นแรกเพื่อดูว่ามันแตกต่างจากต้นไม้จำแนกประเภทอย่างไร:

from sklearn import tree

features = X.columns

first_tree = rfr.estimators_[0]

plt.figure(figsize=(15,6))
tree.plot_tree(first_tree,
               feature_names=features,
               fontsize=8, 
               filled=True, 
               rounded=True);

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

ถึงเวลาดำเนินการขั้นตอนสุดท้ายและสุดท้ายเมื่อแก้ปัญหาการเรียนรู้ของเครื่องและประเมินประสิทธิภาพของอัลกอริทึม!

การประเมิน RandomForestRegressor

สำหรับปัญหาการถดถอย เมตริกที่ใช้ในการประเมินอัลกอริทึม ได้แก่ ข้อผิดพลาดสัมบูรณ์เฉลี่ย (MAE) ข้อผิดพลาดค่าเฉลี่ยกำลังสอง (MSE) และข้อผิดพลาดค่าเฉลี่ยกำลังสอง (RMSE)

1. หมายถึงข้อผิดพลาดแอบโซลูท (MAE): เมื่อเราลบค่าที่คาดการณ์ออกจากค่าจริง หาข้อผิดพลาด รวมค่าสัมบูรณ์ของข้อผิดพลาดเหล่านั้น และหาค่าเฉลี่ย เมตริกนี้ให้แนวคิดเกี่ยวกับข้อผิดพลาดโดยรวมสำหรับการคาดคะเนแต่ละรายการของโมเดล ยิ่งมีค่าน้อย (ใกล้ 0) ยิ่งดี

$$
mae = (frac{1}{n})sum_{i=1}^{n}left | จริง – ถูกทำนาย |
$$

2. ค่าเฉลี่ยกำลังสองข้อผิดพลาด (MSE): คล้ายกับเมตริก MAE แต่จะยกกำลังสองด้วยค่าสัมบูรณ์ของข้อผิดพลาด นอกจากนี้ เช่นเดียวกับ MAE ค่ายิ่งน้อยหรือใกล้ 0 ยิ่งดี ค่า MSE จะถูกยกกำลังสองเพื่อให้ข้อผิดพลาดใหญ่ขึ้น สิ่งหนึ่งที่ควรให้ความสนใจเป็นพิเศษคือโดยปกติแล้วจะเป็นเมตริกที่ตีความได้ยากเนื่องจากขนาดของค่าและข้อเท็จจริงที่ว่าค่าเหล่านั้นไม่ได้อยู่ในสเกลเดียวกันของข้อมูล

$$
mse = sum_{i=1}^{D}(จริง – คาดการณ์)^2
$$

3. รูท Mean Squared Error (RMSE): พยายามแก้ปัญหาการตีความที่เกิดขึ้นกับ MSE โดยรับค่ารากที่สองของค่าสุดท้าย เพื่อปรับขนาดกลับไปเป็นหน่วยเดียวกันของข้อมูล ง่ายต่อการตีความและดีเมื่อเราต้องการแสดงหรือแสดงค่าจริงของข้อมูลที่มีข้อผิดพลาด มันแสดงให้เห็นว่าข้อมูลอาจแตกต่างกันมากน้อยเพียงใด ดังนั้นหากเรามี RMSE เท่ากับ 4.35 แบบจำลองของเราอาจสร้างข้อผิดพลาดได้ เนื่องจากเพิ่ม 4.35 เข้าไปในค่าจริง หรือต้องการ 4.35 เพื่อให้ได้ค่าจริง ยิ่งใกล้ 0 ยิ่งดี

$$
rmse = sqrt{ sum_{i=1}^{D}(จริง – คาดการณ์ไว้)^2}
$$

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

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

คุณสามารถใช้รหัสต่อไปนี้เพื่อค้นหาค่าเหล่านี้:

from sklearn.metrics import mean_absolute_error, mean_squared_error

print('Mean Absolute Error:', mean_absolute_error(y_test, y_pred))
print('Mean Squared Error:', mean_squared_error(y_test, y_pred))
print('Root Mean Squared Error:', np.sqrt(mean_squared_error(y_test, y_pred)))

ผลลัพธ์ควรเป็น:

Mean Absolute Error: 1.127893702896059
Mean Squared Error: 3.0802988503933326
Root Mean Squared Error: 1.755078018320933

เมื่อมีต้นไม้ 20 ต้น ค่าความคลาดเคลื่อนกำลังสองของค่าเฉลี่ยรากคือ 1.75 ซึ่งต่ำ แต่ถึงอย่างนั้น การเพิ่มจำนวนต้นไม้และทดลองกับพารามิเตอร์อื่นๆ ข้อผิดพลาดนี้อาจยิ่งน้อยลงไปอีก

ข้อดีของการใช้ Random Forest

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

1. อัลกอริทึมของฟอเรสต์แบบสุ่มไม่ได้ลำเอียง เนื่องจากมีต้นไม้หลายต้นและต้นไม้แต่ละต้นได้รับการฝึกฝนบนชุดข้อมูลย่อยแบบสุ่ม โดยพื้นฐานแล้ว อัลกอริทึมฟอเรสต์แบบสุ่มอาศัยพลังของ "ฝูงชน"; ดังนั้นระดับอคติโดยรวมของอัลกอริทึมจึงลดลง
2. อัลกอริทึมนี้มีความเสถียรมาก แม้ว่าจะมีการแนะนำจุดข้อมูลใหม่ในชุดข้อมูล อัลกอริทึมโดยรวมจะไม่ได้รับผลกระทบมากนัก เนื่องจากข้อมูลใหม่อาจส่งผลกระทบต่อทรีหนึ่งต้น แต่ก็เป็นเรื่องยากมากที่จะส่งผลกระทบต่อทรีทั้งหมด
3. อัลกอริทึมฟอเรสต์แบบสุ่มทำงานได้ดีเมื่อคุณมีคุณสมบัติทั้งเชิงหมวดหมู่และเชิงตัวเลข
4. อัลกอริทึมฟอเรสต์แบบสุ่มยังทำงานได้ดีเมื่อข้อมูลมีค่าขาดหายไปหรือไม่ได้ปรับขนาด

ข้อเสียของการใช้ Random Forest

1. ข้อเสียเปรียบหลักของป่าสุ่มคือความซับซ้อน พวกเขาต้องการทรัพยากรในการคำนวณมากขึ้น เนื่องจากมีแผนผังการตัดสินใจจำนวนมากมารวมกัน เมื่อฝึกวงดนตรีขนาดใหญ่ แม้ว่า – ด้วยฮาร์ดแวร์ที่ทันสมัย ​​การฝึกอบรมแม้แต่ฟอเรสต์สุ่มขนาดใหญ่ก็ไม่ใช้เวลามาก

ก้าวต่อไป – โครงการ End-To-End แบบมือถือ

ธรรมชาติที่อยากรู้อยากเห็นของคุณทำให้คุณต้องการไปต่อหรือไม่? เราขอแนะนำให้ตรวจสอบของเรา โครงการแนะนำ: “การทำนายราคาบ้านแบบลงมือปฏิบัติ – การเรียนรู้ของเครื่องใน Python”.

ในโครงการแนะนำนี้ คุณจะได้เรียนรู้วิธีสร้างโมเดลแมชชีนเลิร์นนิงแบบดั้งเดิมที่ทรงพลังรวมถึงโมเดลการเรียนรู้เชิงลึก ใช้ Ensemble Learning และฝึกอบรมเมตาเลิร์นนิงเพื่อทำนายราคาบ้านจากโมเดล Scikit-Learn และ Keras

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

การเรียนรู้เชิงลึกนั้นน่าทึ่งมาก – แต่ก่อนที่จะหันไปใช้ ขอแนะนำให้พยายามแก้ปัญหาด้วยเทคนิคที่ง่ายกว่า เช่น การเรียนรู้ที่ตื้น อัลกอริทึม ประสิทธิภาพพื้นฐานของเราจะขึ้นอยู่กับ a การถดถอยของป่าแบบสุ่ม อัลกอริทึม นอกจากนี้ – เราจะสำรวจการสร้างชุดโมเดลผ่าน Scikit-Learn ผ่านเทคนิคต่างๆ เช่น การห่อ และ การออกเสียง.

นี่เป็นโครงการแบบ end-to-end และเช่นเดียวกับโครงการ Machine Learning ทั้งหมด เราจะเริ่มต้นด้วย – with การวิเคราะห์ข้อมูลเชิงสำรวจ, ติดตามโดย การประมวลผลข้อมูลล่วงหน้า และในที่สุดก็ อาคารตื้น และ โมเดลการเรียนรู้เชิงลึก เพื่อให้พอดีกับข้อมูลที่เราได้สำรวจและทำความสะอาดก่อนหน้านี้