Ghid definitiv pentru algoritmul forestier aleatoriu cu Python și Scikit-Learn

Introducere

Algoritmul Random Forest este unul dintre cei mai flexibili, puternici și mai folosiți algoritmi pentru clasificare și regresie, construit ca un ansamblu de Arbori de Decizie.

Dacă nu sunteți familiarizat cu acestea - nu vă faceți griji, vom acoperi toate aceste concepte.

În acest ghid aprofundat, vom construi un intuiţie despre cum funcționează arborii de decizie, cum asamblarea stimulează clasificatorii și regresorii individuali, ce sunt pădurile aleatorii și construiți un clasificator și regresor aleatoriu de pădure folosind Python și Scikit-Learn, printr-un mini-proiect end-to-end, și răspundeți la o întrebare de cercetare.

Luați în considerare că în prezent faceți parte dintr-un grup de cercetare care analizează date despre femei. Grupul a strâns 100 de înregistrări de date și dorește să poată organiza acele înregistrări inițiale împărțind femeile în categorii: fiind sau nu însărcinate și locuiesc în mediul rural sau urban. Cercetătorii vor să înțeleagă câte femei ar fi în fiecare categorie.

Există o structură de calcul care face exact asta, este copac structura. Folosind o structură arborescentă, veți putea reprezenta diferitele diviziuni pentru fiecare categorie.

Arbori de decizie

Cum populezi nodurile unui copac? Aici e locul copaci de decizie intra in focus.

În primul rând, putem împărți înregistrările în funcție de sarcină, după aceea, le putem împărți locuind în zone urbane sau rurale. Observați, că am putea face acest lucru într-o ordine diferită, împărțind inițial pe ce zonă locuiesc femeile și apoi după starea lor de sarcină. Din aceasta, putem vedea că arborele are o ierarhie inerentă. Pe lângă organizarea informațiilor, un arbore organizează informațiile într-o manieră ierarhică – ordinea în care apar informațiile contează și, ca urmare, duce la diferiți arbori.

Mai jos, este un exemplu de arbore care a fost descris:

În imaginea arborelui, există 7 pătrate, cel de deasupra care reprezintă un total de 100 de femei, acest pătrat de sus este conectat cu două pătrate de mai jos, care împart femeile în funcție de numărul lor de 78 neînsarcinate și 22 gravide și din ambele pătrate anterioare sunt patru pătrate; două conectate la fiecare pătrat de deasupra care împart femeile în funcție de suprafață, pentru cele care nu sunt însărcinate, 45 locuiesc în mediul urban, 33 în mediul rural, iar pentru gravide, 14 locuiesc în mediul rural și 8 în mediul urban. Doar privind arborele, este ușor să înțelegeți acele diviziuni și să vedeți cum fiecare „strat” este derivat din cele anterioare, acele straturi sunt arborele nivelurile de, nivelurile descriu adâncime a copacului:

Observați în imaginea de mai sus că primul nivel al copacului este Nivelul 0 unde există un singur pătrat, urmat de Nivelul 1 unde sunt două pătrate și Nivelul 2 unde sunt patru pătrate. Acesta este un adâncime 2 copac.

La nivelul 0 este pătratul care dă naștere arborelui, primul, numit nodul rădăcină, această rădăcină are două nodurile copil la nivelul 1, adică nodurile părinte la cele patru noduri din nivelul 2. Vezi că „pătratele” pe care le-am menționat până acum se numesc de fapt noduri; și că fiecare nod anterior este părinte pentru următoarele noduri, care sunt copiii săi. Sunt numite nodurile copil ale fiecărui nivel care au același părinte fraţi, așa cum se poate vedea în imaginea următoare:

În imaginea anterioară, afișăm și nivelul 1 ca fiind nodurile interioare, odată ce sunt între rădăcină și ultimele noduri, care sunt nodurile frunzelor. Nodurile frunzelor sunt ultima parte a unui copac, dacă ar fi să spunem din cele 100 de femei inițiale, câte sunt însărcinate și locuiesc în mediul rural, am putea face acest lucru uitându-ne la frunze. Deci numărul de la frunze ar răspunde la prima întrebare de cercetare.

Dacă ar exista noi înregistrări ale femeilor, iar arborele care a fost folosit anterior pentru a le clasifica, ar fi fost folosit acum pentru a decide dacă o femeie ar putea sau nu să facă parte din cercetare, ar funcționa în continuare? Arborele ar folosi aceleași criterii, iar o femeie ar fi eligibilă să participe dacă este însărcinată și locuiește într-o zonă rurală.

Privind imaginea de mai sus, putem vedea că răspunsurile la întrebările fiecărui nod de copac – „este ea participant?”, „este însărcinată?”, „locuiește într-o zonă rurală?” – sunt da, da, și da, deci se pare că arborele poate duce la o decizie, în acest caz, că femeia ar putea participa la cercetare.

Aceasta este esență de arbori de decizie în, realizat în mod manual. Folosind Machine Learning, putem construi un model care construiește automat acest arbore pentru noi, astfel încât să maximizăm acuratețea deciziilor finale.

În exemplele anterioare, observați cum ar putea copacul clasifica date noi ca participant sau non-participant, sau întrebările ar putea fi, de asemenea, modificate în – „câți sunt participanți?”, „câți sunt însărcinate?”, „câți locuiesc într-o zonă rurală?”- conducându-ne să găsim cantitate a participantelor gravide care locuiesc într-o zonă rurală.

Când datele sunt clasificate, aceasta înseamnă că arborele realizează a clasificare sarcină, iar când se găsește cantitatea de date, arborele realizează a regres sarcină. Aceasta înseamnă că arborele de decizie poate fi folosit pentru ambele sarcini – clasificare și regresie.

Acum că înțelegem ce este un arbore de decizie, cum poate fi utilizat și ce nomenclatură este folosită pentru a-l descrie, ne putem întreba despre limitările acestuia.

Înțelegerea pădurilor aleatorii

Ce se întâmplă cu decizia dacă un participant trăiește din diviziunea dintre zonele urbane și cele rurale? Ar adăuga arborele această înregistrare în mediul rural sau urban? Pare greu să potrivim aceste date în structura pe care o avem în prezent, deoarece sunt destul de clare.

De asemenea, ce se întâmplă dacă o femeie care locuiește pe o barcă participă la cercetare, ar fi considerată rural sau urban? La fel ca în cazul precedent, este un punct de date dificil de clasificat având în vedere opțiunile disponibile în arbore.

Gândindu-ne puțin la exemplul arborelui de decizie, putem vedea că poate clasifica corect datele noi, considerând că urmează deja un model pe care arborele îl are deja - dar când există înregistrări care diferă de datele inițiale care au definit arborele, Structura arborelui este prea rigidă, ceea ce face ca înregistrările să nu poată fi clasificate.

Aceasta înseamnă că arborele de decizie poate fi strict și limitat în posibilitățile sale. Un arbore de decizie ideal ar fi mai flexibil și mai capabil să găzduiască date mai nuanțate nevăzute.

În ceea ce privește răspunsul la întrebarea inițială, știm deja că va fi codificat în frunzele copacilor – dar ce se schimbă atunci când avem mulți copaci în loc de unul?

Dacă arborii sunt combinați pentru o clasificare, rezultatul va fi definit de majoritatea răspunsurilor, acesta se numește votul majoritar; iar în cazul unei regresii, numărul dat de fiecare copac din pădure va fi în medie.

Ansamblu de învăţare şi ansambluri model

Această metodă este cunoscută ca învățarea ansamblului. Când implicați învățarea ansamblului, puteți amesteca orice algoritm împreună, atâta timp cât vă puteți asigura că rezultatul poate fi analizat și combinat cu alte ieșiri (fie manual, fie folosind bibliotecile existente). În mod obișnuit, asamblați mai multe modele de același tip împreună, cum ar fi mai mulți arbori de decizie, dar nu vă limitați doar să vă alăturați ansamblurilor de același tip de model.

Asamblarea este o modalitate practic garantată de a generaliza mai bine o problemă și de a obține o ușoară creștere a performanței. În unele cazuri, asamblarea modelelor produce a semnificativ creșterea puterii de predicție și, uneori, doar ușoară. Acest lucru depinde de setul de date pe care îl instruiți și pe care îl evaluați, precum și de modelele în sine.

Unirea arborilor de decizie împreună produce randamente semnificativ crește performanța comparativ cu arborii individuali. Această abordare a fost popularizată în comunitățile de cercetare și învățare automată aplicată și a fost atât de comună încât ansamblul de arbori de decizie a fost denumit colocvial un pădure, iar tipul comun de pădure care a fost creat (o pădure de arbori de decizie pe un subset aleatoriu de caracteristici) a popularizat numele păduri aleatorii.

Având în vedere utilizarea pe scară largă, biblioteci precum Scikit-Learn au implementat wrapper-uri pentru RandomForestRegressore și RandomForestClassifiers, construite pe baza propriilor implementări ale arborelui de decizie, pentru a permite cercetătorilor să evite construirea propriilor ansambluri.

Să ne scufundăm în păduri aleatorii!

Cum funcționează algoritmul forestier aleatoriu?

Următorii sunt pașii de bază implicați în executarea algoritmului forestier aleatoriu:

1. Alegeți un număr de înregistrări aleatorii, poate fi orice număr, cum ar fi 4, 20, 76, 150 sau chiar 2.000 din setul de date (numit N înregistrări). Numărul va depinde de lățimea setului de date, cu cât este mai larg, cu atât mai mare N poate fi. Aici este locul aleator o parte din numele algoritmului provine de la!
2. Construiți un arbore de decizie pe baza acestora N înregistrări aleatorii;
3. În funcție de numărul de arbori definiți pentru algoritm, sau de numărul de arbori din pădure, repetați pașii 1 și 2. Acest lucru generează mai mulți arbori din seturi de înregistrări aleatorii de date;
4. După pasul 3, urmează pasul final, care este prezicerea rezultatelor:
   • În caz de clasificare: fiecare copac din pădure va prezice categoria căreia îi aparține noul record. După aceea, noul record este atribuit categoriei care câștigă votul majoritar.
   • În caz de regresie: fiecare copac din pădure prezice o valoare pentru noua înregistrare, iar valoarea de predicție finală va fi calculată luând o medie a tuturor valorilor prezise de toți copacii din pădure.

Fiecare arbore care se potrivește într-un subset aleatoriu de caracteristici nu va avea în mod necesar cunoștințe despre alte caracteristici, care sunt rectificate prin asamblare, menținând în același timp costul de calcul mai mic.

Cu o intuiție asupra modului în care funcționează copacii și o înțelegere a Pădurilor aleatorii – singurul lucru rămas este să exersezi construirea, antrenamentul și reglarea lor pe date!

Construirea și antrenarea modelelor de pădure aleatoare cu Scikit-Learn

A existat un motiv pentru care exemplele folosite până acum implică sarcina, zona de locuit și femeile.

În 2020, cercetătorii din Bangladesh au observat că mortalitatea în rândul femeilor însărcinate era încă foarte mare, mai ales luând în considerare cele care trăiesc în zonele rurale. Din acest motiv, au folosit un sistem de monitorizare IOT pentru analiza riscului pentru sănătatea maternă. Sistemul IOT a colectat date de la diferite spitale, clinici comunitare și îngrijiri de sănătate maternă din zonele rurale din Bangladesh.

Datele colectate au fost apoi organizate într-un fișier cu valori separate prin virgulă (csv) și încărcate în Depozitul de învățare automată al UCI.

Acestea sunt datele pe care le vom folosi pentru a exersa și a încerca să înțelegem dacă o femeie însărcinată are o scăzut, mediu or înalt risc de mortalitate.

Utilizarea pădurii aleatorii pentru clasificare

Din moment ce vrem să știm dacă femeia are o scăzut, mediu or înalt risc de mortalitate, asta înseamnă că vom efectua o clasificare cu trei clase. Când o problemă are mai mult de două clase, se numește a multiclasă problema, spre deosebire de a binar problemă (unde alegi între două clase, de obicei 0 și 1).

În acest prim exemplu, vom implementa un model de clasificare multiclasă cu un clasificator Random Forest și Scikit-Learn de la Python.

Vom urma pașii obișnuiți de învățare automată pentru a rezolva această problemă, care sunt încărcarea bibliotecilor, citirea datelor, analizarea statisticilor rezumate și crearea de vizualizări de date pentru a le înțelege mai bine. Apoi, preprocesarea și împărțirea datelor, urmată de generarea, antrenamentul și evaluarea unui model.

Importul bibliotecilor

Vom folosi Pandas pentru a citi datele, Seaborn și Matplotlib pentru a le vizualiza și NumPy pentru metodele de mare utilitate:

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

Importul setului de date

Următorul cod importă setul de date și îl încarcă într-un python DataFrame:

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

Pentru a ne uita la primele cinci rânduri ale datelor, executăm head() comanda:

dataset.head()

Acest rezultat:

    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

Aici putem vedea toate atributele colectate în timpul cercetării.

• Varsta: varste in ani.
• SystolicBP: valoarea superioară a tensiunii arteriale în mmHg, un atribut semnificativ în timpul sarcinii.
• DiastolicBP: valoare mai mică a tensiunii arteriale în mmHg, un alt atribut semnificativ în timpul sarcinii.
• BS: nivelurile de glucoză din sânge în termeni de concentrație molară, mmol/L.
• Heart Rate: ritmul cardiac de repaus în bătăi pe minut.
• RiskLevel: nivelul de risc în timpul sarcinii.
• BodyTemp: temperatura corpului.

Acum că înțelegem mai multe despre ceea ce se măsoară, ne putem uita la tipurile de date cu care info():

dataset.info()

Rezultă:

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

Din privire la RangeIndex linie, putem vedea că există 1014 înregistrări și coloana Non-Null Count informează că datele nu au valori lipsă. Aceasta înseamnă că nu va trebui să facem niciun tratament pentru datele lipsă!

În Dtype coloană, putem vedea tipul fiecărei variabile. În prezent, float64 coloane astfel BS și BodyTemp au valori numerice care pot varia în orice interval, cum ar fi 15.0, 15.51, 15.76, 17.28, făcându-le continuu numeric (puteți adăuga oricând un 0 la un număr în virgulă mobilă, la infinit). Pe de altă parte, variabile precum Age, SystolicBP, DiastolicBP, și HeartRate sunt de tipul int64, asta înseamnă că numerele se schimbă doar în funcție de unitate, cum ar fi 11, 12, 13, 14 – nu vom avea o frecvență cardiacă de 77.78, este fie 77, fie 78 – acestea sunt discret numeric valorile. Și avem și noi RiskLevel cu object tip, aceasta indică de obicei că variabila este un text și probabil că va trebui să o transformăm într-un număr. Deoarece nivelul de risc crește de la scăzut la ridicat, există o ordine implicită în categorii, aceasta indică faptul că este o categoric ordinal variabilă.

După ce ne uităm la tipurile de date, putem folosi describe() pentru a atinge un vârf la unele statistici descriptive, cum ar fi valorile medii ale fiecărei coloane, abaterea standard, cuantile, valorile minime și maxime ale datelor:

dataset.describe().T 

Codul de mai sus afișează:

            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

Observați că pentru majoritatea coloanelor, însemna valorile sunt departe de abatere standard (std) – aceasta indică faptul că datele nu urmează neapărat o distribuție statistică bine comportată. Dacă ar fi făcut-o, ar fi ajutat modelul atunci când a prezis riscul. Ceea ce se poate face aici este să preprocesăm datele pentru a le face mai reprezentative ca și cum ar fi date de la întreaga populație a lumii sau mai multe normalizat. Dar, un avantaj atunci când folosiți modele Random Forest pt clasificare, este că structura arborescentă inerentă poate face față bine datelor care nu au fost normalizate, odată ce le împarte la valoarea din fiecare nivel de arbore pentru fiecare variabilă.

De asemenea, pentru că folosim arbori și că clasa rezultată va fi obținută prin vot, nu comparăm în mod inerent între diferite valori, ci doar între aceleași tipuri de valori, deci ajustarea caracteristicilor la aceeași scară nu este necesară în acest caz. . Aceasta înseamnă că modelul de clasificare Random Forest este invariant de scară, și nu trebuie să efectuați scalarea caracteristicilor.

În acest caz, pasul în preprocesarea datelor pe care îl putem face este transformarea categoricului RiskLevel coloană într-una numerică.

Vizualizarea datelor

Înainte de a se transforma RiskLevel, să vizualizăm rapid datele, de asemenea, analizând combinațiile de puncte pentru fiecare pereche de caracteristici cu un Scatterplot și modul în care punctele sunt distribuite prin vizualizarea curbei histogramei. Pentru a face asta, vom folosi Seaborn's pairplot() care combină ambele parcele. Acesta generează ambele diagrame pentru fiecare combinație de caracteristici și afișează punctele codificate în culori în funcție de nivelul lor de risc cu hue proprietate:

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

Codul de mai sus generează:

Când ne uităm la complot, situația ideală ar fi să existe o separare clară între curbe și puncte. După cum vedem, cele trei tipuri de clase de risc sunt în mare parte amestecate, deoarece copacii desenează în interior linii atunci când delimitează spațiile dintre puncte, putem presupune că mai mulți copaci din pădure ar putea limita mai multe spații și pot clasifica mai bine punctele.

Odată cu analiza de bază a datelor de explorare efectuată, putem preprocesa RiskLevel coloana.

Preprocesarea datelor pentru clasificare

Pentru a fi sigur că există doar trei clase de RiskLevel în datele noastre și că nicio altă valoare nu a fost adăugată în mod eronat, le putem folosi unique() pentru a afișa valorile unice ale coloanei:

dataset['RiskLevel'].unique()

Acest rezultat:

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

Clasele sunt verificate, acum următorul pas este transformarea fiecărei valori într-un număr. Deoarece există o ordine între clasificări, putem folosi valorile 0, 1 și 2 pentru a semnifica scăzut, mediu și înalt riscuri. Există multe modalități de a modifica valorile coloanei, urmând cele ale lui Python simplu este mai bine atât de complex motto-ul, vom folosi .replace() metoda și înlocuiți-le pur și simplu cu reprezentările lor întregi:

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

După înlocuirea valorilor, putem împărți datele în ceea ce va fi folosit pentru antrenarea modelului, the caracteristici or X, și ceea ce vrem să prezicem, etichete or y:

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

Odată ce X și y seturile sunt gata, putem folosi Scikit-Learn's train_test_split() metodă de a le împărți în continuare în tren și seturi de testare:

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)

Aici, folosim 20% din date pentru testare și 80% pentru antrenament.

Antrenarea unui RandomForestClassifier

Scikit-Learn a implementat ansambluri sub sklearn.ensemble modul. Un ansamblu de arbori de decizie utilizat pentru clasificare, în care se ia votul majoritar este implementat ca RandomForestClassifier.

Având trenul și seturile de testare, putem importa RandomForestClassifier clasă și creați modelul. Pentru început, să creăm o pădure cu trei copaci, prin setare n_estimators parametrul ca 3 și fiecare arbore având trei niveluri, prin setare max_depthla 2:

from sklearn.ensemble import RandomForestClassifier

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

Pentru a se potrivi modelului în jurul datelor – numim fit() metoda, introducând caracteristicile de antrenament și etichetele:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

Acum putem compara etichetele prezise cu etichetele reale pentru a evalua cât de bine a funcționat modelul! Înainte de a evalua modelul, să aruncăm o privire asupra ansamblului.

Pentru a privi puțin mai în profunzime modelul, putem vizualiza fiecare dintre copaci și modul în care aceștia împart datele. Acest lucru se poate face folosind tree modul încorporat în Scikit-Learn și apoi treceți în buclă prin fiecare dintre estimatorii din ansamblu:

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

Codul de mai sus afișează diagramele arborelui:

Observați cum sunt diferiți cei trei copaci. Prima începe cu BS caracteristică, al doilea cu DiastolicBP, iar al treilea cu BS din nou. Deși al treilea se uită la un număr diferit de mostre. Pe ramura din dreapta, primii doi copaci decid de asemenea folosirea Age la nivelul frunzei, în timp ce al treilea copac se termină cu BS caracteristică. Cu doar trei estimatori, este clar cum extinderea oferă o reprezentare bogată și diversă a cunoștințelor care pot fi reunite cu succes într-un model extrem de precis.

Cu cât sunt mai mulți copaci în pădure, cu atât modelul poate fi mai divers. Există un punct în care randamentele descrescătoare, totuși, deoarece mulți copaci se potrivesc într-un subset aleatoriu de caracteristici, vor exista un pic de copaci similari care nu oferă multă diversitate în ansamblu și care vor începe să aibă prea multă putere de vot și obligă ansamblul pentru a fi supraadaptat pe setul de date de antrenament, dăunând generalizării la setul de validare.

A existat o ipoteză făcută mai devreme despre a avea mai mulți copaci și cum ar putea îmbunătăți rezultatele modelului. Să ne uităm la rezultate, să generăm un nou model și să vedem dacă ipoteza se menține!

Evaluarea RandomForestClassifier

Scikit-Learn facilitează crearea liniilor de bază, oferind a DummyClassifier, care generează predicții fără a utiliza funcțiile de intrare (ieșiri total aleatorii). Dacă modelul tău este mai bun decât cel DummyClassifier, unele se învață! Pentru a maximiza învățarea – puteți testa automat diverși hiperparametri utilizând a RandomizedSearchCV or GridSearchCV. Pe lângă faptul că aveți o linie de bază, puteți evalua performanța modelului dvs. din prisma mai multor metrici.

Unele valori tradiționale de clasificare care pot fi utilizate pentru a evalua algoritmul sunt precizia, rechemarea, scorul f1, acuratețea și matricea de confuzie. Iată o scurtă explicație pentru fiecare dintre ele:

1. Precizie: când scopul nostru este să înțelegem ce valori corecte de predicție au fost considerate corecte de către clasificatorul nostru. Precizia va împărți acele valori pozitive adevărate la eșantioanele care au fost prezise ca fiind pozitive;

$$
precizie = frac{text{adevărate pozitive}}{text{adevărate pozitive} + text{false pozitive}}
$$

2. Rechemare: calculat în mod obișnuit împreună cu precizia pentru a înțelege câte dintre elementele pozitive adevărate au fost identificate de clasificatorul nostru. Rechemarea se calculează împărțind adevăratele pozitive la orice ar fi trebuit prezis ca fiind pozitiv.

$$
recall = frac{text{adevărate pozitive}}{text{adevărate pozitive} + text{false negative}}
$$

3. Scor F1: este echilibrat sau medie armonică de precizie și reamintire. Cea mai mică valoare este 0, iar cea mai mare este 1. Când f1-score este egal cu 1, înseamnă că toate clasele au fost corect prezise – acesta este un scor foarte greu de obținut cu date reale (excepții există aproape întotdeauna).

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

4. Matricea confuziei: atunci când trebuie să știm pentru câte mostre am primit corect sau greșit fiecare clasă. Se numesc valorile care au fost corecte și prezise corect adevărate pozitive, cele care au fost prezise ca pozitive, dar nu au fost pozitive sunt numite fals pozitive. Aceeași nomenclatură a negative adevărate și false negative este folosit pentru valori negative;

5. Acuratete: descrie câte predicții a corectat clasificatorul nostru. Cea mai mică valoare de precizie este 0, iar cea mai mare este 1. Această valoare este de obicei înmulțită cu 100 pentru a obține un procent:

$$
acuratețe = frac{text{numărul de predicții corecte}}{text{numărul total de predicții}}
$$

Puteți executa următorul script pentru a importa bibliotecile necesare și pentru a vedea rezultatele:

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

Ieșirea va arăta cam așa:

                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

În raportul de clasificare, observați că reamintirea este mare, 0.89 pentru clasa 0, atât precizia, cât și reamintirea sunt mari pentru clasa 2, 0.74, 0.72 – iar pentru clasa 1, acestea sunt scăzute, în special reamintirea de 0.17 și o precizie de 0.57 . Relația dintre rechemare și precizie pentru toate cele trei clase în mod individual este surprinsă în F1 scor, care este media armonică dintre reamintire și precizie – modelul merge bine pentru clasa 0, destul de rău pentru clasa 1 și decent pentru clasa 2.

Modelul întâmpină dificultăți atunci când identifică cazuri cu risc mediu.

Precizia obținută de clasificatorul nostru aleatoriu de pădure cu doar 3 copaci este de 0.58 (58%) – asta înseamnă că obține puțin mai mult de jumătate din rezultate corecte. Aceasta este o precizie scăzută și poate fi îmbunătățită prin adăugarea mai multor copaci.

Privind matricea de confuzie, putem vedea că majoritatea greșelilor apar atunci când se clasifică 52 de înregistrări cu risc mediu ca risc scăzut, ceea ce oferă o perspectivă suplimentară asupra reamintirii scăzute a clasei 1. Este părtinitoare spre clasificarea pacienților cu risc mediu ca fiind cu risc scăzut. pacientii cu risc.

Un alt lucru care poate fi verificat pentru a genera și mai multe informații este ce caracteristici sunt cele mai luate în considerare de către clasificator atunci când prezice. Acesta este un pas important de făcut sisteme explicabile de învățare automatăși ajută la identificarea și atenuarea părtinirii modelelor.

Pentru a vedea asta, putem accesa feature_importances_ proprietatea clasificatorului. Acest lucru ne va oferi o listă de procente, astfel încât să putem accesa și feature_names_in_ proprietate pentru a obține numele fiecărei caracteristici, organizați-le într-un cadru de date, sortați-le de la cel mai mare la cel mai mic și reprezentați rezultatul:

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)

Observați cum clasificatorul ia în considerare cel mai mult zahăr din sânge, apoi puțin din presiunea diastolică, temperatura corpului și doar puțină vârstă pentru a lua o decizie, acest lucru ar putea avea de-a face și cu reamintirea scăzută pe clasa 1, poate că datele cu risc mediu au de-a face cu caracteristici care nu sunt luate mult în considerare de model. Puteți încerca să vă jucați mai mult cu importanța caracteristicilor pentru a investiga acest lucru și pentru a vedea dacă modificările asupra modelului afectează caracteristicile utilizate, de asemenea, dacă există o relație semnificativă între unele dintre caracteristici și clasele prezise.

În sfârșit, este timpul să generăm un nou model cu mai mulți copaci pentru a vedea cum afectează rezultatele. Să creăm rfc_ pădure cu 900 de copaci, 8 nivele și aceeași sămânță. Se vor îmbunătăți rezultatele?

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

Calcularea și afișarea valorilor:

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

Acest rezultat:

                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

Aceasta arată cum adăugarea mai multor copaci și a mai multor copaci specializați (niveluri mai înalte) a îmbunătățit valorile noastre. Avem încă o rechemare scăzută pentru clasa 1, dar acuratețea este acum de 74%. Scorul F1 la clasificarea cazurilor cu risc ridicat este de 0.85, ceea ce înseamnă că cazurile cu risc ridicat sunt acum mai ușor de identificat în comparație cu 0.73 în modelul anterior!

Într-un proiect de zi cu zi, ar putea fi mai important să se identifice cazurile cu risc ridicat, de exemplu, cu o măsurătoare similară cu precizia, care este cunoscută și ca sensibilitate în statistici. Încercați să modificați unii dintre parametrii modelului și observați rezultatele.

Până acum, am obținut o înțelegere generală a modului în care Random Forest poate fi utilizată pentru clasificarea datelor – în secțiunea următoare, putem folosi același set de date într-un mod diferit pentru a vedea cum același model prezice valorile cu regresie.

Folosirea pădurilor aleatoare pentru regresie

În această secțiune vom studia modul în care un algoritm de pădure aleatorie poate fi utilizat pentru a rezolva probleme de regresie folosind Scikit-Learn. Pașii urmați pentru implementarea acestui algoritm sunt aproape identici cu pașii efectuati pentru clasificare, pe lângă tipul de model și tipul de date prezise – care vor fi acum vale continue – există o singură diferență în pregătirea datelor.

Din moment ce regresia se face pentru valorile numerice – să alegem o valoare numerică din setul de date. Am văzut că glicemia a fost importantă în clasificare, așa că ar trebui să fie previzibilă pe baza altor caracteristici (deoarece dacă se corelează cu o anumită caracteristică, acea caracteristică se corelează și cu ea).

Urmând ceea ce am făcut pentru clasificare, să importăm mai întâi bibliotecile și același set de date. Dacă ați făcut deja acest lucru pentru modelul de clasificare, puteți sări peste această parte și să treceți direct la pregătirea datelor pentru antrenament.

Importul biblioteci și date

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

Preprocesarea datelor pentru regresie

Aceasta este o sarcină de regresie, așa că în loc să prezicem clase, putem prezice una dintre coloanele numerice ale setului de date. În acest exemplu, BS coloana va fi prezisă. Aceasta înseamnă y datele vor contine date de zahăr din sânge, și X datele vor conține toate caracteristicile, în afară de zahărul din sânge. După separarea X și y date, putem împărți trenul și seturile de testare:

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)

Antrenarea unui RandomForestRegressor

Acum că ne-am scalat setul de date, este timpul să ne antrenăm algoritmul pentru a rezolva această problemă de regresie, pentru a o schimba puțin – vom crea un model cu 20 de copaci în pădure și fiecare cu 4 nivele. Pentru a face acest lucru, puteți executa următorul cod:

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)

Puteți găsi detalii pentru toți parametrii RandomForestRegressor în documentația oficială.

Deoarece trasarea și analiza a 20 de copaci ar necesita ceva timp și dedicare, îl putem reprezenta doar pe primul pentru a ne uita la modul în care este diferit de arborele de clasificare:

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

Observați că arborele de regresie are deja o valoare atribuită datelor care se încadrează pe fiecare nod. Acestea sunt valorile care vor fi mediate la combinarea celor 20 de copaci. Urmând ceea ce am făcut cu clasificarea, puteți, de asemenea, să reprezentați grafic importanța caracteristicilor pentru a vedea ce variabile ia mai mult în considerare modelul de regresie la calcularea valorilor.

Este timpul să treceți la ultimul și ultimul pas atunci când rezolvați o problemă de învățare automată și să evaluați performanța algoritmului!

Evaluarea unui RandomForestRegressor

Pentru problemele de regresie, metricile utilizate pentru a evalua un algoritm sunt eroarea medie absolută (MAE), eroarea medie pătratică (MSE) și eroarea medie pătratică (RMSE).

1. Eroare absolută medie (MAE): când scădem valorile prezise din valorile reale, obținând erorile, însumăm valorile absolute ale acelor erori și obținem media lor. Această măsurătoare oferă o noțiune a erorii generale pentru fiecare predicție a modelului, cu cât este mai mică (mai aproape de 0), cu atât mai bine.

$$
mae = (frac{1}{n})sum_{i=1}^{n}stânga | Actual – Previzual corect |
$$

2. Eroare medie pătratică (MSE): este similar cu metrica MAE, dar pune la pătrat valorile absolute ale erorilor. De asemenea, ca și în cazul MAE, cu cât este mai mic sau mai aproape de 0, cu atât mai bine. Valoarea MSE este pătrată pentru a face erorile mari și mai mari. Un lucru la care trebuie să acordați o atenție deosebită este că de obicei este o metrică greu de interpretat din cauza mărimii valorilor sale și a faptului că acestea nu se află la aceeași scară a datelor.

$$
mse = sum_{i=1}^{D}(Real – Predict)^2
$$

3. Root Mean Squared Error (RMSE): încearcă să rezolve problema de interpretare ridicată cu MSE prin obținerea rădăcinii pătrate a valorii sale finale, astfel încât să o scaleze înapoi la aceleași unități de date. Este mai ușor de interpretat și bun atunci când trebuie să afișăm sau să arătăm valoarea reală a datelor cu eroarea. Arată cât de mult pot varia datele, așa că, dacă avem un RMSE de 4.35, modelul nostru poate face o eroare fie pentru că a adăugat 4.35 la valoarea reală, fie a avut nevoie de 4.35 pentru a ajunge la valoarea reală. Cu cât este mai aproape de 0, cu atât mai bine.

$$
rmse = sqrt{ sum_{i=1}^{D}(Real – Predict)^2}
$$

Putem folosi oricare dintre aceste trei valori pentru comparaţie modele (dacă trebuie să alegem unul). De asemenea, putem compara același model de regresie cu valori diferite de argument sau cu date diferite și apoi luăm în considerare metricile de evaluare. Aceasta este cunoscută ca reglarea hiperparametrului – reglarea hiperparametrilor care influențează un algoritm de învățare și observarea rezultatelor.

Atunci când alegeți dintre modele, cele cu cele mai mici erori, de obicei, au rezultate mai bune. La monitorizarea modelelor, dacă valorile s-au înrăutățit, atunci o versiune anterioară a modelului a fost mai bună sau a existat o modificare semnificativă a datelor pentru ca modelul să aibă performanțe mai slabe decât performanța.

Puteți folosi următorul cod pentru a găsi aceste valori:

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

Ieșirea ar trebui să fie:

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

Cu 20 de arbori, eroarea pătratică medie este de 1.75, dar chiar și așa – prin creșterea numărului de arbori și experimentarea cu ceilalți parametri, această eroare ar putea deveni și mai mică.

Avantajele utilizării Random Forest

Ca și în cazul oricărui algoritm, utilizarea acestuia are avantaje și dezavantaje. În următoarele două secțiuni vom arunca o privire asupra avantajelor și dezavantajelor utilizării pădurii aleatorii pentru clasificare și regresie.

1. Algoritmul pădurii aleatorii nu este părtinitor, deoarece există mai mulți copaci și fiecare copac este antrenat pe un subset aleatoriu de date. Practic, algoritmul forestier aleatoriu se bazează pe puterea „mulțimii”; prin urmare, gradul general de părtinire a algoritmului este redus.
2. Acest algoritm este foarte stabil. Chiar dacă un nou punct de date este introdus în setul de date, algoritmul general nu este afectat prea mult, deoarece datele noi pot afecta un arbore, dar este foarte greu pentru acesta să afecteze toți copacii.
3. Algoritmul forestier aleatoriu funcționează bine atunci când aveți atât caracteristici categoriale, cât și numerice.
4. Algoritmul forestier aleatoriu funcționează bine și atunci când datele au valori lipsă sau nu au fost scalate.

Dezavantajele utilizării Random Forest

1. Principalul dezavantaj al pădurilor aleatorii constă în complexitatea lor. Acestea necesită mult mai multe resurse de calcul, datorită numărului mare de arbori de decizie uniți, atunci când antrenați ansambluri mari. Cu toate acestea, cu hardware-ul modern, antrenarea chiar și a unei păduri mari aleatorii nu necesită mult timp.

Mergând mai departe – Proiect manual de la capăt la capăt

Natura ta curios te face să vrei să mergi mai departe? Vă recomandăm să verificați Proiect ghidat: „Predicție practică pentru prețul casei – Învățare automată în Python”.

În acest proiect ghidat – veți învăța cum să construiți modele puternice tradiționale de învățare automată, precum și modele de învățare profundă, să utilizați Ensemble Learning și să formați meta-învățați pentru a prezice prețurile caselor dintr-un pachet de modele Scikit-Learn și Keras.

Folosind Keras, API-ul de deep learning construit pe Tensorflow, vom experimenta arhitecturi, vom construi un ansamblu de modele stivuite și vom antrena un meta-învățator rețea neuronală (model de nivel 1) pentru a afla prețul unei case.

Învățarea profundă este uimitoare – dar înainte de a recurge la ea, se recomandă să încercați și să rezolvați problema cu tehnici mai simple, cum ar fi cu învăţare superficială algoritmi. Performanța noastră de bază se va baza pe a Regresie aleatorie a pădurii algoritm. În plus – vom explora crearea de ansambluri de modele prin Scikit-Learn prin tehnici precum insacuire și vot.

Acesta este un proiect de la capăt la capăt și, ca toate proiectele de învățare automată, vom începe cu – cu Analiza datelor exploratorii, urmat de Pre-procesare de date și, în sfârșit Construire superficială și Modele de învățare profundă pentru a se potrivi cu datele pe care le-am explorat și curățat anterior.