การดูพฤติกรรมไม่เชิงเส้นของแผนผังการตัดสินใจและฟอเรสต์สุ่มในการแก้ปัญหาการถดถอย

ทำความเข้าใจว่าโมเดล Machine Learning เหล่านี้ทำงานอย่างไรโดยการแสดงภาพพฤติกรรมในพื้นที่สามมิติ

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

สารบัญ

บทนำ
แผนผังการตัดสินใจและป่าสุ่ม
การวิเคราะห์ข้อมูล
การวางแผนแบบจำลอง
— ภาพรวม
— การฝึกอบรม/การแยกการตรวจสอบ
— ชุดข้อมูลประดิษฐ์
— ตารางเสริม< br /> แบบจำลอง
— แบบจำลองค่าเฉลี่ยพื้นฐาน
— แบบจำลองการถดถอยเชิงเส้น
— แบบจำลองต้นไม้การตัดสินใจ
— แบบจำลองฟอเรสต์แบบสุ่ม
หมายเหตุสรุป

บทนำ

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

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

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

ต้นไม้ตัดสินใจและป่าสุ่ม

แผนผังการตัดสินใจ มีชื่อนี้เนื่องจากมีโครงสร้างคล้ายแผนผัง: จากโหนดรากเริ่มต้นเดียว (ซึ่งมีข้อมูลตัวอย่างทั้งหมด 'อยู่ข้างใน') อัลกอริธึมจะค้นหาคุณลักษณะซ้ำ ๆ เพื่อค้นหาการแยกที่เหมาะสมที่สุด จุดที่แยกชุดย่อยข้อมูลที่สรุปส่วนหนึ่งของเป้าหมายโดยมีข้อผิดพลาดน้อยที่สุด จากนั้น สำหรับเซ็ตย่อยนี้ อัลกอริธึมจะทำซ้ำขั้นตอนการค้นหาเพื่อค้นหาจุดแยกที่เหมาะสมที่สุด และต่อไปเรื่อยๆ จนกว่าจะถึงเกณฑ์การหยุด (เช่น ได้ระดับความลึกที่ระบุ) เมื่อโหนดเทอร์มินัลนี้บรรลุผลแล้ว ขั้นตอนถัดไปของอัลกอริทึมจะเกี่ยวข้องกับการแก้ปัญหาการแยกส่วนย่อยที่เหลือ ผลลัพธ์ที่ได้คือชุดของโหนดเทอร์มินัลที่สร้างการคาดการณ์เป้าหมายโดยลดข้อผิดพลาดให้เหลือน้อยที่สุด รูปด้านล่างแสดงตัวอย่างสมมุติฐานของแผนผังการตัดสินใจที่มีคุณสมบัติสองประการ (x1 และ x2) อัลกอริธึมใช้ x2 เพื่อแยกโหนด 0 ออกเป็นกิ่ง 1 และ 4 จากนั้นโหนด 1 ลงในโหนดเทอร์มินัล 2 และ 3 หลังจากนั้น อัลกอริธึมจะแก้ไขส่วนที่เหลือโดยใช้ x1

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

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

ในบทความนี้ เราจะเห็นภาพการทำงานของแบบจำลองเหล่านี้ ตลอดจนคุณลักษณะและพฤติกรรมของแบบจำลองเหล่านี้ ฉันเลือกชุดข้อมูลขนาดเล็กเพื่อความเรียบง่าย มาทำการวิเคราะห์ข้อมูลเชิงสำรวจก่อนเริ่มงานการสร้างแบบจำลองกัน!

การวิเคราะห์ข้อมูล

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

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

from matplotlib import gridspec
from mpl_toolkits.mplot3d import Axes3D

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.tree import export_graphviz
from sklearn.tree import export_text
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error

import warnings # For disabling a warning message from dtreeviz
import graphviz
from dtreeviz.trees import dtreeviz 
from IPython.display import SVG

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

# Dataframe df gets the csv file 'Student_Marks.csv'
df = pd.read_csv('Student_Marks.csv')
display( df.head() ) # display the first 5 rows

สถิติเชิงพรรณนาด้านล่างแสดงให้เห็นว่าชุดข้อมูลประกอบด้วยการสังเกต 100 รายการ, number_courses เป็นตัวแปรแยกตั้งแต่ 3 ถึง 8, time_study เป็นตัวแปรต่อเนื่องตั้งแต่ 0.096 ถึง 7.957 และ เครื่องหมายเป็นตัวแปรต่อเนื่องตั้งแต่ 5.609 ถึง 55.299

ดังที่เราเห็นในแปลงด้านล่าง คุณลักษณะต่างๆ มีความสัมพันธ์แบบไม่เชิงเส้นกับเป้าหมาย เมื่อพิจารณาจาก number_courses(แผงด้านซ้าย) มีแนวโน้มกระจายและอ่อนแอสำหรับคะแนนที่สูงขึ้นและมีจำนวนหลักสูตรมากขึ้น เราจะเห็นรูปแบบค่าเฉลี่ยที่แตกต่างกันสองรูปแบบ — ประมาณ 19 สำหรับ 3 ถึง 5 คอร์ส และประมาณ 30 สำหรับ 6 ถึง 8 คอร์ส เมื่อพิจารณาจาก time_study(แผงด้านขวา) มีรูปแบบที่ชัดเจนในการเพิ่มคะแนนพร้อมกับเวลาศึกษาที่เพิ่มขึ้น การสังเกตใกล้สุดขั้วทั้งสองเบี่ยงเบนไปจากความเป็นเส้นตรง และรูปแบบโดยรวมอธิบายได้ดีกว่าโดยใช้เส้นโค้งมากกว่าเส้นตรง

แนวคิดก็คือการใช้ทั้งสองคุณสมบัติ — number_courses และ time_study — เพื่อทำนายคะแนนของนักเรียน ในแผนภาพสามมิติด้านล่าง เราสามารถสังเกตพฤติกรรมไม่เชิงเส้นที่เราจะสร้างแบบจำลองและแสดงภาพการถดถอยได้

การวางแผนแบบจำลอง

ภาพรวม

แนวทางที่ฉันนำมาใช้ประกอบด้วยการพัฒนาแบบจำลองสี่แบบ:

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

มีการนำขั้นตอนต่อไปนี้มาใช้:

ข้อมูลถูกแบ่งออกเป็น ชุดการฝึก (70%) และ ชุดการตรวจสอบ (30%) สำหรับการประเมินประสิทธิภาพของโมเดลด้วยข้อมูลใหม่ที่ไม่เคยเห็นมาก่อน
ประสิทธิภาพในการตรวจสอบได้รับการประเมินโดย ค่าคลาดเคลื่อนสัมบูรณ์เฉลี่ย(หรือ MAE) ซึ่งบ่งชี้ว่าการคาดการณ์เบี่ยงเบนไปจากค่าจริงโดยเฉลี่ยมากน้อยเพียงใด ยิ่ง MAE มีค่าน้อย การคาดการณ์ก็จะใกล้เคียงกับค่าจริงมากที่สุด
ก่อนหน้าแผนผังการตัดสินใจขั้นสุดท้ายและแบบจำลองฟอเรสต์แบบสุ่ม ฉันได้ติดตามการปรับพารามิเตอร์ให้เหมาะสมเพื่อให้แน่ใจว่ามีการสรุปข้อมูลทั่วไปที่เพียงพอกับข้อมูลใหม่
สำหรับการแสดงภาพพฤติกรรมของแบบจำลอง ฉันได้สร้างชุดข้อมูลเทียมซึ่งประกอบด้วยการรวมกันระหว่างค่าที่เป็นไปได้ของ number_courses (เช่น ตัวเลขหกตัว ตั้งแต่ 3 ถึง 8) และ time_study โดยมีตัวเลข 100 ตัวเว้นระยะเท่ากันระหว่าง 0.096 ถึง 7.957 คู่ 600 คู่นี้ได้รับการประมวลผลโดยแบบจำลองที่ผ่านการฝึกอบรมเพื่อวางแผนช่วงของการคาดการณ์

แยกการฝึก/การตรวจสอบ

แบบจำลองได้รับการฝึกอบรมโดยใช้ข้อมูล 70% และ 30% ใช้สำหรับการตรวจสอบความถูกต้อง ตัวอย่างด้านล่างแสดงการแบ่งการทดสอบรถไฟ

# Separating the Features and the Target
X = df[['number_courses', 'time_study']]
y = df['Marks']

# Splitting the dataset into train and validation sets
X_train, X_valid, y_train, y_valid = train_test_split(X, y,
                                                      test_size=0.3, 
                                                      random_state=13)

# X_train: 70 rows, 2 columns, y_train: 70 rows, 1 column
# X_valid: 30 rows, 2 columns, y_valid: 30 rows, 1 column

ชุดข้อมูลประดิษฐ์

ตัวอย่างด้านล่างแสดงการสร้างตัวเลข 600 คู่โดยพิจารณาจากค่าผสมระหว่างค่า number_courses ที่เป็นไปได้ 6 ค่า และค่า time_study ที่เป็นไปได้ 100 ค่า ห้าแถวแรกและแถวสุดท้ายของชุดข้อมูลนี้จะแสดงอยู่ด้านล่าง

# Create values for plotting the solution space of the models

# Generate a set of values for x1 and x2 coordinates
# x1 values range from 3 to 8
x1_values = np.arange(df['number_courses'].min(),df['number_courses'].max() + 1, 1) 

# x2 values range between min and max 
# This generates 100 equally spaced values between min and max:
x2_values = np.linspace(df['time_study'].min(), df['time_study'].max(), 100) 

# Combinatory between coordinates
x1_values, x2_values = np.meshgrid(x1_values, x2_values)
X_artif = np.array([x1_values.flatten(), x2_values.flatten()]).T

# Create a dataframe and display the first and last 5 rows
X_artif = pd.DataFrame(X_artif, columns=['number_courses', 'time_study'])

display( X_artif )

ตารางเสริม

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

# List of models
models = ['Mean Model',
          'Linear Regression Model',
          'Decision Tree Model',
          'Random Forest Model']
# List of columns
cols = ['Error (Train)', 'Error (Validation)']

# DF with models as index
df_models = pd.DataFrame(index=models, columns=cols)

# Create a DF for the validation set and log models' predictions
df_valid = pd.concat([X_valid, y_valid], axis=1)

โมเดล

แบบจำลองค่าเฉลี่ยพื้นฐาน

โดยเป็นจุดเริ่มต้น ฉันได้พิจารณา Mean Model แบบธรรมดาเพื่อใช้เป็นข้อมูลอ้างอิง เพียงแต่ส่งกลับค่าเฉลี่ยของชุดการฝึกไปยังชุดการทดสอบใดๆ ที่มีให้ ดังที่แสดงในฟังก์ชันด้านล่าง:

# This function returns an array with the mean of the training set target
def mean_model(y_train, X_test):
    return np.array( [y_train.mean()] * X_test.shape[0] )

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

# Predictions for the validation set
df_valid['y_mean'] = mean_model(y_train, X_valid)

# Generate predictions based on the artificial data
predictions_m = mean_model(y_train, X_artif)

# Compute MAE - Train and Valid
mae_train_m_model = mean_absolute_error(y_train, mean_model(y_train, X_train))
mae_valid_m_model = mean_absolute_error(y_valid, df_valid['y_mean'])

# Log in the DF and display the results
df_models.loc['Mean Model', 'Error (Train)'] = mae_train_m_model
df_models.loc['Mean Model', 'Error (Validation)'] = mae_valid_m_model

display( df_models.iloc[:1] )

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

โมเดลการถดถอยเชิงเส้น

ตอนนี้ เรามาสำรวจความพอดีเชิงเส้นของข้อมูลกัน ตัวอย่างด้านล่างแสดงการใช้งาน

# Create model and fit to the training data
lr_model = LinearRegression()
lr_model.fit(X_train, y_train)

# Generate predictions based on validation data
df_valid['y_lr'] = lr_model.predict(X_valid)

# Generate predictions based on the artificial data
predictions_lr = lr_model.predict(X_artif)

# Compute MAE - Train and Valid
mae_train_lr_model = mean_absolute_error(y_train, lr_model.predict(X_train))
mae_valid_lr_model = mean_absolute_error(y_valid, df_valid['y_lr'])

# Log in the DF
df_models.loc['Linear Regression Model', 'Error (Train)'] = mae_train_lr_model
df_models.loc['Linear Regression Model', 'Error (Validation)'] = mae_valid_lr_model

# Compute the decrease % and display df_models
df_models['Valid. Error Decrease (%)'] = df_models['Error (Validation)'].pct_change() * 100
display( df_models.iloc[:2].round(2) )

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

แบบจำลองแผนผังการตัดสินใจ

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

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

# Create and fit the model 
dt_model = DecisionTreeRegressor(max_depth=3,
                                 criterion='absolute_error',
                                 random_state=15)
dt_model.fit(X_train, y_train)

# Generate predictions based on the validation data
df_valid['y_dt'] = dt_model.predict(X_valid)

# Generate predictions based on the artificial data
predictions_dt = dt_model.predict(X_artif)

# Compute MAE - Train and Valid
mae_train_dt_model = mean_absolute_error(y_train, dt_model.predict(X_train))
mae_valid_dt_model = mean_absolute_error(y_valid, df_valid['y_dt'])

# Log in the DF
df_models.loc['Decision Tree Model', 'Error (Train)'] = mae_train_dt_model
df_models.loc['Decision Tree Model', 'Error (Validation)'] = mae_valid_dt_model

# Compute the decrease % and display df_models
df_models['Valid. Error Decrease (%)'] = df_models['Error (Validation)'].pct_change() * 100

display( df_models.iloc[:3].round(2) )

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

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

เมื่อดูการถดถอยแบบแผนผังการตัดสินใจในพื้นที่สามมิติ ตอนนี้เราสามารถสำรวจเพิ่มเติมว่าแบบจำลองพัฒนาโซลูชันได้อย่างไร ไลบรารีหลาม dtreeviz ให้การแสดงภาพที่ดี หากคุณจำคำอธิบายสั้น ๆ ของฉันเกี่ยวกับแผนผังการตัดสินใจได้ คุณควรอ่านรูปภาพด้านล่างตามลำดับหมายเลข โหนด 0 และ 1 ใช้ค่า time_study เพื่อแยกตัวอย่างเล็กๆ ที่มีจุดที่คล้ายกันมากกว่า และโหนด 2 ใช้ number_courses เพื่อสร้างโหนดเทอร์มินัล 3 และ 4 เพิ่มเติม โปรดสังเกตค่า Mark ที่คาดการณ์ไว้ ในโหนดเทอร์มินัล

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

การตรวจสอบความสำคัญของคุณลักษณะของโมเดลระบุว่า time_study เป็นตัวแปรที่สำคัญที่สุด

โมเดลป่าสุ่ม

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

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

# Create and fit the model that produced the minimum MAE
best_n_estimator = 25
rf_model = model = RandomForestRegressor(n_estimators=best_n_estimator,
                                         criterion='absolute_error',
                                         random_state=15)
rf_model.fit(X_train, y_train)

# Generate predicions based on the validation set
df_valid['y_rf'] = rf_model.predict(X_valid)

# Generate predictions based on the artificial set
predictions_rf = rf_model.predict(X_artif)

# Compute MAE - Train and Valid
mae_train_rf_model = mean_absolute_error(y_train, rf_model.predict(X_train))
mae_valid_rf_model = mean_absolute_error(y_valid, df_valid['y_rf'])

# Log in the DF
df_models.loc['Random Forest Model', 'Error (Train)'] = mae_train_rf_model
df_models.loc['Random Forest Model', 'Error (Validation)'] = mae_valid_rf_model

# Compute the decrease % and display df_models
df_models['Valid. Error Decrease (%)'] = df_models['Error (Validation)'].pct_change() * 100
display( df_models.round(2) )

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

การตรวจสอบความสำคัญของคุณลักษณะของโมเดลระบุว่า time_study เป็นคุณลักษณะที่สำคัญที่สุด และในกรณีนี้ ความสำคัญ number_courses สูงกว่าที่สังเกตได้จากโมเดลแผนผังการตัดสินใจ

สรุปข้อสังเกต

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

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

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