Pahami cara kerja model Machine Learning ini dengan memvisualisasikan perilakunya dalam ruang tiga dimensi

Artikel ini dilatarbelakangi oleh ketertarikan saya dalam mengembangkan intuisi visual tentang regresi yang dilakukan oleh model pembelajaran mesin seperti Decision Trees dan Random Forests. Saya telah memilih kumpulan data kecil yang memungkinkan visualisasi tiga dimensi dari variabel dan ruang solusi model. Hasilnya sangat menggambarkan perilaku nonlinier mereka dan membantu lebih memahami kapasitas mereka dalam memecahkan masalah multidimensi yang kompleks.

Isi

"Pendahuluan"
Pohon Keputusan dan Hutan Acak
Analisis data
Perencanaan model
— Ikhtisar
— Pemisahan pelatihan/validasi
— Kumpulan data buatan
— Tabel tambahan< br /> Model
— Baseline Mean Model
— Linear Regression Model
— Decision Tree Model
— Random Forest Model
Catatan penutup

Pendahuluan

Model pembelajaran mesin dikembangkan untuk mengekstrak pola dari data guna memprediksi perilaku data baru yang tidak terlihat. Dalam masalah klasifikasi, tugas model adalah memetakan sekumpulan atribut ke dua atau beberapa kategori. Dalam permasalahan regresi, tugasnya adalah memetakan atribut ke rentang nilai yang dapat diasumsikan oleh variabel target, misalnya dalam memprediksi harga rumah berdasarkan lokasi, luas persegi, jumlah kamar tidur, dll.

Salah satu daya tarik utama model ML seperti Decision Trees dan Random Forests adalah kemampuannya untuk menangkap hubungan nonlinier antara atribut dan variabel target. Karena masalah dan aplikasi di dunia nyata biasanya bersifat multidimensi dengan beberapa variabel, sulit untuk memvisualisasikan hubungan dan interaksi kompleksnya.

Dalam artikel ini, kita akan memvisualisasikan tampilan regresi Decision Tree dan Random Forest dalam ruang tiga dimensi, sehingga kita bisa mendapatkan pemahaman yang lebih baik tentang solusi nonlinier multidimensi model ini. Mari kita pahami cara kerja model ini!

Pohon keputusan dan Hutan Acak

Pohon keputusan diberi nama ini karena strukturnya yang mirip pohon: dari satu simpul akar awal (yang memiliki semua data sampel 'di dalamnya'), algoritme menelusuri fitur secara berulang untuk menemukan pemisahan optimal titik yang memisahkan subset data yang merangkum bagian target dengan kesalahan minimum. Kemudian, untuk subset ini, algoritme mengulangi prosedur pencarian untuk menemukan titik pemisahan optimal, dan seterusnya hingga kriteria penghentian terpenuhi (misalnya, tingkat kedalaman tertentu tercapai). Setelah simpul terminal ini tercapai, langkah algoritma selanjutnya melibatkan penyelesaian masalah pemisahan untuk himpunan bagian yang tersisa. Hasilnya adalah sekumpulan node terminal yang menghasilkan prediksi target dengan kesalahan yang diminimalkan. Gambar di bawah menunjukkan contoh hipotetis pohon keputusan dengan dua fitur (x1 dan x2). Algoritma ini menggunakan x2 untuk membagi Node 0 menjadi cabang 1 dan 4, dan kemudian Node 1 menjadi node terminal 2 dan 3. Setelah itu, algoritma menyelesaikan bagian sisanya menggunakan x1.

Dalam contoh ini, pemisahan lapisan ketiga masih dimungkinkan, yang selanjutnya mengurangi kesalahan dan jumlah sampel di node terminal, dan menghasilkan prediksi target yang lebih detail. Namun, hal ini tidak diinginkan karena pohon menjadi terlalu cocok dengan data dan tidak dapat digeneralisasi dengan baik pada data baru. Jadi, penting untuk mengontrol kedalaman pohon untuk menghindari overfitting.

Hutan Acak diberi nama ini karena merupakan kumpulan pohon keputusan acak. Pohon-pohon tunggal di dalam 'hutan' bersifat acak dalam arti bahwa masing-masing pohon dilatih dengan pengambilan sampel fitur dan observasi secara acak, dengan cara di mana setiap pohon mengembangkan solusi terhadap bagian data yang diamati dengan sumber daya (fitur) yang tersedia. . Hutan kemudian menggabungkan keluaran dari beberapa pohon keputusan untuk mencapai suatu solusi. Dengan cara ini, model ini mengurangi risiko overfitting dan meningkatkan fleksibilitas prediksi. Model Random Forests memiliki beberapa parameter penting, seperti jumlah pohon keputusan, kedalamannya, dan jumlah fiturnya (misalnya, pilih secara acak 30% fitur untuk setiap pohon).

Pada artikel ini, kita akan memvisualisasikan cara kerja model ini serta karakteristik dan perilakunya. Saya memilih kumpulan data kecil demi kesederhanaan. Mari kita lakukan analisis data eksplorasi sebelum melakukan pekerjaan pemodelan!

Analisis data

Di sini, saya telah menyertakan kode Python yang paling instruktif, dan Anda dapat menemukan di “halaman Github” saya, “buku catatan” lengkap dan materi proyek studi ini. Cuplikan di bawah menunjukkan perpustakaan 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

Mari kita pertimbangkan kumpulan data yang tersedia dari Kaggle kecil yang terdiri dari nilai siswa yang harus diprediksi berdasarkan dua atribut — jumlah mata kuliah yang diikuti dan waktu belajar.

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

Statistik deskriptif di bawah menunjukkan bahwa kumpulan data terdiri dari 100 observasi, jumlah_kursus adalah variabel diskrit yang berkisar antara 3 hingga 8, waktu_studi adalah variabel kontinu yang berkisar antara 0,096 hingga 7,957, dan Marksadalah variabel kontinu yang berkisar antara 5,609 hingga 55,299.

Seperti yang dapat kita lihat pada plot di bawah, fitur-fitur tersebut memiliki hubungan nonlinier dengan target. Mengingat jumlah_mata kuliah(panel kiri), terdapat tren yang menyebar dan lemah untuk nilai yang lebih tinggi dengan jumlah mata kuliah yang lebih banyak. Kita dapat melihat dua pola rata-rata yang berbeda — sekitar 19 untuk 3 hingga 5 kursus dan sekitar 30 untuk 6 hingga 8 kursus. Mengingat time_study(panel kanan), terdapat pola jelas peningkatan nilai seiring bertambahnya waktu belajar. Pengamatan di dekat kedua ekstrem menyimpang dari linearitas dan pola keseluruhan lebih baik dijelaskan oleh kurva daripada garis lurus.

Idenya adalah menggunakan kedua fitur — number_courses dan time_study — untuk memprediksi nilai siswa. Pada plot tiga dimensi di bawah ini, kita dapat mengamati perilaku nonlinier yang akan kita modelkan dan visualisasikan regresinya.

Perencanaan model

Ringkasan

Pendekatan yang saya adopsi terdiri dari pengembangan empat model:

  1. Model Rata-Rata dasar untuk memiliki referensi awal
  2. Model Regresi Linier untuk memvisualisasikan solusi linier terhadap suatu masalah
  3. Model Regresi Pohon Keputusan
  4. Model Hutan Acak

Prosedur berikut diadopsi:

  1. Data tersebut dibagi menjadi kumpulan pelatihan (70%) dan kumpulan validasi (30%) untuk menilai kinerja model dengan data baru yang belum pernah dilihat sebelumnya.
  2. Kinerja dalam validasi dinilai dengan Mean Absolute Error (atau MAE), yang menunjukkan seberapa besar rata-rata penyimpangan prediksi dari nilai sebenarnya. Semakin kecil MAE, semakin dekat prediksi tersebut dengan nilai sebenarnya.
  3. Sebelum Model Pohon Keputusan dan Hutan Acak definitif, saya telah mengikuti pengoptimalan parameter untuk memastikan generalisasi yang memadai pada data baru.
  4. Untuk memvisualisasikan perilaku model, saya telah membuat kumpulan data buatan yang terdiri dari kombinasi antara kemungkinan nilai number_courses (yaitu, enam angka, dari 3 hingga 8) dan time_study, dengan 100 angka dengan jarak yang sama antara 0,096 dan 7,957. 600 pasangan ini diproses oleh model terlatih untuk merencanakan rentang prediksi.

Pemisahan pelatihan/validasi

Model dilatih dengan 70% data dan 30% digunakan untuk validasi. Cuplikan di bawah menunjukkan pemisahan uji kereta.

# 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

Kumpulan data buatan

Cuplikan di bawah menunjukkan pembuatan 600 pasang angka dengan kombinasi antara 6 kemungkinan nilai number_courses dan 100 kemungkinan nilai time_study. Lima baris pertama dan terakhir dari kumpulan data ini ditampilkan di bawah.

# 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 )

Tabel bantu

Saya juga telah membuat tabel untuk mendaftarkan dan menampilkan kesalahan pelatihan dan validasi, serta tabel untuk mendaftarkan prediksi model ke set validasi.

# 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)

Model

Model Rata-rata Dasar

Sebagai titik awal, saya telah mempertimbangkan Model Mean sederhana untuk dijadikan referensi. Ini hanya mengembalikan rata-rata set pelatihan ke set pengujian apa pun yang disediakan, seperti yang diungkapkan dalam fungsi di bawah ini:

# 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] )

Cuplikan di bawah menunjukkan model rata-rata yang diterapkan pada set pelatihan dan validasi untuk menghitung kesalahan. Model ini memiliki kesalahan besar dan menyimpang 12,85 poin dari Nilai sebenarnya dari set validasi.

# 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] )

Di bawah ini, kita melihat tampilan Mean Model dalam ruang tiga dimensi. Perhatikan kode warna yang saya gunakan untuk plot: data set pelatihan berwarna hijau dan data set validasi berwarna oranye. Kisaran prediksi model hingga himpunan buatan berwarna biru.

Model Regresi Linier

Sekarang, mari kita jelajahi kesesuaian linier dengan data. Cuplikan di bawah ini menunjukkan implementasinya.

# 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) )

Pada Gambar di bawah, kita melihat tampilan regresi linier dalam ruang tiga dimensi (panel kanan). Model Regresi Linier menangkap pola umum, namun prediksinya menyimpang rata-rata sebesar 2,73 poin dari Nilai aktual kumpulan validasi (panel kiri), yang menunjukkan penurunan kesalahan sebesar 78,7% dibandingkan dengan Model Rata-Rata.

Model Pohon Keputusan

Kedalaman pohon merupakan parameter penting dari Pohon Keputusan, jadi langkah pertama adalah melatih model dengan tingkat kedalaman berbeda untuk menganalisis performa validasi pelatihan. Seperti yang ditunjukkan pada Gambar di bawah, untuk kedalaman pohon 3 kami memiliki jarak pendek yang diinginkan antara kesalahan pelatihan dan validasi, yang menunjukkan generalisasi pada data yang tidak terlihat. Dari kedalaman 4 hingga 9, kami melihat sedikit penurunan kesalahan validasi, tetapi penurunan kesalahan pelatihan menunjukkan adanya overfitting pada model.

Cuplikan di bawah ini menunjukkan implementasi Pohon Keputusan dengan kedalaman 3 dan kesalahan absolut sebagai kriteria pemisahan node.

# 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) )

Kinerja validasi Pohon Keputusan menunjukkan penurunan kesalahan sebesar 13,5% dibandingkan dengan Regresi Linier. Gambar di bawah menunjukkan tampilan regresi Pohon Keputusan dalam ruang tiga dimensi (panel kanan). Prediksi tersebut menyimpang rata-rata 2,36 poin dari Nilai sebenarnya dari set validasi (panel kiri).

Akibat proses pemisahan tersebut, perilaku pohon dicirikan oleh pola respons berlapis yang mampu menangkap bagian-bagian nonlinier. Sebuah pohon dengan kedalaman 3 menghasilkan 8 node terminal, dan dari bawah ke atas plot (panel kanan), kita dapat mengamati 8 level regresi.

Setelah melihat regresi Pohon Keputusan dalam ruang tiga dimensi, kini kita dapat mengeksplorasi lebih jauh bagaimana model mengembangkan solusinya. Pustaka python dtreeviz memberikan visualisasi yang bagus. Jika Anda ingat penjelasan singkat saya tentang pohon keputusan, sebaiknya Anda membaca Gambar di bawah ini sesuai urutan nomornya. Node 0 dan 1 menggunakan nilai time_study untuk memisahkan sampel yang lebih kecil dari titik-titik yang lebih mirip, dan node 2 menggunakan number_courses untuk selanjutnya menghasilkan node terminal 3 dan 4. Catat nilai Mark yang diprediksi di node terminal.

Ada 8 prediksi berbeda yang dihasilkan oleh model ini, dan oleh karena itu Pohon Keputusan agak terbatas untuk menangkap semua bagian distribusi yang relevan. Gambar di bawah, yang dihasilkan oleh pustaka graphviz, juga memberikan visualisasi bagus yang mencakup kesalahan absolut dan jumlah sampel untuk setiap node.

Pemeriksaan terhadap pentingnya fitur model menunjukkan bahwa time_study adalah variabel yang paling penting.

Model Hutan Acak

Jumlah estimator merupakan parameter penting dari Random Forests, dan langkah pertama adalah menguji model dengan jumlah estimator yang berbeda. Parameter lain seperti kedalaman pohon dan jumlah fitur dibuat konstan dan tidak dibatasi. Seperti terlihat pada Gambar di bawah, optimasi menunjukkan jarak validasi kereta minimum adalah sekitar 0,40, dengan 25 estimator.

Cuplikan di bawah ini menunjukkan implementasi Random Forest dengan 25 estimator dan kesalahan absolut sebagai kriteria pemisahan. Parameter model lainnya memiliki spesifikasi standar, artinya kedalaman pohon tidak dibatasi dan semua pohon memiliki kedua fitur tersebut. Komponen acak model berasal dari bootstrap sampling set pelatihan.

# 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) )

Kinerja validasi Random Forest menunjukkan penurunan kesalahan sebesar 58,1% dibandingkan dengan regresi Pohon Keputusan, dan penurunan kesalahan sebesar 63,8% dibandingkan dengan Regresi Linier. Prediksi tersebut menyimpang rata-rata 1 poin dari Nilai sebenarnya dari kumpulan validasi, sehingga jauh lebih akurat dibandingkan model lainnya. Mengingat tingginya jumlah penduga, Random Forest mampu membuat prediksi yang lebih detail. Pada Gambar di bawah, kita dapat melihat tampilan regresi Random Forest dalam ruang tiga dimensi.

Pemeriksaan terhadap pentingnya fitur model menunjukkan bahwa time_study adalah fitur yang paling penting, dan dalam hal ini kepentingan number_courses lebih tinggi daripada yang diamati pada Model Pohon Keputusan.

Catatan penutup

Tujuan artikel ini adalah untuk mengeksplorasi perilaku nonlinier Pohon Keputusan dan Hutan Acak, khususnya untuk memvisualisasikan regresi dan solusi nonlinier model.

Visualisasi yang disajikan di sini berguna untuk memahami cara kerja model ini dan memecahkan masalah regresi. Mengamati ruang solusi model sangat informatif mengenai karakteristik, keterbatasan, dan kelebihannya. Misalnya, kedalaman Pohon Keputusan harus dibatasi untuk menghindari overfitting, namun hal ini juga membatasi jumlah prediksi yang dihasilkan.

Regresi Decision Tree mungkin cocok untuk memodelkan pola distribusi yang dapat direduksi secara memuaskan menjadi serangkaian prediksi yang relatif kecil, sedangkan regresi Random Forest cocok untuk memodelkan distribusi kompleks yang memerlukan rentang prediksi yang luas.