ป่าสุ่มใน Python
ตัวอย่างการเรียนรู้ของเครื่องแบบครบวงจรที่ใช้งานได้จริง
ไม่เคยมีเวลาใดที่ดีไปกว่านี้ในการเข้าสู่การเรียนรู้ของเครื่อง ด้วยทรัพยากรการเรียนรู้ที่ "พร้อมใช้งานออนไลน์" ฟรี "เครื่องมือโอเพ่นซอร์ส" พร้อมการใช้งานอัลกอริธึมใดๆ เท่าที่จะจินตนาการได้ และความพร้อมใช้งานในราคาถูกของพลังการประมวลผลผ่านบริการคลาวด์ เช่น AWS การเรียนรู้ของเครื่องจึงเป็นสาขาที่ได้รับการทำให้เป็นประชาธิปไตยโดยอินเทอร์เน็ตอย่างแท้จริง . ทุกคนที่สามารถเข้าถึงแล็ปท็อปและเต็มใจที่จะเรียนรู้สามารถลองใช้อัลกอริธึมที่ล้ำสมัยได้ภายในไม่กี่นาที ด้วยเวลาเพิ่มขึ้นอีกเล็กน้อย คุณสามารถพัฒนาแบบจำลองที่ใช้งานได้จริงเพื่อช่วยในชีวิตประจำวันหรือที่ทำงานของคุณ (หรือแม้แต่เปลี่ยนไปใช้การเรียนรู้ของเครื่องและเก็บเกี่ยว "ผลประโยชน์ทางเศรษฐกิจ") โพสต์นี้จะแนะนำคุณเกี่ยวกับการใช้งานโมเดลการเรียนรู้ของเครื่องฟอเรสต์แบบสุ่มที่ทรงพลังตั้งแต่ต้นทางถึงปลายทาง มีจุดมุ่งหมายเพื่อใช้เป็นส่วนเสริมของ "คำอธิบายแนวความคิดเกี่ยวกับฟอเรสต์สุ่ม" ของฉัน แต่สามารถอ่านได้ทั้งหมดด้วยตัวเองตราบใดที่คุณมีแนวคิดพื้นฐานของแผนผังการตัดสินใจและฟอเรสต์สุ่ม โพสต์ติดตามผล ให้รายละเอียดว่าเราจะปรับปรุงโมเดลที่สร้างขึ้นที่นี่ได้อย่างไร
แน่นอนว่าจะต้องมีโค้ด Python ที่นี่ อย่างไรก็ตาม มันไม่ได้มีไว้สำหรับใครก็ตาม แต่เพื่อแสดงให้เห็นว่า Machine Learning เข้าถึงได้ง่ายเพียงใดด้วยทรัพยากรที่มีอยู่ในปัจจุบัน! โครงการทั้งหมดพร้อมข้อมูลมีอยู่ใน "GitHub" และ "ไฟล์ข้อมูล" และ "Jupyter Notebook" ยังสามารถดาวน์โหลดได้จาก Google Drive สิ่งที่คุณต้องมีคือแล็ปท็อปที่ติดตั้ง Python และมีความสามารถในการเริ่ม Jupyter Notebook และคุณสามารถทำตามได้ (สำหรับการติดตั้ง Python และใช้งานโน้ตบุ๊ก Jupyter โปรดดู คู่มือนี้) จะมีหัวข้อแมชชีนเลิร์นนิงที่จำเป็นบางหัวข้อกล่าวถึงที่นี่ แต่ฉันจะพยายามทำให้หัวข้อเหล่านี้ชัดเจนและจัดหาทรัพยากรสำหรับการเรียนรู้เพิ่มเติมสำหรับผู้ที่สนใจ
บทนำปัญหา
ปัญหาที่เราจะแก้ไขคือการทำนายอุณหภูมิสูงสุดสำหรับวันพรุ่งนี้ในเมืองของเราโดยใช้ข้อมูลสภาพอากาศในอดีตหนึ่งปี ฉันใช้เมืองซีแอตเทิล รัฐวอชิงตัน แต่อย่าลังเลที่จะค้นหาข้อมูลสำหรับเมืองของคุณเองโดยใช้ เครื่องมือ NOAA Climate Data Online เราจะทำตัวราวกับว่าเราไม่สามารถเข้าถึงการพยากรณ์อากาศใดๆ ได้ (และนอกจากนี้ การพยากรณ์ของเราเองจะสนุกกว่าการพึ่งพาผู้อื่น) สิ่งที่เราเข้าถึงได้คืออุณหภูมิสูงสุดในอดีตในหนึ่งปี อุณหภูมิสำหรับสองวันก่อนหน้า และการประมาณการจากเพื่อนที่มักจะอ้างว่ารู้ทุกอย่างเกี่ยวกับสภาพอากาศ นี่คือ "ปัญหาการเรียนรู้ของเครื่องแบบถดถอยภายใต้การดูแล" มีการควบคุมดูแลเนื่องจากเรามีทั้งคุณลักษณะ (ข้อมูลสำหรับเมือง) และเป้าหมาย (อุณหภูมิ) ที่เราต้องการคาดการณ์ ในระหว่างการฝึก เราจะให้ทั้งคุณสมบัติและเป้าหมายแก่ฟอเรสต์แบบสุ่ม และจะต้องเรียนรู้วิธีการจับคู่ข้อมูลกับการคาดการณ์ ยิ่งไปกว่านั้น นี่คืองานการถดถอยเนื่องจากค่าเป้าหมายมีความต่อเนื่อง (ตรงข้ามกับคลาสที่แยกกันในการจำแนกประเภท) นั่นเป็นพื้นหลังทั้งหมดที่เราต้องการ มาเริ่มกันเลย!
แผนการทำงาน
ก่อนที่เราจะเข้าสู่การเขียนโปรแกรม เราควรจัดทำคำแนะนำสั้นๆ เพื่อให้เราดำเนินการต่อไป ขั้นตอนต่อไปนี้เป็นพื้นฐานสำหรับเวิร์กโฟลว์แมชชีนเลิร์นนิงเมื่อเรามีปัญหาและโมเดลอยู่ในใจ:
- ระบุคำถามและระบุข้อมูลที่ต้องการ
- รับข้อมูลในรูปแบบที่สามารถเข้าถึงได้
- ระบุและแก้ไขจุดข้อมูลที่ขาดหายไป/ความผิดปกติตามที่ต้องการ
- เตรียมข้อมูลสำหรับโมเดลการเรียนรู้ของเครื่อง
- สร้างแบบจำลองพื้นฐานที่คุณตั้งเป้าที่จะไปให้ไกลกว่านั้น
- ฝึกโมเดลกับข้อมูลการฝึก
- คาดการณ์ข้อมูลการทดสอบ
- เปรียบเทียบการคาดการณ์กับเป้าหมายชุดทดสอบที่ทราบ และคำนวณตัวชี้วัดประสิทธิภาพ
- หากประสิทธิภาพไม่เป็นที่น่าพอใจ ให้ปรับโมเดล รับข้อมูลเพิ่มเติม หรือลองใช้เทคนิคการสร้างแบบจำลองอื่น
- ตีความโมเดลและรายงานผลลัพธ์ด้วยภาพและตัวเลข
ขั้นตอนที่ 1 ได้ถูกทำเครื่องหมายไว้แล้ว! เรามีคำถาม: “เราสามารถทำนายอุณหภูมิสูงสุดในเมืองของเราในวันพรุ่งนี้ได้หรือไม่” และเรารู้ว่าเราสามารถเข้าถึงอุณหภูมิสูงสุดในอดีตของปีที่ผ่านมาในซีแอตเทิล รัฐวอชิงตันได้
การได้มาของข้อมูล
ก่อนอื่น เราต้องการข้อมูลบางอย่าง หากต้องการใช้ตัวอย่างที่สมจริง ฉันดึงข้อมูลสภาพอากาศสำหรับซีแอตเทิล รัฐวอชิงตัน ตั้งแต่ปี 2016 โดยใช้เครื่องมือ NOAA Climate Data Online โดยทั่วไป ประมาณ 80% ของเวลาที่ใช้ในการวิเคราะห์ข้อมูลคือการล้างและเรียกข้อมูล แต่ภาระงานนี้สามารถลดลงได้ด้วยการค้นหาแหล่งข้อมูลคุณภาพสูง เครื่องมือ NOAA ใช้งานง่ายอย่างน่าประหลาดใจและสามารถดาวน์โหลดข้อมูลอุณหภูมิเป็นไฟล์ csv ที่ชัดเจน ซึ่งสามารถแยกวิเคราะห์เป็นภาษาต่างๆ เช่น Python หรือ R ได้ ไฟล์ข้อมูลที่สมบูรณ์คือ "พร้อมให้ดาวน์โหลด" สำหรับผู้ที่ต้องการติดตาม
รหัส Python ต่อไปนี้จะโหลดในข้อมูล CSV และแสดงโครงสร้างของข้อมูล:
# Pandas is used for data manipulation
import pandas as pd
# Read in data and display first 5 rows
features = pd.read_csv('temps.csv')
features.head(5)
ข้อมูลอยู่ในรูปแบบ ข้อมูลที่เป็นระเบียบเรียบร้อย โดยแต่ละแถวประกอบขึ้นเป็นข้อสังเกตเดียว พร้อมด้วยค่าตัวแปรในคอลัมน์
ต่อไปนี้เป็นคำอธิบายของคอลัมน์:
ปี:2016 สำหรับจุดข้อมูลทั้งหมด
เดือน: หมายเลขสำหรับเดือนของปี
วัน: หมายเลขสำหรับวันของปี
สัปดาห์: วันในสัปดาห์เป็นสตริงอักขระ
temp_2: อุณหภูมิสูงสุด 2 วันก่อนหน้า
temp_1: อุณหภูมิสูงสุด 1 วันก่อนหน้า
เฉลี่ย: อุณหภูมิสูงสุดเฉลี่ยในอดีต
ตามจริง: การวัดอุณหภูมิสูงสุด
เพื่อน: คำทำนายของเพื่อนของคุณ ตัวเลขสุ่มระหว่าง 20 ต่ำกว่าค่าเฉลี่ย และ 20 สูงกว่าค่าเฉลี่ย
ระบุความผิดปกติ/ข้อมูลที่ขาดหายไป
หากเราดูมิติของข้อมูล เราจะสังเกตเห็นว่ามีเพียง 348 แถวเท่านั้น ซึ่งไม่สอดคล้องกับ 366 วันที่เรารู้ว่ามีในปี 2016 มากนัก เมื่อดูข้อมูลจาก NOAA ฉันสังเกตเห็นวันที่หายไปหลายวัน ซึ่งเป็นเครื่องเตือนใจที่ดีว่าข้อมูลที่เก็บรวบรวมในโลกแห่งความเป็นจริงจะไม่มีวันสมบูรณ์แบบ “ข้อมูลที่ขาดหายไป” อาจส่งผลกระทบต่อการวิเคราะห์ เช่นเดียวกับข้อมูลที่ไม่ถูกต้องหรือค่าผิดปกติ ในกรณีนี้ ข้อมูลที่หายไปจะไม่ส่งผลกระทบมากนัก และคุณภาพของข้อมูลก็ดีเนื่องจากแหล่งที่มา นอกจากนี้เรายังเห็นว่ามีเก้าคอลัมน์ซึ่งแสดงถึงแปดคุณลักษณะและเป้าหมายเดียว ('จริง')
print('The shape of our features is:', features.shape)
The shape of our features is: (348, 9)
เพื่อระบุความผิดปกติ เราสามารถคำนวณสถิติสรุปได้อย่างรวดเร็ว
# Descriptive statistics for each column features.describe()
ไม่มีจุดข้อมูลใดที่ปรากฏผิดปกติทันทีและไม่มีศูนย์ในคอลัมน์การวัดใดๆ อีกวิธีหนึ่งในการตรวจสอบคุณภาพของข้อมูลคือการทำแปลงพื้นฐาน บ่อยครั้งที่มองเห็นความผิดปกติในกราฟได้ง่ายกว่าตัวเลข ฉันได้ทิ้งโค้ดจริงไว้ที่นี่ เนื่องจากการลงจุดเป็น Python นั้นไม่ใช้งานง่าย แต่อย่าลังเลที่จะอ้างอิงถึงสมุดบันทึกเพื่อการใช้งานที่สมบูรณ์ (เช่นเดียวกับนักวิทยาศาสตร์ข้อมูลที่ดี ๆ ฉันค่อนข้างจะคัดลอกและวางโค้ดการลงจุดจาก Stack Overflow ).
การตรวจสอบสถิติเชิงปริมาณและกราฟทำให้เรามั่นใจในคุณภาพของข้อมูลของเรา ไม่มีค่าผิดปกติที่ชัดเจน และถึงแม้จะมีบางจุดที่ขาดหายไป แต่ก็จะไม่เบี่ยงเบนไปจากการวิเคราะห์
การเตรียมข้อมูล
น่าเสียดายที่เรายังไม่ถึงจุดที่คุณสามารถป้อนข้อมูลดิบลงในโมเดลและส่งคืนคำตอบได้ (แม้ว่าผู้คนกำลังดำเนินการเรื่องนี้ก็ตาม)! เราจะต้องทำการแก้ไขเล็กน้อยเพื่อให้ข้อมูลของเราอยู่ในเงื่อนไขที่เครื่องเข้าใจได้ เราจะใช้ไลบรารี Python Pandas สำหรับการจัดการข้อมูลของเราโดยอาศัยโครงสร้างที่เรียกว่า dataframe ซึ่งโดยพื้นฐานแล้วคือสเปรดชีต Excel ที่มีแถวและคอลัมน์
ขั้นตอนที่แน่นอนในการเตรียมข้อมูลจะขึ้นอยู่กับโมเดลที่ใช้และข้อมูลที่รวบรวม แต่จะต้องใช้การจัดการข้อมูลจำนวนหนึ่งสำหรับแอปพลิเคชันแมชชีนเลิร์นนิง
การเข้ารหัสแบบร้อนแรง
ขั้นตอนแรกสำหรับเราเรียกว่า "การเข้ารหัสแบบร้อนแรงเดียว" ของข้อมูล กระบวนการนี้ใช้ตัวแปรที่เป็นหมวดหมู่ เช่น วันในสัปดาห์ แล้วแปลงเป็นการแสดงตัวเลขโดยไม่ต้องเรียงลำดับใดๆ วันในสัปดาห์นั้นใช้งานง่ายสำหรับเราเพราะเราใช้มันตลอดเวลา คุณ (หวังว่า) จะไม่พบใครเลยที่ไม่รู้ว่า 'จันทร์' หมายถึงวันแรกของสัปดาห์ทำงาน แต่เครื่องจักรไม่มีความรู้ตามสัญชาตญาณ สิ่งที่คอมพิวเตอร์รู้คือตัวเลข และสำหรับการเรียนรู้ของเครื่อง เราต้องรองรับตัวเลขเหล่านั้น เราสามารถจับคู่วันในสัปดาห์เป็นตัวเลข 1–7 ได้ แต่สิ่งนี้อาจนำไปสู่อัลกอริทึมที่ให้ความสำคัญกับวันอาทิตย์มากขึ้นเนื่องจากมีค่าตัวเลขที่สูงกว่า แต่เราเปลี่ยนคอลัมน์เดียวของวันธรรมดาเป็นเจ็ดคอลัมน์ของข้อมูลไบนารี นี่เป็นภาพประกอบที่ดีที่สุด การเข้ารหัสแบบ hot หนึ่งครั้งใช้สิ่งนี้:
และเปลี่ยนมันให้เป็น
ดังนั้น หากจุดข้อมูลเป็นวันพุธ ก็จะมีเลข 1 ในคอลัมน์วันพุธ และ 0 ในคอลัมน์อื่นๆ ทั้งหมด กระบวนการนี้สามารถทำได้ในแพนด้าในบรรทัดเดียว!
# One-hot encode the data using pandas get_dummies features = pd.get_dummies(features) # Display the first 5 rows of the last 12 columns features.iloc[:,5:].head(5)
สแนปชอตของข้อมูลหลังจากการเข้ารหัสแบบร้อนแรงเพียงครั้งเดียว:
รูปร่างของข้อมูลของเราตอนนี้คือ 349 x 15 และคอลัมน์ทั้งหมดเป็นตัวเลข อย่างที่อัลกอริทึมชอบ!
คุณสมบัติและเป้าหมาย และแปลงข้อมูลเป็นอาร์เรย์
ตอนนี้ เราต้องแยกข้อมูลออกเป็นคุณลักษณะและเป้าหมาย เป้าหมายหรือที่เรียกว่าป้ายกำกับ คือค่าที่เราต้องการทำนาย ในกรณีนี้คืออุณหภูมิสูงสุดจริงและคุณลักษณะคือคอลัมน์ทั้งหมดที่แบบจำลองใช้ในการทำนาย นอกจากนี้เรายังจะแปลงดาต้าเฟรมของ Pandas เป็นอาร์เรย์ "Numpy" เนื่องจากนั่นคือวิธีการทำงานของอัลกอริทึม (ฉันบันทึกส่วนหัวของคอลัมน์ซึ่งเป็นชื่อของคุณลักษณะ ลงในรายการเพื่อใช้สำหรับการแสดงภาพในภายหลัง)
# Use numpy to convert to arrays
import numpy as np
# Labels are the values we want to predict
labels = np.array(features['actual'])
# Remove the labels from the features
# axis 1 refers to the columns
features= features.drop('actual', axis = 1)
# Saving feature names for later use
feature_list = list(features.columns)
# Convert to numpy array
features = np.array(features)
ชุดการฝึกอบรมและการทดสอบ
มีขั้นตอนสุดท้ายของการเตรียมข้อมูล: การแบ่งข้อมูลออกเป็นชุดการฝึกอบรมและการทดสอบ ในระหว่างการฝึก เราให้โมเดล 'ดู' คำตอบ ซึ่งในกรณีนี้คืออุณหภูมิจริง เพื่อที่จะได้เรียนรู้วิธีคาดการณ์อุณหภูมิจากคุณลักษณะต่างๆ เราคาดว่าจะมีความสัมพันธ์บางอย่างระหว่างฟีเจอร์ทั้งหมดกับค่าเป้าหมาย และงานของโมเดลคือการเรียนรู้ความสัมพันธ์นี้ระหว่างการฝึก จากนั้น เมื่อถึงเวลาประเมินโมเดล เราจะขอให้โมเดลคาดการณ์ชุดทดสอบที่มีสิทธิ์เข้าถึงเฉพาะฟีเจอร์เท่านั้น (ไม่ใช่คำตอบ)! เนื่องจากเรามีคำตอบจริงสำหรับชุดทดสอบ เราจึงสามารถเปรียบเทียบการคาดการณ์เหล่านี้กับค่าจริงเพื่อตัดสินว่าแบบจำลองมีความแม่นยำเพียงใด โดยทั่วไป เมื่อฝึกโมเดล เราจะสุ่มแบ่งข้อมูลออกเป็น "ชุดการฝึกและการทดสอบ" เพื่อให้ได้จุดข้อมูลทั้งหมด (หากเราฝึกในช่วง 9 เดือนแรกของปี จากนั้นใช้ช่วง 3 เดือนสุดท้ายในการคาดการณ์ เราจะ อัลกอริธึมจะทำงานได้ดีเนื่องจากไม่เห็นข้อมูลใด ๆ ในช่วงสามเดือนที่ผ่านมา) ฉันกำลังตั้งค่าสถานะสุ่มเป็น 42 ซึ่งหมายความว่าผลลัพธ์จะเหมือนกันทุกครั้งที่ฉันเรียกใช้การแยกเพื่อให้ได้ผลลัพธ์ที่ทำซ้ำได้
รหัสต่อไปนี้แยกชุดข้อมูลด้วยบรรทัดเดียว:
# Using Skicit-learn to split data into training and testing sets from sklearn.model_selection import train_test_split # Split the data into training and testing sets train_features, test_features, train_labels, test_labels = train_test_split(features, labels, test_size = 0.25, random_state = 42)
เราสามารถดูรูปร่างของข้อมูลทั้งหมดเพื่อให้แน่ใจว่าเราทำทุกอย่างถูกต้อง เราคาดว่าจำนวนคอลัมน์ของฟีเจอร์การฝึกอบรมจะตรงกับจำนวนคอลัมน์ของฟีเจอร์การทดสอบและจำนวนแถวที่จะตรงกันสำหรับฟีเจอร์การฝึกอบรมและการทดสอบที่เกี่ยวข้องและป้ายกำกับ:
print('Training Features Shape:', train_features.shape)
print('Training Labels Shape:', train_labels.shape)
print('Testing Features Shape:', test_features.shape)
print('Testing Labels Shape:', test_labels.shape)
Training Features Shape: (261, 14)
Training Labels Shape: (261,)
Testing Features Shape: (87, 14)
Testing Labels Shape: (87,)
ดูเหมือนทุกอย่างจะเป็นระเบียบ! สรุปก็คือ เพื่อให้ข้อมูลอยู่ในรูปแบบที่ยอมรับได้สำหรับการเรียนรู้ของเครื่อง เรา:
- ตัวแปรหมวดหมู่ที่เข้ารหัสแบบร้อนแรงหนึ่งรายการ
- แบ่งข้อมูลออกเป็นฟีเจอร์และป้ายกำกับ
- แปลงเป็นอาร์เรย์
- แบ่งข้อมูลออกเป็นชุดการฝึกอบรมและการทดสอบ
ขึ้นอยู่กับชุดข้อมูลเริ่มต้น อาจมีงานเพิ่มเติมที่เกี่ยวข้อง เช่น การลบค่าผิดปกติ "การใส่ค่าที่หายไป" หรือ "การแปลงตัวแปรชั่วคราวให้เป็นการแสดงวัฏจักร" ขั้นตอนเหล่านี้อาจดูเหมือนไม่มีกฎเกณฑ์ในตอนแรก แต่เมื่อคุณได้รับขั้นตอนการทำงานพื้นฐานแล้ว โดยทั่วไปแล้วก็จะเหมือนกันสำหรับปัญหาด้าน Machine Learning ใดๆ มันคือทั้งหมดที่เกี่ยวกับการนำข้อมูลที่มนุษย์สามารถอ่านได้มาจัดวางในรูปแบบที่โมเดลการเรียนรู้ของเครื่องสามารถเข้าใจได้
สร้างพื้นฐาน
ก่อนที่เราจะทำและประเมินการคาดการณ์ได้ เราต้องสร้างพื้นฐาน ซึ่งเป็นการวัดที่สมเหตุสมผลซึ่งเราหวังว่าจะเอาชนะด้วยแบบจำลองของเรา หากแบบจำลองของเราไม่สามารถปรับปรุงตามพื้นฐานได้ แสดงว่าล้มเหลว และเราควรลองใช้โมเดลอื่นหรือยอมรับว่าการเรียนรู้ของเครื่องไม่เหมาะกับปัญหาของเรา การทำนายพื้นฐานสำหรับกรณีของเราอาจเป็นค่าเฉลี่ยอุณหภูมิสูงสุดในอดีต กล่าวอีกนัยหนึ่ง เส้นฐานของเราคือข้อผิดพลาดที่เราจะได้รับหากเราคาดการณ์อุณหภูมิสูงสุดเฉลี่ยตลอดทั้งวัน
# The baseline predictions are the historical averages
baseline_preds = test_features[:, feature_list.index('average')]
# Baseline errors, and display average baseline error
baseline_errors = abs(baseline_preds - test_labels)
print('Average baseline error: ', round(np.mean(baseline_errors), 2))
Average baseline error: 5.06 degrees.
ตอนนี้เรามีเป้าหมายของเราแล้ว! หากเราไม่สามารถเอาชนะข้อผิดพลาดเฉลี่ย 5 องศาได้ เราต้องคิดวิธีการของเราใหม่
โมเดลรถไฟ
หลังจากการเตรียมข้อมูล การสร้างและการฝึกอบรมแบบจำลองก็ค่อนข้างง่าย โดยใช้ Scikit-learn เรานำเข้าแบบจำลองการถดถอยของฟอเรสต์แบบสุ่มจาก skicit-learn สร้างอินสแตนซ์ของแบบจำลอง และปรับให้เหมาะสม (ชื่อของ scikit-learn สำหรับการฝึกอบรม) แบบจำลองกับข้อมูลการฝึกอบรม (ตั้งค่าสถานะสุ่มอีกครั้งเพื่อให้ได้ผลลัพธ์ที่ทำซ้ำได้) กระบวนการทั้งหมดนี้มีเพียง 3 บรรทัดใน scikit-learn!
# Import the model we are using from sklearn.ensemble import RandomForestRegressor # Instantiate model with 1000 decision trees rf = RandomForestRegressor(n_estimators = 1000, random_state = 42) # Train the model on training data rf.fit(train_features, train_labels);
ทำนายชุดทดสอบ
ขณะนี้โมเดลของเราได้รับการฝึกอบรมเพื่อเรียนรู้ความสัมพันธ์ระหว่างฟีเจอร์และเป้าหมาย ขั้นตอนต่อไปคือการหาคำตอบว่าโมเดลนั้นดีแค่ไหน! ในการดำเนินการนี้ เราจะคาดการณ์คุณลักษณะการทดสอบ (แบบจำลองไม่ได้รับอนุญาตให้ดูคำตอบของการทดสอบ) จากนั้นเราจะเปรียบเทียบการทำนายกับคำตอบที่ทราบ เมื่อทำการถดถอย เราต้องแน่ใจว่าใช้ข้อผิดพลาดสัมบูรณ์เพราะเราคาดว่าคำตอบบางข้อจะต่ำและบางข้อก็สูง เราสนใจว่าการคาดการณ์โดยเฉลี่ยของเราอยู่ห่างจากค่าจริงเพียงใด ดังนั้นเราจึงหาค่าสัมบูรณ์ (เหมือนที่เราเคยทำเมื่อสร้างเส้นฐาน)
การคาดการณ์โดยไม่ใช้โมเดลถือเป็นคำสั่ง 1 บรรทัดใน Skicit-learn
# Use the forest's predict method on the test data
predictions = rf.predict(test_features)
# Calculate the absolute errors
errors = abs(predictions - test_labels)
# Print out the mean absolute error (mae)
print('Mean Absolute Error:', round(np.mean(errors), 2), 'degrees.')
Mean Absolute Error: 3.83 degrees.
ค่าเฉลี่ยของเราลดลง 3.83 องศา นั่นคือการปรับปรุงโดยเฉลี่ยมากกว่า 1 องศาเหนือระดับพื้นฐาน แม้ว่าสิ่งนี้อาจดูไม่สำคัญ แต่ก็ดีกว่าพื้นฐานเกือบ 25% ซึ่งอาจสร้างรายได้หลายล้านดอลลาร์ให้กับบริษัท ทั้งนี้ขึ้นอยู่กับสาขาและปัญหา
กำหนดตัวชี้วัดประสิทธิภาพ
เพื่อให้การคาดการณ์เป็นมุมมอง เราสามารถคำนวณความแม่นยำโดยใช้เปอร์เซ็นต์ความคลาดเคลื่อนเฉลี่ยเฉลี่ยที่หักออกจาก 100 %
# Calculate mean absolute percentage error (MAPE)
mape = 100 * (errors / test_labels)
# Calculate and display accuracy
accuracy = 100 - np.mean(mape)
print('Accuracy:', round(accuracy, 2), '%.')
Accuracy: 93.99 %.
นั่นดูดีทีเดียว! แบบจำลองของเราได้เรียนรู้วิธีทำนายอุณหภูมิสูงสุดสำหรับวันถัดไปในซีแอตเทิลด้วยความแม่นยำ 94%
ปรับปรุงโมเดลหากจำเป็น
ในเวิร์กโฟลว์แมชชีนเลิร์นนิงตามปกติ นี่จะเป็นเมื่อเริ่มการปรับแต่งไฮเปอร์พารามิเตอร์ นี่เป็นวลีที่ซับซ้อนซึ่งหมายถึง "ปรับการตั้งค่าเพื่อปรับปรุงประสิทธิภาพ" (การตั้งค่านี้เรียกว่า "ไฮเปอร์พารามิเตอร์" เพื่อแยกความแตกต่างจากพารามิเตอร์โมเดลที่เรียนรู้ระหว่างการฝึก) วิธีที่พบบ่อยที่สุดในการทำเช่นนี้คือสร้างโมเดลจำนวนมากที่มีการตั้งค่าที่แตกต่างกัน ประเมินโมเดลทั้งหมดโดยใช้ชุดการตรวจสอบเดียวกัน และดูว่าโมเดลใดทำงานได้ดีที่สุด แน่นอนว่านี่อาจเป็นกระบวนการที่น่าเบื่อหากต้องทำด้วยตนเอง และมี วิธีการอัตโนมัติ ในการทำกระบวนการนี้ใน Skicit-learn การปรับไฮเปอร์พารามิเตอร์มักจะเป็น "วิศวกรรม" มากกว่าตามทฤษฎี และฉันขอแนะนำให้ทุกคนที่สนใจตรวจสอบ "เอกสารประกอบ" และเริ่มลองเล่นดู! ความแม่นยำ 94% เป็นที่น่าพอใจสำหรับปัญหานี้ แต่โปรดจำไว้ว่าโมเดลแรกที่สร้างขึ้นแทบจะไม่มีวันเป็นโมเดลที่ผลิตจริงเลย
ตีความแบบจำลองและรายงานผลลัพธ์
ณ จุดนี้ เรารู้ว่าโมเดลของเราดี แต่ก็ค่อนข้างจะเป็น "กล่องดำ" เราป้อนอาร์เรย์ Numpy บางตัวเพื่อฝึกฝน ขอให้มันทำการทำนาย ประเมินการทำนาย และดูว่าพวกมันสมเหตุสมผล คำถามคือ โมเดลนี้มาถึงค่านิยมได้อย่างไร มีสองวิธีในการเข้าไปในป่าสุ่ม ประการแรก เราสามารถดูต้นไม้ต้นเดียวในป่า และประการที่สอง เราสามารถดูความสำคัญของคุณลักษณะของตัวแปรอธิบายของเรา
การแสดงภาพต้นไม้การตัดสินใจเดี่ยว
หนึ่งในส่วนที่เจ๋งที่สุดของการใช้ Random Forest ใน Skicit-learn คือเราสามารถตรวจสอบต้นไม้ในป่าได้จริงๆ เราจะเลือกต้นไม้หนึ่งต้น และบันทึกต้นไม้ทั้งต้นเป็นรูปภาพ
รหัสต่อไปนี้นำต้นไม้หนึ่งต้นจากฟอเรสต์และบันทึกเป็นรูปภาพ
# Import tools needed for visualization
from sklearn.tree import export_graphviz
import pydot
# Pull out one tree from the forest
tree = rf.estimators_[5]
# Import tools needed for visualization
from sklearn.tree import export_graphviz
import pydot
# Pull out one tree from the forest
tree = rf.estimators_[5]
# Export the image to a dot file
export_graphviz(tree, out_file = 'tree.dot', feature_names = feature_list, rounded = True, precision = 1)
# Use dot file to create a graph
(graph, ) = pydot.graph_from_dot_file('tree.dot')
# Write graph to a png file
graph.write_png('tree.png')
มาดูกัน:
ว้าว! ดูเหมือนต้นไม้ค่อนข้างใหญ่มี 15 ชั้น (จริงๆ แล้วเป็นต้นไม้ที่ค่อนข้างเล็กเมื่อเทียบกับบางต้นที่ฉันเคยเห็น) คุณสามารถ ดาวน์โหลดภาพนี้ ได้ด้วยตัวเองและตรวจสอบรายละเอียดมากขึ้น แต่เพื่อให้ง่ายขึ้น ฉันจะจำกัดความลึกของต้นไม้ในป่าเพื่อสร้างภาพที่เข้าใจได้
# Limit depth of tree to 3 levels
rf_small = RandomForestRegressor(n_estimators=10, max_depth = 3)
rf_small.fit(train_features, train_labels)
# Extract the small tree
tree_small = rf_small.estimators_[5]
# Save the tree as a png image
export_graphviz(tree_small, out_file = 'small_tree.dot', feature_names = feature_list, rounded = True, precision = 1)
(graph, ) = pydot.graph_from_dot_file('small_tree.dot')
graph.write_png('small_tree.png');
นี่คือต้นไม้ขนาดลดขนาดที่มีคำอธิบายประกอบพร้อมป้ายกำกับ
จากแผนผังนี้เพียงอย่างเดียว เราสามารถคาดการณ์จุดข้อมูลใหม่ได้ มาดูตัวอย่างการทำนายสำหรับวันพุธที่ 27 ธันวาคม 2017 ตัวแปร (จริง) ได้แก่: temp_2 = 39, temp_1 = 35, ค่าเฉลี่ย = 44 และเพื่อน = 30 เราเริ่มต้นที่โหนดรูทและคำตอบแรก เป็นจริงเนื่องจาก temp_1 ≤ 59.5 เราเคลื่อนไปทางซ้ายแล้วพบกับคำถามที่สอง ซึ่งก็คือ จริง เช่นกัน โดยเฉลี่ย ≤ 46.8 เลื่อนลงไปทางซ้ายและต่อไปยังคำถามที่สามซึ่งเป็นคำถามสุดท้ายซึ่งเป็น True เช่นกัน เพราะ temp_1 ≤ 44.5 ดังนั้นเราจึงสรุปได้ว่าค่าประมาณอุณหภูมิสูงสุดของเราคือ 41.0 องศา ตามค่าที่ระบุในโหนดใบ ข้อสังเกตที่น่าสนใจคือในโหนดรูท มีเพียง 162 ตัวอย่าง แม้ว่าจะมีจุดข้อมูลการฝึก 261 จุดก็ตาม เนื่องจากต้นไม้แต่ละต้นในป่าได้รับการฝึกฝนบนชุดย่อยแบบสุ่มของจุดข้อมูลที่มีการแทนที่ (เรียกว่า "การบรรจุถุง ย่อมาจาก การรวมบูตสแตรป") (เราสามารถปิดการสุ่มตัวอย่างด้วยการแทนที่ และใช้จุดข้อมูลทั้งหมดโดยการตั้งค่า bootstrap = False เมื่อสร้างฟอเรสต์) การสุ่มตัวอย่างจุดข้อมูล รวมกับการสุ่มตัวอย่างชุดย่อยของคุณลักษณะที่แต่ละโหนดของแผนผัง เป็นสาเหตุว่าทำไมแบบจำลองนี้จึงเรียกว่าฟอเรสต์ 'สุ่ม'
นอกจากนี้ โปรดสังเกตด้วยว่าในแผนภูมิต้นไม้ของเรา มีเพียง 2 ตัวแปรที่เราใช้ทำนายจริงๆ! ตามแผนผังการตัดสินใจนี้ คุณสมบัติที่เหลือไม่สำคัญสำหรับการคาดการณ์ เดือนของปี วันเดือน และการทำนายของเพื่อนไม่มีประโยชน์อะไรในการทำนายอุณหภูมิสูงสุดในวันพรุ่งนี้! ข้อมูลสำคัญเพียงอย่างเดียวตามแผนภูมิง่าย ๆ ของเราคืออุณหภูมิ 1 วันก่อนและค่าเฉลี่ยในอดีต การแสดงภาพต้นไม้ได้เพิ่มพูนความรู้โดเมนของเราเกี่ยวกับปัญหา และตอนนี้เรารู้แล้วว่าข้อมูลใดที่ควรค้นหาหากเราถูกขอให้ทำการคาดการณ์!
ความสำคัญของตัวแปร
เพื่อที่จะหาปริมาณประโยชน์ของตัวแปรทั้งหมดในฟอเรสต์สุ่มทั้งหมด เราสามารถดูความสำคัญสัมพัทธ์ของตัวแปรได้ ความสำคัญที่ส่งคืนใน Skicit-learn แสดงถึงจำนวนตัวแปรเฉพาะที่ช่วยปรับปรุงการทำนายได้มากน้อยเพียงใด การคำนวณความสำคัญที่แท้จริงนั้นอยู่นอกเหนือขอบเขตของโพสต์นี้ แต่เราสามารถใช้ตัวเลขเพื่อทำการเปรียบเทียบแบบสัมพัทธ์ระหว่างตัวแปรต่างๆ ได้
โค้ดที่นี่ใช้ประโยชน์จากกลเม็ดต่างๆ ในภาษา Python ได้แก่ "รายการที่ครอบคลุม" "zip" "การเรียงลำดับ" และ "การคลายอาร์กิวเมนต์" ในตอนนี้การทำความเข้าใจสิ่งเหล่านี้ไม่ใช่เรื่องสำคัญ แต่ถ้าคุณต้องการเชี่ยวชาญ Python สิ่งเหล่านี้คือเครื่องมือที่คุณควรมีติดตัวไว้!
# Get numerical feature importances
importances = list(rf.feature_importances_)
# List of tuples with variable and importance
feature_importances = [(feature, round(importance, 2)) for feature, importance in zip(feature_list, importances)]
# Sort the feature importances by most important first
feature_importances = sorted(feature_importances, key = lambda x: x[1], reverse = True)
# Print out the feature and importances
[print('Variable: {:20} Importance: {}'.format(*pair)) for pair in feature_importances];
Variable: temp_1 Importance: 0.7
Variable: average Importance: 0.19
Variable: day Importance: 0.03
Variable: temp_2 Importance: 0.02
Variable: friend Importance: 0.02
Variable: month Importance: 0.01
Variable: year Importance: 0.0
Variable: week_Fri Importance: 0.0
Variable: week_Mon Importance: 0.0
Variable: week_Sat Importance: 0.0
Variable: week_Sun Importance: 0.0
Variable: week_Thurs Importance: 0.0
Variable: week_Tues Importance: 0.0
Variable: week_Wed Importance: 0.0
ที่ด้านบนของรายการคือ temp_1 ซึ่งเป็นอุณหภูมิสูงสุดของวันก่อน ข้อมูลนี้บอกเราว่าตัวทำนายอุณหภูมิสูงสุดในหนึ่งวันได้ดีที่สุดคืออุณหภูมิสูงสุดของวันก่อน ซึ่งเป็นการค้นพบที่ค่อนข้างเข้าใจง่าย ปัจจัยที่สำคัญที่สุดอันดับสองคืออุณหภูมิสูงสุดเฉลี่ยในอดีต ซึ่งก็ไม่น่าแปลกใจเช่นกัน เพื่อนของคุณกลับกลายเป็นว่าช่วยได้ไม่มากนัก รวมถึงวันในสัปดาห์ ปี เดือน และอุณหภูมิเมื่อ 2 วันก่อน ความสำคัญเหล่านี้ล้วนสมเหตุสมผลเนื่องจากเราไม่ได้คาดหวังให้วันในสัปดาห์เป็นตัวทำนายอุณหภูมิสูงสุด เนื่องจากไม่เกี่ยวข้องกับสภาพอากาศ นอกจากนี้ ปีจะเหมือนกันสำหรับจุดข้อมูลทั้งหมด จึงทำให้เราไม่มีข้อมูลในการทำนายอุณหภูมิสูงสุด
ในการใช้งานโมเดลในอนาคต เราสามารถลบตัวแปรที่ไม่มีความสำคัญออกได้ และประสิทธิภาพจะไม่ได้รับผลกระทบ นอกจากนี้ หากเราใช้โมเดลอื่น เช่น เครื่องเวกเตอร์ที่รองรับ เราสามารถใช้ความสำคัญของฟีเจอร์ฟอเรสต์แบบสุ่มเป็นวิธีการเลือกฟีเจอร์ประเภทหนึ่งได้ มาสร้างฟอเรสต์แบบสุ่มโดยมีเพียงตัวแปรที่สำคัญที่สุดสองตัวอย่างรวดเร็ว อุณหภูมิสูงสุด 1 วันก่อนหน้า และค่าเฉลี่ยในอดีต แล้วดูว่าประสิทธิภาพเปรียบเทียบกันอย่างไร
# New random forest with only the two most important variables
rf_most_important = RandomForestRegressor(n_estimators= 1000, random_state=42)
# Extract the two most important features
important_indices = [feature_list.index('temp_1'), feature_list.index('average')]
train_important = train_features[:, important_indices]
test_important = test_features[:, important_indices]
# Train the random forest
rf_most_important.fit(train_important, train_labels)
# Make predictions and determine the error
predictions = rf_most_important.predict(test_important)
errors = abs(predictions - test_labels)
# Display the performance metrics
print('Mean Absolute Error:', round(np.mean(errors), 2), 'degrees.')
mape = np.mean(100 * (errors / test_labels))
accuracy = 100 - mape
print('Accuracy:', round(accuracy, 2), '%.')
Mean Absolute Error: 3.9 degrees.
Accuracy: 93.8 %.
สิ่งนี้บอกเราว่าจริง ๆ แล้วเราไม่ต้องการข้อมูลทั้งหมดที่เรารวบรวมมาเพื่อคาดการณ์ที่แม่นยำ! หากเราใช้โมเดลนี้ต่อไป เราจะรวบรวมได้เพียง 2 ตัวแปรและบรรลุประสิทธิภาพที่เกือบจะเท่าเดิม ในการตั้งค่าการผลิต เราจะต้องชั่งน้ำหนักความแม่นยำที่ลดลงเทียบกับเวลาพิเศษที่ต้องใช้ในการรับข้อมูลเพิ่มเติม การรู้วิธีหาสมดุลที่เหมาะสมระหว่างประสิทธิภาพและราคาเป็นทักษะที่จำเป็นสำหรับวิศวกร Machine Learning และท้ายที่สุดจะขึ้นอยู่กับปัญหา!
ณ จุดนี้ เราได้ครอบคลุมทุกสิ่งที่ควรรู้สำหรับการดำเนินการขั้นพื้นฐานของฟอเรสต์สุ่มสำหรับปัญหาการถดถอยภายใต้การดูแล เรามั่นใจได้ว่าแบบจำลองของเราสามารถทำนายอุณหภูมิสูงสุดในวันพรุ่งนี้ได้อย่างแม่นยำ 94% จากข้อมูลในอดีตหนึ่งปี จากที่นี่ คุณสามารถลองใช้ตัวอย่างนี้ได้ตามใจชอบ หรือใช้แบบจำลองกับชุดข้อมูลที่คุณเลือก ฉันจะสรุปโพสต์นี้ด้วยการสร้างภาพข้อมูลบางส่วน สองส่วนที่ฉันชอบที่สุดในวิทยาศาสตร์ข้อมูลคือการสร้างกราฟและการสร้างแบบจำลอง ดังนั้นโดยธรรมชาติแล้วฉันจึงต้องสร้างแผนภูมิขึ้นมา! นอกจากความเพลิดเพลินในการดูแล้ว แผนภูมิยังช่วยให้เราวิเคราะห์แบบจำลองของเราได้ เนื่องจากแผนภูมิจะบีบอัดตัวเลขจำนวนมากให้เป็นรูปภาพที่เราสามารถตรวจสอบได้อย่างรวดเร็ว
การแสดงภาพ
แผนภูมิแรกที่ฉันจะทำคือแผนภูมิแท่งอย่างง่ายของความสำคัญของคุณลักษณะ เพื่อแสดงให้เห็นความแตกต่างในนัยสำคัญสัมพัทธ์ของตัวแปร การลงจุดใน Python นั้นไม่เป็นไปตามสัญชาตญาณ และสุดท้ายฉันก็ค้นหาเกือบทุกอย่างใน "Stack Overflow" เมื่อสร้างกราฟ อย่ากังวลหากโค้ดที่นี่ไม่ค่อยสมเหตุสมผล บางครั้งการทำความเข้าใจโค้ดอย่างถ่องแท้ก็ไม่จำเป็นเพื่อให้ได้ผลลัพธ์ที่คุณต้องการ!
# Import matplotlib for plotting and use magic command for Jupyter Notebooks
import matplotlib.pyplot as plt
%matplotlib inline
# Set the style
plt.style.use('fivethirtyeight')
# list of x locations for plotting
x_values = list(range(len(importances)))
# Make a bar chart
plt.bar(x_values, importances, orientation = 'vertical')
# Tick labels for x axis
plt.xticks(x_values, feature_list, rotation='vertical')
# Axis labels and title
plt.ylabel('Importance'); plt.xlabel('Variable'); plt.title('Variable Importances');
ต่อไป เราสามารถพล็อตชุดข้อมูลทั้งหมดโดยเน้นการคาดคะเนไว้ได้ ต้องใช้การจัดการข้อมูลเล็กน้อย แต่ก็ไม่ยากเกินไป เราสามารถใช้พล็อตนี้เพื่อพิจารณาว่ามีค่าผิดปกติในข้อมูลหรือการคาดการณ์ของเราหรือไม่
# Use datetime for creating date objects for plotting
import datetime
# Dates of training values
months = features[:, feature_list.index('month')]
days = features[:, feature_list.index('day')]
years = features[:, feature_list.index('year')]
# List and then convert to datetime object
dates = [str(int(year)) + '-' + str(int(month)) + '-' + str(int(day)) for year, month, day in zip(years, months, days)]
dates = [datetime.datetime.strptime(date, '%Y-%m-%d') for date in dates]
# Dataframe with true values and dates
true_data = pd.DataFrame(data = {'date': dates, 'actual': labels})
# Dates of predictions
months = test_features[:, feature_list.index('month')]
days = test_features[:, feature_list.index('day')]
years = test_features[:, feature_list.index('year')]
# Column of dates
test_dates = [str(int(year)) + '-' + str(int(month)) + '-' + str(int(day)) for year, month, day in zip(years, months, days)]
# Convert to datetime objects
test_dates = [datetime.datetime.strptime(date, '%Y-%m-%d') for date in test_dates]
# Dataframe with predictions and dates
predictions_data = pd.DataFrame(data = {'date': test_dates, 'prediction': predictions})
# Plot the actual values
plt.plot(true_data['date'], true_data['actual'], 'b-', label = 'actual')
# Plot the predicted values
plt.plot(predictions_data['date'], predictions_data['prediction'], 'ro', label = 'prediction')
plt.xticks(rotation = '60');
plt.legend()
# Graph labels
plt.xlabel('Date'); plt.ylabel('Maximum Temperature (F)'); plt.title('Actual and Predicted Values');
งานเล็กๆ น้อยๆ เพื่อกราฟสวยๆ! ดูเหมือนเราจะไม่มีค่าผิดปกติที่เห็นได้ชัดเจนซึ่งจำเป็นต้องแก้ไข เพื่อวินิจฉัยแบบจำลองเพิ่มเติม เราสามารถพล็อตส่วนที่เหลือ (ข้อผิดพลาด) เพื่อดูว่าแบบจำลองของเรามีแนวโน้มที่จะคาดการณ์สูงเกินไปหรือคาดการณ์ต่ำเกินไป และเรายังสามารถดูได้ว่าส่วนที่เหลือมีการกระจายตามปกติหรือไม่ อย่างไรก็ตาม ฉันจะสร้างแผนภูมิสุดท้ายที่แสดงค่าจริง อุณหภูมิหนึ่งวันก่อนหน้า ค่าเฉลี่ยในอดีต และคำทำนายของเพื่อนเรา สิ่งนี้จะช่วยให้เราเห็นความแตกต่างระหว่างตัวแปรที่มีประโยชน์กับตัวแปรที่ไม่มีประโยชน์มากนัก
# Make the data accessible for plotting
true_data['temp_1'] = features[:, feature_list.index('temp_1')]
true_data['average'] = features[:, feature_list.index('average')]
true_data['friend'] = features[:, feature_list.index('friend')]
# Plot all the data as lines
plt.plot(true_data['date'], true_data['actual'], 'b-', label = 'actual', alpha = 1.0)
plt.plot(true_data['date'], true_data['temp_1'], 'y-', label = 'temp_1', alpha = 1.0)
plt.plot(true_data['date'], true_data['average'], 'k-', label = 'average', alpha = 0.8)
plt.plot(true_data['date'], true_data['friend'], 'r-', label = 'friend', alpha = 0.3)
# Formatting plot
plt.legend(); plt.xticks(rotation = '60');
# Lables and title
plt.xlabel('Date'); plt.ylabel('Maximum Temperature (F)'); plt.title('Actual Max Temp and Variables');
ยากที่จะเข้าใจทุกบรรทัด แต่เราเข้าใจได้ว่าทำไมอุณหภูมิสูงสุดในหนึ่งวันก่อนและอุณหภูมิสูงสุดในอดีตจึงมีประโยชน์ในการทำนายอุณหภูมิสูงสุดในขณะที่เพื่อนของเราไม่เป็นเช่นนั้น (อย่าเพิ่งยอมแพ้เพื่อน แต่อาจจะไม่ให้น้ำหนักกับการประมาณการมากนัก!) กราฟเช่นนี้มักจะมีประโยชน์ในการจัดทำล่วงหน้าเพื่อให้เราสามารถเลือกตัวแปรที่จะรวมไว้ได้ แต่ก็สามารถนำมาใช้ในการวินิจฉัยได้เช่นกัน เช่นเดียวกับในกรณีของ "Anscombe's quartet" กราฟมักจะเปิดเผยมากกว่าตัวเลขเชิงปริมาณ และควรเป็นส่วนหนึ่งของเวิร์กโฟลว์แมชชีนเลิร์นนิง
ข้อสรุป
ด้วยกราฟเหล่านี้ เราได้ทำตัวอย่างการเรียนรู้ของเครื่องแบบครบวงจรเสร็จสิ้นแล้ว! ณ จุดนี้ หากเราต้องการปรับปรุงโมเดลของเรา เราอาจลองใช้ไฮเปอร์พารามิเตอร์ (การตั้งค่า) ที่แตกต่างกัน ลองใช้อัลกอริธึมอื่น หรือวิธีที่ดีที่สุดคือรวบรวมข้อมูลให้มากขึ้น! ประสิทธิภาพของโมเดลใดๆ ก็ตามจะเป็นสัดส่วนโดยตรงกับจำนวนข้อมูลที่ถูกต้อง ที่สามารถเรียนรู้ได้ และเราใช้ข้อมูลจำนวนจำกัดมากในการฝึกอบรม ฉันขอแนะนำให้ทุกคนลองปรับปรุงโมเดลนี้และแบ่งปันผลลัพธ์ จากที่นี่ คุณสามารถเจาะลึกเพิ่มเติมเกี่ยวกับ "ทฤษฎีป่าสุ่ม" และการประยุกต์ใช้งานโดยใช้ "แหล่งข้อมูลออนไลน์ (ฟรี)" มากมาย สำหรับผู้ที่มองหาหนังสือเล่มเดียวที่ครอบคลุมทั้งทฤษฎีและการใช้งาน Python ของโมเดล Machine Learning ฉันขอแนะนำ "การเรียนรู้ของเครื่องแบบลงมือปฏิบัติด้วย Scikit-Learn และ Tensorflow" เป็นอย่างยิ่ง นอกจากนี้ ฉันหวังว่าทุกคนที่ผ่านมันมาได้จะได้เห็นแล้วว่าการเรียนรู้ของเครื่องที่เข้าถึงได้กลายมาเป็นอย่างไรบ้าง และพร้อมที่จะเข้าร่วม "ชุมชนการเรียนรู้ของเครื่อง" ที่เป็นมิตรและพร้อมให้ความช่วยเหลือ
และเช่นเคย ฉันยินดีรับข้อเสนอแนะและคำวิจารณ์ที่สร้างสรรค์! อีเมลของฉันคือ [email protected]
