Panduan Definitif untuk Algoritma Hutan Acak dengan Python dan Scikit-Learn

Pengantar

Algoritma Random Forest adalah salah satu algoritma yang paling fleksibel, kuat dan banyak digunakan untuk klasifikasi dan regresi, dibangun sebagai ansambel Pohon Keputusan.

Jika Anda tidak terbiasa dengan ini – jangan khawatir, kami akan membahas semua konsep ini.

Dalam panduan langsung yang mendalam ini, kami akan membangun sebuah intuisi tentang bagaimana pohon keputusan bekerja, bagaimana ensembling meningkatkan classifier dan regressor individu, apa itu hutan acak dan membangun classifier dan regressor hutan acak menggunakan Python dan Scikit-Learn, melalui proyek mini end-to-end, dan menjawab pertanyaan penelitian.

Pertimbangkan bahwa Anda saat ini menjadi bagian dari kelompok riset yang menganalisis data tentang wanita. Kelompok tersebut telah mengumpulkan 100 catatan data dan ingin dapat mengatur catatan awal tersebut dengan membagi perempuan ke dalam kategori: sedang atau tidak hamil, dan tinggal di daerah pedesaan atau perkotaan. Para peneliti ingin memahami berapa banyak wanita di setiap kategori.

Ada struktur komputasi yang melakukan hal itu, yaitu pohon struktur. Dengan menggunakan struktur pohon, Anda akan dapat mewakili divisi yang berbeda untuk setiap kategori.

Pohon Keputusan

Bagaimana Anda mengisi node pohon? Di sinilah pohon keputusan menjadi fokus.

Pertama, kita bisa membagi catatan berdasarkan kehamilan, setelah itu kita bisa membaginya dengan tinggal di perkotaan atau pedesaan. Perhatikan, bahwa kita dapat melakukan ini dalam urutan yang berbeda, mula-mula membagi berdasarkan wilayah tempat tinggal wanita dan setelahnya dengan status kehamilan mereka. Dari sini, kita dapat melihat bahwa pohon tersebut memiliki hierarki yang melekat. Selain mengatur informasi, sebuah pohon mengatur informasi secara hierarkis – urutan informasi muncul penting dan sebagai hasilnya mengarah ke pohon yang berbeda.

Di bawah ini, adalah contoh pohon yang telah dijelaskan:

Pada gambar pohon terdapat 7 kotak, yang di atas berjumlah 100 wanita, kotak di atas ini dihubungkan dengan dua kotak di bawah, yang membagi wanita berdasarkan jumlah 78 tidak hamil dan 22 hamil, dan dari kedua kotak sebelumnya ada empat kotak; dua disambungkan pada setiap kotak di atas yang membagi wanita berdasarkan wilayahnya, untuk yang tidak hamil, 45 tinggal di perkotaan, 33 di pedesaan dan untuk ibu hamil, 14 tinggal di pedesaan dan 8 di perkotaan. Hanya dengan melihat pohonnya, mudah untuk memahami pembagian tersebut dan melihat bagaimana setiap “lapisan” berasal dari yang sebelumnya, lapisan tersebut adalah pohonnya. adalah ide yang bagus, tingkat menggambarkan kedalaman dari pohon:

Amati pada gambar di atas bahwa level pohon pertama adalah tingkat 0 di mana hanya ada satu kotak, diikuti oleh tingkat 1 di mana ada dua kotak, dan tingkat 2 di mana ada empat kotak. Ini adalah sebuah kedalaman 2 pohon.

Di level 0 adalah kotak yang berasal dari pohon, yang pertama disebut simpul akar, akar ini memiliki dua simpul anak di tingkat 1, yaitu node induk ke empat node di level 2. Lihat bahwa "kotak" yang telah kita sebutkan sejauh ini, sebenarnya disebut node; dan bahwa setiap simpul sebelumnya adalah induk dari simpul berikutnya, yang merupakan anak-anaknya. Node anak dari setiap level yang memiliki induk yang sama dipanggil saudara kandung, seperti yang dapat dilihat pada gambar berikut:

Pada gambar sebelumnya, kami juga menampilkan level 1 sebagai node interior, setelah berada di antara root dan node terakhir, yaitu simpul daun. Simpul daun adalah bagian terakhir dari sebuah pohon, jika kita mengatakan dari 100 wanita awal, berapa banyak yang hamil dan tinggal di daerah pedesaan, kita bisa melakukannya dengan melihat daunnya. Jadi angka pada daun akan menjawab pertanyaan penelitian pertama.

Jika ada catatan baru tentang wanita, dan pohon yang sebelumnya digunakan untuk mengkategorikan mereka, sekarang digunakan untuk memutuskan apakah seorang wanita dapat atau tidak dapat menjadi bagian dari penelitian, apakah akan tetap berfungsi? Pohon itu akan menggunakan kriteria yang sama, dan seorang wanita dapat berpartisipasi jika hamil dan tinggal di daerah pedesaan.

Dengan melihat gambar di atas, kita dapat melihat bahwa jawaban atas pertanyaan dari setiap simpul pohon – “apakah dia peserta?”, “apakah dia hamil?”, “apakah dia tinggal di daerah pedesaan?”- adalah ya, ya, dan ya, jadi sepertinya pohon itu bisa mengarah pada keputusan, dalam hal ini, wanita itu bisa ikut serta dalam penelitian.

Ini adalah intisari pohon keputusan, dilakukan secara manual. Dengan menggunakan Pembelajaran Mesin, kita dapat membuat model yang membuat pohon ini secara otomatis untuk kita, sedemikian rupa untuk memaksimalkan keakuratan keputusan akhir.

Dalam contoh sebelumnya, amati bagaimana pohon itu bisa menggolongkan data baru sebagai peserta atau non peserta, atau pertanyaan juga dapat diubah menjadi – “berapa banyak peserta?”, “berapa banyak yang hamil?”, “berapa banyak yang tinggal di daerah pedesaan?” - mengarahkan kita untuk menemukan kuantitas peserta hamil yang tinggal di pedesaan.

Ketika data diklasifikasikan, ini berarti pohon sedang melakukan a klasifikasi tugas, dan ketika jumlah data ditemukan, pohon melakukan a regresi tugas. Ini berarti bahwa pohon keputusan dapat digunakan untuk kedua tugas – klasifikasi dan regresi.

Sekarang setelah kita memahami apa itu pohon keputusan, bagaimana cara menggunakannya, dan nomenklatur apa yang digunakan untuk mendeskripsikannya, kita dapat bertanya-tanya tentang keterbatasannya.

Memahami Hutan Acak

Apa yang terjadi pada keputusan jika beberapa peserta tinggal di daerah perkotaan dan pedesaan? Akankah pohon menambahkan catatan ini ke pedesaan atau perkotaan? Tampaknya sulit untuk memasukkan data ini ke dalam struktur yang kita miliki saat ini, karena potongannya cukup jelas.

Juga, bagaimana jika seorang wanita yang tinggal di atas kapal berpartisipasi dalam penelitian, apakah itu dianggap pedesaan atau perkotaan? Dengan cara yang sama seperti kasus sebelumnya, ini adalah titik data yang sulit untuk diklasifikasi dengan mempertimbangkan opsi yang tersedia di pohon.

Dengan memikirkan lebih dalam tentang contoh pohon keputusan, kita dapat melihatnya dapat mengklasifikasikan data baru dengan benar mengingat sudah mengikuti pola yang sudah dimiliki pohon – tetapi ketika ada catatan yang berbeda dari data awal yang mendefinisikan pohon, struktur pohon terlalu kaku, membuat catatan tidak dapat diklasifikasikan.

Ini berarti bahwa pohon keputusan bisa ketat dan terbatas kemungkinannya. Pohon keputusan yang ideal akan lebih fleksibel dan mampu menampung lebih banyak nuansa data tak terlihat.

Mengenai jawaban atas pertanyaan awal, kita sudah tahu bahwa itu akan dikodekan dalam daun pohon – tetapi apa yang berubah ketika kita memiliki banyak pohon dan bukan satu?

Jika pohon digabungkan untuk klasifikasi, hasilnya akan ditentukan oleh sebagian besar jawaban, ini disebut suara terbanyak; dan dalam kasus regresi, angka yang diberikan oleh setiap pohon di hutan adalah rata-rata.

Pembelajaran Ensemble dan Model Ensemble

Metode ini dikenal sebagai pembelajaran ensemble. Saat menerapkan pembelajaran ansambel, Anda dapat menggabungkan algoritme apa pun, selama Anda dapat memastikan bahwa keluaran dapat diuraikan dan digabungkan dengan keluaran lain (baik secara manual, atau menggunakan pustaka yang ada). Biasanya, Anda menyatukan beberapa model dengan tipe yang sama, seperti beberapa pohon keputusan, tetapi Anda tidak terbatas hanya bergabung dengan ansambel tipe model yang sama.

Ensembling adalah cara praktis yang dijamin untuk menggeneralisasi masalah dengan lebih baik, dan untuk memeras sedikit peningkatan kinerja. Dalam beberapa kasus, model ensembling menghasilkan a penting peningkatan daya prediksi, dan terkadang, hanya sedikit. Ini bergantung pada kumpulan data yang Anda latih dan evaluasi, serta modelnya sendiri.

Menggabungkan pohon keputusan bersama menghasilkan penting peningkatan kinerja dibandingkan dengan masing-masing pohon. Pendekatan ini dipopulerkan dalam penelitian dan komunitas pembelajaran mesin terapan, dan sangat umum sehingga ansambel pohon keputusan disebut bahasa sehari-hari sebagai hutan, dan jenis hutan umum yang sedang dibuat (hutan pohon keputusan pada subset fitur acak) mempopulerkan nama hutan acak.

Mengingat penggunaan skala luas, perpustakaan seperti Scikit-Learn telah mengimplementasikan pembungkus untuk RandomForestRegressors dan RandomForestClassifiers, dibangun di atas implementasi pohon keputusan mereka sendiri, untuk memungkinkan peneliti menghindari membangun ansambel mereka sendiri.

Ayo selami hutan acak!

Bagaimana Algoritma Hutan Acak Bekerja?

Berikut ini adalah langkah-langkah dasar yang terlibat saat menjalankan algoritma hutan acak:

1. Pilih sejumlah record acak, bisa berapa saja, seperti 4, 20, 76, 150, atau bahkan 2.000 dari dataset (disebut N catatan). Jumlahnya akan tergantung pada lebar kumpulan data, semakin lebar, semakin besar N dapat. Di sinilah acak bagian dalam nama algoritma berasal dari!
2. Bangun pohon keputusan berdasarkan itu N catatan acak;
3. Menurut jumlah pohon yang ditentukan untuk algoritme, atau jumlah pohon di hutan, ulangi langkah 1 dan 2. Ini akan menghasilkan lebih banyak pohon dari kumpulan catatan data acak;
4. Setelah langkah 3, datanglah langkah terakhir, yaitu memprediksi hasil:
   • Dalam hal klasifikasi: setiap pohon di hutan akan memprediksi kategori tempat rekaman baru tersebut berada. Setelah itu, rekor baru diberikan ke kategori yang memenangkan suara terbanyak.
   • Dalam kasus regresi: setiap pohon di hutan memprediksi nilai untuk record baru, dan nilai prediksi akhir akan dihitung dengan mengambil rata-rata dari semua nilai yang diprediksi oleh semua pohon di hutan.

Setiap pohon yang cocok pada subset fitur acak tidak akan memiliki pengetahuan tentang beberapa fitur lain, yang diperbaiki dengan ensembling, sekaligus menjaga biaya komputasi tetap rendah.

Dengan intuisi tentang cara kerja pohon, dan pemahaman tentang Hutan Acak – satu-satunya yang tersisa adalah berlatih membangun, melatih, dan menyetelnya pada data!

Membangun dan Melatih Model Hutan Acak dengan Scikit-Learn

Ada alasan mengapa contoh yang digunakan selama ini melibatkan kehamilan, tempat tinggal dan perempuan.

Pada tahun 2020, peneliti dari Bangladesh mencatat bahwa angka kematian ibu hamil masih sangat tinggi, apalagi mengingat mereka yang tinggal di pedesaan. Karena itu, mereka menggunakan sistem pemantauan IOT menganalisis risiko kesehatan ibu. Sistem IOT mengumpulkan data dari berbagai rumah sakit, klinik komunitas, dan layanan kesehatan ibu dari daerah pedesaan Bangladesh.

Data yang dikumpulkan kemudian diatur dalam file comma-separated-value (csv) dan diunggah ke Repositori pembelajaran mesin UCI.

Ini adalah data yang akan kami gunakan untuk berlatih dan mencoba memahami jika seorang wanita hamil menderita a rendah, medium or tinggi risiko kematian.

Menggunakan Hutan Acak untuk Klasifikasi

Karena kami ingin tahu apakah wanita memiliki a rendah, medium or tinggi risiko kematian, ini berarti kita akan melakukan klasifikasi dengan tiga kelas. Jika suatu masalah memiliki lebih dari dua kelas, maka disebut a multikelas masalah, berbeda dengan a biner masalah (di mana Anda memilih antara dua kelas, biasanya 0 dan 1).

Dalam contoh pertama ini, kami akan mengimplementasikan model klasifikasi multikelas dengan pengklasifikasi Hutan Acak dan Scikit-Learn Python.

Kami akan mengikuti langkah-langkah pembelajaran mesin yang biasa untuk mengatasi masalah ini, yaitu memuat perpustakaan, membaca data, melihat statistik ringkasan, dan membuat visualisasi data untuk lebih memahaminya. Kemudian, preprocessing dan splitting data dilanjutkan dengan generate, training dan evaluasi model.

Mengimpor Perpustakaan

Kami akan menggunakan Pandas untuk membaca data, Seaborn dan Matplotlib untuk memvisualisasikannya, dan NumPy untuk metode utilitas yang hebat:

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

Mengimpor Kumpulan Data

Kode berikut mengimpor kumpulan data dan memuatnya ke dalam python DataFrame:

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

Untuk melihat lima baris pertama dari data, kami mengeksekusi head() perintah:

dataset.head()

Output ini:

    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

Di sini kita bisa melihat semua atribut yang dikumpulkan selama penelitian.

• Umur : umur dalam tahun.
• SystolicBP: nilai atas Tekanan Darah di mmHg, atribut yang signifikan selama kehamilan.
• DiastolikBP: nilai Tekanan Darah yang lebih rendah dalam mmHg, atribut penting lainnya selama kehamilan.
• BS: kadar glukosa darah dalam hal konsentrasi molar, mmol/L.
• Detak Jantung: detak jantung istirahat dalam detak per menit.
• RiskLevel: tingkat resiko selama kehamilan.
• BodyTemp : suhu tubuh.

Sekarang setelah kita lebih memahami tentang apa yang diukur, kita dapat melihat jenis datanya info():

dataset.info()

Ini menghasilkan:

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

Dari melihat ke RangeIndex baris, kita dapat melihat bahwa ada 1014 catatan, dan kolom Non-Null Count menginformasikan bahwa data tidak memiliki nilai yang hilang. Artinya, kita tidak perlu melakukan perawatan apa pun untuk data yang hilang!

Dalam majalah Dtype kolom, kita bisa melihat jenis masing-masing variabel. Saat ini, float64 kolom seperti itu BS dan BodyTemp memiliki nilai numerik yang dapat bervariasi dalam rentang apa pun, seperti 15.0, 15.51, 15.76, 17.28, menjadikannya kontinyu secara numerik (Anda selalu dapat menambahkan 0 ke angka floating point, ad infinitem). Di sisi lain, variabel seperti Age, SystolicBP, DiastolicBP, dan HeartRate adalah tipenya int64, ini berarti bahwa angka hanya diubah oleh unit, seperti 11, 12, 13, 14 – kita tidak akan memiliki detak jantung 77.78, itu adalah 77 atau 78 – yaitu diskrit numerik nilai-nilai. Dan kami juga punya RiskLevel dengan object ketik, ini biasanya menunjukkan bahwa variabelnya adalah teks, dan kita mungkin perlu mengubahnya menjadi angka. Karena tingkat risiko tumbuh dari rendah ke tinggi, ada urutan tersirat dalam kategori, ini menunjukkan bahwa a kategoris ordinal variabel.

Setelah melihat tipe data, kita bisa menggunakan describe() untuk mencapai puncak pada beberapa statistik deskriptif, seperti nilai rata-rata setiap kolom, standar deviasi, kuantil, nilai data minimum dan maksimum:

dataset.describe().T 

Kode di atas menampilkan:

            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

Perhatikan bahwa untuk sebagian besar kolom, kolom berarti nilainya jauh dari standar deviasi (std) – ini menunjukkan bahwa data tidak harus mengikuti distribusi statistik yang berperilaku baik. Jika ya, itu akan membantu model saat memprediksi risiko. Yang bisa dilakukan di sini adalah mengolah data terlebih dahulu agar lebih representatif seolah-olah merupakan data dari seluruh populasi dunia, atau lebih. dinormalisasi. Tapi, keuntungan menggunakan model Random Forest untuk klasifikasi, adalah bahwa struktur pohon yang melekat dapat menangani dengan baik data yang belum dinormalisasi, setelah membaginya dengan nilai di setiap tingkat pohon untuk setiap variabel.

Selain itu, karena kami menggunakan pohon dan kelas yang dihasilkan akan diperoleh dengan memilih, kami tidak secara inheren membandingkan antara nilai yang berbeda, hanya antara jenis nilai yang sama, jadi menyesuaikan fitur ke skala yang sama tidak diperlukan dalam hal ini. . Artinya model klasifikasi Random Forest adalah invarian skala, dan Anda tidak perlu melakukan penskalaan fitur.

Dalam hal ini, langkah dalam preprocessing data yang bisa kita lakukan adalah mentransformasi kategorikal RiskLevel kolom menjadi numerik.

Memvisualisasikan Data

Sebelum bertransformasi RiskLevel, mari kita juga memvisualisasikan data dengan cepat dengan melihat kombinasi titik untuk setiap pasangan fitur dengan Scatterplot dan bagaimana titik didistribusikan dengan memvisualisasikan kurva histogram. Untuk melakukan itu, kita akan menggunakan Seaborn's pairplot() yang menggabungkan kedua plot. Ini menghasilkan kedua plot untuk setiap kombinasi fitur dan menampilkan kode warna poin sesuai dengan tingkat risikonya dengan hue milik:

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

Kode di atas menghasilkan:

Saat melihat plot, situasi yang ideal adalah memiliki pemisahan yang jelas antara kurva dan titik. Seperti yang dapat kita lihat, ketiga jenis kelas risiko sebagian besar tercampur, karena pohon secara internal menggambar garis saat membatasi ruang antar titik, kita dapat berhipotesis bahwa lebih banyak pohon di hutan mungkin dapat membatasi lebih banyak ruang dan mengklasifikasikan titik dengan lebih baik.

Dengan analisis data eksplorasi dasar yang dilakukan, kita dapat melakukan praproses RiskLevel kolom.

Preprocessing Data untuk Klasifikasi

Yang pasti hanya ada tiga kelas RiskLevel dalam data kami, dan bahwa tidak ada nilai lain yang ditambahkan secara keliru, dapat kami gunakan unique() untuk menampilkan nilai unik kolom:

dataset['RiskLevel'].unique()

Output ini:

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

Kelas diperiksa, sekarang langkah selanjutnya adalah mengubah setiap nilai menjadi angka. Karena ada urutan antar klasifikasi, kita dapat menggunakan nilai 0, 1 dan 2 untuk menandakan rendah, medium dan tinggi risiko. Ada banyak cara untuk mengubah nilai kolom, mengikuti cara Python sederhana lebih baik daripada yang rumit motto, kita akan menggunakan .replace() metode, dan cukup ganti dengan representasi bilangan bulatnya:

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

Setelah mengganti nilai, kita dapat membagi data menjadi apa yang akan digunakan untuk melatih model, yaitu fitur or X, dan apa yang ingin kita prediksi, yaitu label or y:

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

Setelah X dan y set sudah siap, kita bisa menggunakan Scikit-Learn's train_test_split() metode untuk membaginya lebih lanjut menjadi set kereta dan tes:

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)

Di sini, kami menggunakan 20% data untuk pengujian dan 80% untuk pelatihan.

Melatih RandomForestClassifier

Scikit-Learn mengimplementasikan ansambel di bawah sklearn.ensemble modul. Ansambel pohon keputusan yang digunakan untuk klasifikasi, di mana suara mayoritas diambil diimplementasikan sebagai RandomForestClassifier.

Memiliki set kereta dan tes, kita dapat mengimpor RandomForestClassifier kelas dan membuat model. Untuk memulai, mari buat hutan dengan tiga pohon, dengan pengaturan n_estimators parameter sebagai 3, dan dengan masing-masing pohon memiliki tiga level, dengan pengaturan max_depthke 2:

from sklearn.ensemble import RandomForestClassifier

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

Agar sesuai dengan model di sekitar data – kami menyebutnya fit() metode, memasukkan fitur dan label pelatihan:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

Kita sekarang dapat membandingkan label yang diprediksi dengan label sebenarnya untuk mengevaluasi seberapa baik kinerja model! Sebelum mengevaluasi modelnya, mari kita lihat ansambelnya.

Untuk melihat modelnya lebih dalam, kita dapat memvisualisasikan masing-masing pohon dan bagaimana mereka membagi data. Hal ini dapat dilakukan dengan menggunakan tree modul dibangun ke dalam Scikit-Learn, dan kemudian mengulang melalui masing-masing estimator dalam ansambel:

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

Kode di atas menampilkan plot pohon:

Perhatikan bagaimana ketiga pohon itu berbeda. Yang pertama dimulai dengan BS fitur, yang kedua dengan DiastolicBP, dan yang ketiga dengan BS lagi. Meskipun yang ketiga melihat jumlah sampel yang berbeda. Di cabang kanan, dua pohon pertama juga diputuskan untuk digunakan Age di tingkat daun, sedangkan pohon ketiga diakhiri dengan BS fitur. Dengan hanya tiga estimator, jelas bagaimana penskalaan memberikan representasi pengetahuan yang kaya dan beragam yang dapat digabungkan dengan sukses ke dalam model yang sangat akurat.

Semakin banyak pohon di hutan, semakin beragam modelnya. Namun, ada titik pengembalian yang berkurang, karena dengan banyak pohon yang sesuai dengan subset fitur acak, akan ada sedikit pohon serupa yang tidak menawarkan banyak keragaman dalam ansambel, dan yang akan mulai memiliki terlalu banyak hak suara dan condongkan ansambel agar overfit pada dataset pelatihan, melukai generalisasi ke set validasi.

Ada hipotesis yang dibuat sebelumnya tentang memiliki lebih banyak pohon, dan bagaimana hal itu dapat meningkatkan hasil model. Mari kita lihat hasilnya, buat model baru dan lihat apakah hipotesisnya berlaku!

Mengevaluasi RandomForestClassifier

Scikit-Learn memudahkan pembuatan garis dasar dengan menyediakan a DummyClassifier, yang menghasilkan prediksi tanpa menggunakan fitur input (keluaran yang benar-benar acak). Jika model Anda lebih baik dari DummyClassifier, beberapa pembelajaran terjadi! Untuk memaksimalkan pembelajaran – Anda dapat menguji berbagai hyperparameter secara otomatis dengan menggunakan a RandomizedSearchCV or GridSearchCV. Selain memiliki garis dasar, Anda dapat mengevaluasi performa model Anda dari sudut pandang beberapa metrik.

Beberapa metrik klasifikasi tradisional yang dapat digunakan untuk mengevaluasi algoritme adalah presisi, perolehan kembali, skor-f1, akurasi, dan matriks kebingungan. Berikut adalah penjelasan singkat tentang masing-masing dari mereka:

1. Ketelitian: ketika tujuan kami adalah untuk memahami nilai prediksi yang benar apa yang dianggap benar oleh pengklasifikasi kami. Presisi akan membagi nilai positif sebenarnya dengan sampel yang diprediksi sebagai positif;

$$
presisi = frac{teks{positif benar}}{teks{positif benar} + teks{positif palsu}}
$$

2. Mengingat kembali: umumnya dihitung bersama dengan presisi untuk memahami berapa banyak positif sebenarnya yang diidentifikasi oleh pengklasifikasi kami. Penarikan kembali dihitung dengan membagi positif yang sebenarnya dengan apa pun yang seharusnya diprediksi sebagai positif.

$$
ingat = frac{teks{positif benar}}{teks{positif benar} + teks{negatif palsu}}
$$

3. Skor F1: apakah seimbang atau rata-rata harmonis presisi dan recall. Nilai terendah adalah 0 dan tertinggi adalah 1. Ketika f1-score sama dengan 1, itu berarti semua kelas diprediksi dengan benar – ini adalah skor yang sangat sulit diperoleh dengan data nyata (pengecualian hampir selalu ada).

$$
teks{f1-score} = 2* frac{text{precision} * teks{recall}}{text{precision} + teks{recall}}
$$

4. Matriks Kebingungan: ketika kita perlu mengetahui berapa banyak sampel yang kita dapatkan dengan benar atau salah setiap kelas. Nilai-nilai yang benar dan diprediksi dengan benar disebut positif sejati, yang diprediksi sebagai positif tetapi tidak positif disebut positif palsu. Nomenklatur yang sama dari negatif yang sebenarnya dan negatif palsu digunakan untuk nilai negatif;

5. Ketepatan: menjelaskan berapa banyak prediksi yang benar dari pengklasifikasi kami. Nilai akurasi terendah adalah 0 dan tertinggi adalah 1. Nilai tersebut biasanya dikalikan dengan 100 untuk mendapatkan persentase:

$$
akurasi = frac{teks{jumlah prediksi yang benar}}{teks{jumlah total prediksi}}
$$

Anda dapat menjalankan skrip berikut untuk mengimpor pustaka yang diperlukan dan melihat hasilnya:

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

Outputnya akan terlihat seperti ini:

                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

Dalam laporan klasifikasi, amati bahwa daya ingatnya tinggi, 0.89 untuk kelas 0, presisi dan daya ingatnya tinggi untuk kelas 2, 0.74, 0.72 – dan untuk kelas 1, rendah, khususnya daya ingat 0.17 dan presisi 0.57 . Hubungan antara daya ingat dan presisi untuk ketiga kelas secara individual terekam dalam F1 skor, yang merupakan rata-rata harmonik antara penarikan kembali dan presisi – model melakukannya oke untuk kelas 0, lumayan buruk untuk kelas 1 dan lumayan untuk kelas 2.

Model mengalami kesulitan saat mengidentifikasi kasus risiko sedang.

Keakuratan yang dicapai oleh pengklasifikasi hutan acak kami dengan hanya 3 pohon adalah sebesar 0.58 (58%) – ini berarti mendapatkan sedikit lebih dari setengah hasil yang benar. Ini adalah akurasi yang rendah, dan mungkin dapat ditingkatkan dengan menambahkan lebih banyak pohon.

Dengan melihat matriks kebingungan, kita dapat melihat bahwa sebagian besar kesalahan adalah ketika mengklasifikasikan 52 catatan risiko sedang sebagai risiko rendah, yang memberikan wawasan lebih lanjut tentang ingatan rendah kelas 1. Bias untuk mengklasifikasikan pasien risiko sedang sebagai rendah pasien berisiko.

Hal lain yang dapat diperiksa untuk menghasilkan lebih banyak wawasan adalah fitur apa yang paling dipertimbangkan oleh pengklasifikasi saat memprediksi. Ini adalah langkah penting yang harus diambil sistem pembelajaran mesin yang dapat dijelaskan, dan membantu mengidentifikasi dan mengurangi bias dalam model.

Untuk melihatnya, kita dapat mengakses feature_importances_ milik pengklasifikasi. Ini akan memberi kita daftar persentase, jadi kita juga bisa mengaksesnya feature_names_in_ properti untuk mendapatkan nama setiap fitur, mengaturnya dalam kerangka data, mengurutkannya dari tertinggi ke terendah, dan memplot hasilnya:

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)

Perhatikan bagaimana pengklasifikasi sebagian besar mempertimbangkan gula darah, lalu sedikit tekanan diastolik, suhu tubuh dan sedikit usia untuk mengambil keputusan, ini mungkin juga ada hubungannya dengan rendahnya daya ingat di kelas 1, mungkin data risiko sedang ada hubungannya dengan fitur yang tidak ada banyak dipertimbangkan oleh model. Anda dapat mencoba bermain lebih banyak dengan kepentingan fitur untuk menyelidiki hal ini, dan melihat apakah perubahan pada model memengaruhi fitur yang digunakan, juga apakah ada hubungan yang signifikan antara beberapa fitur dan kelas yang diprediksi.

Akhirnya tiba waktunya untuk membuat model baru dengan lebih banyak pohon untuk melihat pengaruhnya terhadap hasil. Mari kita buat rfc_ hutan dengan 900 pohon, 8 tingkat dan benih yang sama. Apakah hasilnya akan membaik?

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

Menghitung dan menampilkan metrik:

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

Output ini:

                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

Ini menunjukkan bagaimana menambahkan lebih banyak pohon, dan lebih banyak pohon khusus (tingkat lebih tinggi), telah meningkatkan metrik kami. Kami masih memiliki daya ingat yang rendah untuk kelas 1, tetapi akurasinya sekarang mencapai 74%. Skor F1 saat mengklasifikasikan kasus berisiko tinggi adalah sebesar 0.85, yang berarti kasus berisiko tinggi kini lebih mudah diidentifikasi jika dibandingkan dengan 0.73 pada model sebelumnya!

Dalam proyek sehari-hari, mungkin lebih penting untuk mengidentifikasi kasus berisiko tinggi, misalnya dengan metrik yang mirip dengan presisi, yang juga dikenal sebagai kepekaan dalam statistik. Coba atur beberapa parameter model dan amati hasilnya.

Hingga saat ini, kami telah memperoleh pemahaman menyeluruh tentang bagaimana Hutan Acak dapat digunakan untuk mengklasifikasikan data – di bagian berikutnya, kami dapat menggunakan kumpulan data yang sama dengan cara yang berbeda untuk melihat bagaimana model yang sama memprediksi nilai dengan regresi.

Menggunakan Hutan Acak untuk Regresi

Pada bagian ini kita akan mempelajari bagaimana algoritma Random Forest dapat digunakan untuk menyelesaikan masalah regresi menggunakan Scikit-Learn. Langkah-langkah yang dilakukan untuk mengimplementasikan algoritma ini hampir sama dengan langkah-langkah yang dilakukan untuk klasifikasi, selain jenis model, dan jenis data prediksi – yang sekarang akan menjadi nilai kontinu – hanya ada satu perbedaan dalam persiapan data.

Karena regresi dilakukan untuk nilai numerik – mari kita pilih nilai numerik dari kumpulan data. Kami telah melihat bahwa gula darah penting dalam klasifikasi, sehingga harus dapat diprediksi berdasarkan fitur lainnya (karena jika berkorelasi dengan beberapa fitur, fitur tersebut juga berkorelasi dengannya).

Mengikuti apa yang telah kita lakukan untuk klasifikasi, pertama-tama mari impor pustaka dan kumpulan data yang sama. Jika Anda telah melakukan ini untuk model klasifikasi, Anda dapat melewati bagian ini dan langsung menyiapkan data untuk pelatihan.

Mengimpor Pustaka dan Data

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

Preprocessing Data untuk Regresi

Ini adalah tugas regresi, jadi alih-alih memprediksi kelas, kita dapat memprediksi salah satu kolom numerik dari kumpulan data. Dalam contoh ini, BS kolom akan diprediksi. Ini berarti y data akan berisi informasi gula darah, dan X data akan berisi semua fitur selain gula darah. Setelah memisahkan X dan y data, kita dapat membagi set kereta dan tes:

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)

Melatih RandomForestRegressor

Sekarang kita telah menskalakan dataset kita, sekarang saatnya melatih algoritme kita untuk menyelesaikan masalah regresi ini, untuk mengubahnya sedikit – kita akan membuat model dengan 20 pohon di hutan dan masing-masing dengan 4 level. Untuk melakukannya, Anda dapat mengeksekusi kode berikut:

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)

Anda dapat menemukan rincian untuk semua parameter RandomForestRegressor dalam dokumentasi resmi.

Karena memplot dan melihat 20 pohon akan membutuhkan waktu dan dedikasi, kita dapat memplot yang pertama saja untuk melihat perbedaannya dari pohon klasifikasi:

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

Perhatikan bahwa pohon regresi sudah memiliki nilai yang ditetapkan ke data yang ada di setiap node. Itulah nilai yang akan dirata-ratakan saat menggabungkan 20 pohon. Mengikuti apa yang telah kami lakukan dengan klasifikasi, Anda juga dapat memplot kepentingan fitur untuk melihat variabel apa yang lebih dipertimbangkan oleh model regresi saat menghitung nilai.

Saatnya untuk melanjutkan ke langkah terakhir dan terakhir saat memecahkan masalah pembelajaran mesin dan mengevaluasi kinerja algoritme!

Mengevaluasi RandomForestRegressor

Untuk masalah regresi, metrik yang digunakan untuk mengevaluasi suatu algoritma adalah mean absolute error (MAE), mean squared error (MSE), dan root mean squared error (RMSE).

1. Rata-Rata Kesalahan Mutlak (MAE): saat kita mengurangkan nilai prediksi dari nilai aktual, memperoleh kesalahan, menjumlahkan nilai absolut dari kesalahan tersebut dan mendapatkan rata-ratanya. Metrik ini memberikan gambaran error keseluruhan untuk setiap prediksi model, semakin kecil (mendekati 0) semakin baik.

$$
mae = (frac{1}{n})sum_{i=1}^{n}kiri | Aktual – Prediksi tepat |
$$

2. Kesalahan Kuadrat Rata-Rata (MSE): mirip dengan metrik MAE, tetapi mengkuadratkan nilai absolut dari kesalahan. Juga, seperti MAE, semakin kecil, atau mendekati 0, semakin baik. Nilai MSE dikuadratkan sehingga membuat kesalahan besar menjadi lebih besar. Satu hal yang perlu diperhatikan, biasanya ini merupakan metrik yang sulit untuk ditafsirkan karena ukuran nilainya dan fakta bahwa mereka tidak berada dalam skala data yang sama.

$$
mse = sum_{i=1}^{D}(Aktual – Prediksi)^2
$$

3. Kesalahan Root Mean Squared (RMSE): mencoba memecahkan masalah interpretasi yang diangkat dengan MSE dengan mendapatkan akar kuadrat dari nilai akhirnya, untuk menskalakannya kembali ke unit data yang sama. Lebih mudah untuk ditafsirkan dan bagus ketika kita perlu menampilkan atau menunjukkan nilai sebenarnya dari data dengan kesalahan. Ini menunjukkan berapa banyak data dapat bervariasi, jadi, jika kita memiliki RMSE 4.35, model kita dapat membuat kesalahan karena menambahkan 4.35 ke nilai sebenarnya, atau membutuhkan 4.35 untuk mendapatkan nilai sebenarnya. Semakin mendekati 0, semakin baik juga.

$$
rmse = sqrt{ sum_{i=1}^{D}(Aktual – Prediksi)^2}
$$

Kita dapat menggunakan salah satu dari ketiga metrik tersebut untuk membandingkan model (jika kita perlu memilih salah satu). Kami juga dapat membandingkan model regresi yang sama dengan nilai argumen yang berbeda atau dengan data yang berbeda dan kemudian mempertimbangkan metrik evaluasi. Ini dikenal sebagai penyetelan hyperparameter – menyetel hyperparameter yang memengaruhi algoritme pembelajaran dan mengamati hasilnya.

Saat memilih di antara model, model dengan kesalahan terkecil, biasanya berkinerja lebih baik. Saat memantau model, jika metrik menjadi lebih buruk, maka versi model sebelumnya lebih baik, atau ada beberapa perubahan signifikan pada data agar model berperforma lebih buruk daripada performanya.

Anda dapat kode berikut untuk menemukan nilai-nilai ini:

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

Outputnya harus:

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

Dengan 20 pohon, kesalahan kuadrat rata-rata akar adalah 1.75 yang rendah, tetapi meskipun demikian – dengan menambah jumlah pohon dan bereksperimen dengan parameter lain, kesalahan ini mungkin bisa menjadi lebih kecil.

Keuntungan menggunakan Hutan Acak

Seperti halnya algoritma apa pun, ada kelebihan dan kekurangan untuk menggunakannya. Dalam dua bagian berikutnya kita akan melihat pro dan kontra menggunakan hutan acak untuk klasifikasi dan regresi.

1. Algoritme hutan acak tidak bias, karena ada banyak pohon dan setiap pohon dilatih pada subset data acak. Pada dasarnya, algoritma random forest bergantung pada kekuatan “kerumunan”; oleh karena itu tingkat bias keseluruhan dari algoritma berkurang.
2. Algoritma ini sangat stabil. Bahkan jika titik data baru diperkenalkan dalam kumpulan data, algoritme keseluruhan tidak banyak terpengaruh karena data baru dapat memengaruhi satu pohon, tetapi sangat sulit untuk memengaruhi semua pohon.
3. Algoritme hutan acak bekerja dengan baik ketika Anda memiliki fitur kategori dan numerik.
4. Algoritme hutan acak juga bekerja dengan baik ketika data memiliki nilai yang hilang atau belum diskalakan.

Kerugian menggunakan Hutan Acak

1. Kerugian utama dari hutan acak terletak pada kerumitannya. Mereka membutuhkan lebih banyak sumber daya komputasi, karena banyaknya pohon keputusan yang digabungkan, saat melatih ansambel besar. Padahal – dengan perangkat keras modern, melatih bahkan hutan acak yang besar tidak memakan banyak waktu.

Melangkah Lebih Jauh – Proyek End-To-End Hand-Held

Sifat ingin tahu Anda membuat Anda ingin melangkah lebih jauh? Kami merekomendasikan untuk memeriksa kami Proyek Terpandu: “Prediksi Harga Rumah Langsung – Pembelajaran Mesin dengan Python”.

Dalam proyek terpandu ini – Anda akan mempelajari cara membuat model pembelajaran mesin tradisional yang kuat serta model pembelajaran mendalam, memanfaatkan Ensemble Learning dan melatih meta-pelajar untuk memprediksi harga rumah dari sekumpulan model Scikit-Learn dan Keras.

Menggunakan Keras, API pembelajaran mendalam yang dibangun di atas Tensorflow, kami akan bereksperimen dengan arsitektur, membangun ensembel model bertumpuk, dan melatih meta-pelajar jaringan saraf (model level-1) untuk mengetahui harga rumah.

Pembelajaran mendalam itu luar biasa – tetapi sebelum beralih ke itu, disarankan untuk juga mencoba memecahkan masalah dengan teknik yang lebih sederhana, seperti dengan pembelajaran dangkal algoritma. Kinerja dasar kami akan didasarkan pada a Regresi Hutan Acak algoritma. Selain itu – kami akan mengeksplorasi pembuatan ansambel model melalui Scikit-Learn melalui teknik seperti mengantongi dan pemungutan suara.

Ini adalah proyek end-to-end, dan seperti semua proyek Machine Learning, kami akan memulai dengan – dengan Analisis Data Eksplorasi, Diikuti oleh Pengolah Data dan akhirnya Bangunan Dangkal dan Model Pembelajaran Mendalam agar sesuai dengan data yang telah kita jelajahi dan bersihkan sebelumnya.