Definitiv guide til Random Forest Algorithm med Python og Scikit-Learn

Introduktion

Random Forest-algoritmen er en af ​​de mest fleksible, kraftfulde og udbredte algoritmer til klassificering og regression, bygget som en ensemble af beslutningstræer.

Hvis du ikke er bekendt med disse - ingen bekymringer, vi dækker alle disse begreber.

I denne dybdegående praktiske vejledning bygger vi en intuition om hvordan beslutningstræer fungerer, hvordan ensembling booster individuelle klassifikatorer og regressorer, hvad tilfældige skove er og opbygg en tilfældig skovklassifikator og regressor ved hjælp af Python og Scikit-Learn, gennem et ende-til-ende mini-projekt, og besvar et forskningsspørgsmål.

Overvej, at du i øjeblikket er en del af en forskergruppe, der analyserer data om kvinder. Gruppen har indsamlet 100 dataregistre og ønsker at være i stand til at organisere disse indledende optegnelser ved at opdele kvinderne i kategorier: at være eller ikke gravide og at bo i land- eller byområder. Forskerne ønsker at forstå, hvor mange kvinder der ville være i hver kategori.

Der er en beregningsstruktur, der gør præcis det, det er træ struktur. Ved at bruge en træstruktur vil du være i stand til at repræsentere de forskellige divisioner for hver kategori.

Beslutningstræer

Hvordan befolker du knudepunkterne i et træ? Det er her beslutning træer komme i fokus.

Først kan vi opdele posterne efter graviditet, derefter kan vi opdele dem ved at bo i by- eller landområder. Bemærk, at vi kunne gøre dette i en anden rækkefølge, indledningsvis divideret med hvilket område kvinderne bor og efter med deres graviditetsstatus. Ud fra dette kan vi se, at træet har et iboende hierarki. Udover at organisere information, organiserer et træ information på en hierarkisk måde - rækkefølgen, hvorpå informationen vises, har betydning og fører til forskellige træer som et resultat.

Nedenfor er et eksempel på træet, der er blevet beskrevet:

I træbilledet er der 7 felter, den øverste, der tegner sig for de i alt 100 kvinder, denne øverste firkant er forbundet med to felter nedenfor, der deler kvinderne ud fra deres antal på 78 ikke-gravide og 22 gravide, og fra begge tidligere felter er der fire felter; to forbundet til hver firkant over, der deler kvinderne ud fra deres område, for de ikke-gravide bor 45 i et byområde, 33 i et landområde og for de gravide bor 14 i et landområde og 8 i et byområde. Bare ved at se på træet, er det nemt at forstå disse opdelinger og se, hvordan hvert "lag" er afledt fra tidligere, disse lag er træet niveauer, beskriver niveauerne dybde af træet:

Bemærk på billedet ovenfor, at det første træniveau er niveau 0 hvor der kun er én firkant, efterfulgt af niveau 1 hvor der er to firkanter, og niveau 2 hvor der er fire firkanter. Dette er en dybde 2 træ.

I niveau 0 kaldes det kvadrat, der stammer fra træet, det første rodnode, denne rod har to barn noder på niveau 1, dvs forældreknudepunkter til de fire noder i niveau 2. Se, at de "firkanter", vi har nævnt hidtil, faktisk hedder noder; og at hver tidligere node er en forælder til de følgende noder, som er dens børn. De underordnede noder på hvert niveau, der har den samme forælder, kaldes søskende, som det kan ses på næste billede:

På det forrige billede viser vi også niveau 1 som værende indre knudepunkter, når de er mellem roden og de sidste noder, som er bladknudepunkter. Bladknuderne er den sidste del af et træ, hvis vi ud fra de 100 første kvinder skal sige, hvor mange der er gravide og bor i landdistrikter, kunne vi gøre dette ved at se på bladene. Så nummeret ved bladene ville besvare det første forskningsspørgsmål.

Hvis der var nye registreringer af kvinder, og træet, der tidligere blev brugt til at kategorisere dem, nu blev brugt til at afgøre, om en kvinde kunne eller ikke kunne være en del af forskningen, ville det så stadig fungere? Træet ville bruge de samme kriterier, og en kvinde ville være berettiget til at deltage, hvis hun er gravid og bor i et landområde.

Ved at se på billedet ovenfor kan vi se, at svarene på spørgsmålene for hver træknude – "er hun en deltager?", "er hun gravid?", "bor hun i et landområde?"- er ja, ja, og ja, så det ser ud til, at træet kan tænkes at føre til en beslutning, i dette tilfælde, om at kvinden kunne deltage i forskningen.

Dette er den essens af beslutningstræer i, udført på en manuel måde. Ved at bruge Machine Learning kan vi konstruere en model, der konstruerer dette træ automatisk for os, på en sådan måde at maksimere nøjagtigheden af ​​de endelige beslutninger.

I de foregående eksempler skal du observere, hvordan træet kunne enten klassificere nye data som deltager eller ikke-deltager, eller spørgsmålene kan også ændres til - "hvor mange er deltagere?", "hvor mange er gravide?", "hvor mange bor i et landområde?" - hvilket får os til at finde mængde af gravide deltagere, der bor i et landområde.

Når dataene er klassificeret, betyder det, at træet udfører en klassificering opgave, og når mængden af ​​data er fundet, udfører træet en regression opgave. Det betyder, at beslutningstræet kan bruges til både opgaver – klassificering og regression.

Nu hvor vi forstår, hvad et beslutningstræ er, hvordan kan det bruges, og hvilken nomenklatur der bruges til at beskrive det, kan vi undre os over dets begrænsninger.

Forståelse af tilfældige skove

Hvad sker der med beslutningen, hvis en deltager lever på opdelingen mellem by og land? Ville træet tilføje denne rekord til landdistrikter eller byer? Det virker svært at passe disse data ind i den struktur, vi har i øjeblikket, da det er ret tydeligt.

Og hvad hvis en kvinde, der bor på en båd, deltager i forskningen, ville det så blive betragtet som landdistrikt eller by? På samme måde som det foregående tilfælde er det et udfordrende datapunkt at klassificere i betragtning af de tilgængelige muligheder i træet.

Ved at tænke lidt mere over beslutningstræ-eksemplet kan vi se, at det korrekt kan klassificere nye data, i betragtning af at det allerede følger et mønster, træet allerede har - men når der er poster, der adskiller sig fra de oprindelige data, der definerede træet, træstrukturen er for stiv, hvilket gør, at registreringerne ikke kan klassificeres.

Det betyder, at beslutningstræet kan være strengt og begrænset i sine muligheder. Et ideelt beslutningstræ ville være mere fleksibelt og i stand til at rumme mere nuancerede usete data.

Med hensyn til svaret på det indledende spørgsmål ved vi allerede, at det vil blive indkodet i træets blade – men hvad ændrer sig, når vi har mange træer i stedet for ét?

Hvis træerne kombineres til en klassificering, vil resultatet blive defineret af flertallet af svarene, dette kaldes flertalsafstemning; og i tilfælde af en regression vil tallet givet af hvert træ i skoven være gennemsnit.

Ensemble læring og modelensembler

Denne metode er kendt som ensemble læring. Når du anvender ensemble learning, kan du blande alle algoritmer sammen, så længe du kan sikre, at outputtet kan parses og kombineres med andre output (enten manuelt eller ved hjælp af eksisterende biblioteker). Typisk samler du flere modeller af samme type sammen, f.eks. flere beslutningstræer, men du er ikke begrænset til blot at deltage i ensembler af samme modeltype.

Ensembling er en praktisk garanteret måde at generalisere bedre til et problem og til at presse et lille præstationsboost ud. I nogle tilfælde giver ensembling af modeller en signifikant stigning i forudsigelseskraft, og nogle gange kun lille. Dette afhænger af det datasæt, du træner og evaluerer på, såvel som selve modellerne.

Sammenføjning af beslutningstræer giver udbytte signifikant præstationsforøgelser sammenlignet med individuelle træer. Denne tilgang blev populær i forsknings- og anvendt maskinlæringssamfund og var så almindelig, at ensemblet af beslutningstræer i daglig tale blev kaldt en skov, og den almindelige type skov, der blev skabt (en skov af beslutningstræer på en tilfældig delmængde af funktioner) populariserede navnet tilfældige skove.

På grund af bred anvendelse har biblioteker som Scikit-Learn implementeret indpakninger til RandomForestRegressors og RandomForestClassifiers, bygget oven på deres egne beslutningstræ-implementeringer, for at give forskere mulighed for at undgå at bygge deres egne ensembler.

Lad os dykke ned i tilfældige skove!

Hvordan fungerer Random Forest Algorithm?

Følgende er de grundlæggende trin involveret, når du udfører den tilfældige skovalgoritme:

1. Vælg et antal tilfældige poster, det kan være et hvilket som helst tal, såsom 4, 20, 76, 150 eller endda 2.000 fra datasættet (kaldet N optegnelser). Antallet vil afhænge af datasættets bredde, jo bredere, jo større N måske. Det er her tilfældig del i algoritmens navn kommer fra!
2. Byg et beslutningstræ baseret på dem N tilfældige optegnelser;
3. I henhold til antallet af træer defineret for algoritmen, eller antallet af træer i skoven, gentag trin 1 og 2. Dette genererer flere træer fra sæt af tilfældige dataposter;
4. Efter trin 3 kommer det sidste trin, som er at forudsige resultaterne:
   • I tilfælde af klassificering: hvert træ i skoven vil forudsige den kategori, som den nye rekord tilhører. Derefter tildeles den nye rekord til den kategori, der vinder flertalsafstemningen.
   • I tilfælde af regression: hvert træ i skoven forudsiger en værdi for den nye rekord, og den endelige forudsigelsesværdi vil blive beregnet ved at tage et gennemsnit af alle værdierne forudsagt af alle træerne i skoven.

Hvert træ, der passer på en tilfældig delmængde af funktioner, vil nødvendigvis ikke have noget kendskab til nogle andre funktioner, hvilket rettes ved ensembling, samtidig med at de beregningsmæssige omkostninger holdes lavere.

Med en intuition om, hvordan træer fungerer, og en forståelse af Random Forests – det eneste tilbage er at øve sig i at bygge, træne og tune dem på data!

Opbygning og træning af tilfældige skovmodeller med Scikit-Learn

Der var en grund til, at de hidtil anvendte eksempler involverer graviditet, opholdsstue og kvinder.

I 2020 bemærkede forskere fra Bangladesh, at dødeligheden blandt gravide kvinder stadig var meget høj, især i betragtning af dem, der bor i landdistrikter. På grund af det brugte de et IOT-overvågningssystem til analysere risikoen for mødres sundhed. IOT-systemet indsamlede data fra forskellige hospitaler, lokale klinikker og mødres sundhedspleje fra landdistrikterne i Bangladesh.

De indsamlede data blev derefter organiseret i en kommasepareret-værdi-fil (csv) og uploadet til UCI's maskinlæringsdepot.

Dette er de data, vi vil bruge til at øve os og forsøge at forstå, om en gravid kvinde har en lav, medium or høj risiko for dødelighed.

Brug af Random Forest til klassificering

Da vi gerne vil vide, om kvinden har en lav, medium or høj risiko for dødelighed, betyder det, at vi udfører en klassificering med tre klasser. Når et problem har mere end to klasser, kaldes det en multiklasse problem, i modsætning til en binær problem (hvor du typisk vælger mellem to klasser 0 , 1).

I dette første eksempel vil vi implementere en multiklasse-klassifikationsmodel med en Random Forest-klassifikator og Pythons Scikit-Learn.

Vi vil følge de sædvanlige maskinlæringstrin for at løse dette problem, som er at indlæse biblioteker, læse data, se på oversigtsstatistikker og skabe datavisualiseringer for bedre at forstå det. Derefter forbehandling og opdeling af data efterfulgt af generering, træning og evaluering af en model.

Import af biblioteker

Vi vil bruge Pandas til at læse dataene, Seaborn og Matplotlib til at visualisere dem, og NumPy til de fantastiske hjælpemetoder:

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

Import af datasættet

Følgende kode importerer datasættet og indlæser det i en python DataFrame:

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

For at se på de første fem linjer af dataene, udfører vi head() kommando:

dataset.head()

Dette udsender:

    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

Her kan vi se alle de attributter, der er indsamlet under forskningen.

• Alder: aldre i år.
• Systolisk BP: øvre værdi af blodtryk i mmHg, en væsentlig egenskab under graviditet.
• Diastolisk BP: lavere værdi af blodtryk i mmHg, en anden væsentlig egenskab under graviditet.
• BS: blodsukkerniveauer i form af en molær koncentration, mmol/L.
• Hjertefrekvens: Hvilepuls i slag i minuttet.
• Risikoniveau: Risikoniveau under graviditet.
• BodyTemp: kropstemperaturen.

Nu hvor vi forstår mere om, hvad der måles, kan vi se på typerne af data med info():

dataset.info()

Dette resulterer i:

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

Fra at se på RangeIndex linje, kan vi se, at der er 1014 poster, og kolonnen Non-Null Count informerer om, at dataene ikke mangler nogen værdier. Det betyder, at vi ikke behøver at foretage nogen behandling for manglende data!

I Dtype kolonne, kan vi se typen af ​​hver variabel. I øjeblikket, float64 kolonner såsom BS , BodyTemp har numeriske værdier, der kan variere i ethvert område, såsom 15.0, 15.51, 15.76, 17.28, hvilket gør dem numerisk kontinuerlig (du kan altid tilføje et 0 til et flydende decimaltal, ad uendeligt). På den anden side kan variable som f.eks Age, SystolicBP, DiastolicBPog HeartRate er af typen int64, betyder det, at tallene kun ændres af enheden, såsom 11, 12, 13, 14 – vi vil ikke have en puls på 77.78, det er enten 77 eller 78 – det er numerisk diskret værdier. Og det har vi også RiskLevel med en object type, indikerer dette normalt, at variablen er en tekst, og vi bliver sandsynligvis nødt til at transformere den til et tal. Da risikoniveauet vokser fra lavt til højt, er der en underforstået rækkefølge i kategorierne, hvilket indikerer, at det er en kategorisk ordinal variabel.

Efter at have set på datatyper, kan vi bruge describe() at tage et højdepunkt på nogle beskrivende statistikker, såsom middelværdierne for hver kolonne, standardafvigelsen, kvantiler, minimums- og maksimumsdataværdier:

dataset.describe().T 

Ovenstående kode viser:

            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

Bemærk, at for de fleste kolonner betyde værdier er langt fra standardafvigelse (std) – dette indikerer, at dataene ikke nødvendigvis følger en velopdragen statistisk fordeling. Hvis det gjorde det, ville det have hjulpet modellen, når den forudsagde risikoen. Det, der kan gøres her, er at forbehandle dataene for at gøre dem mere repræsentative, som om det var data fra hele verdensbefolkningen eller mere normaliseret. Men, en fordel ved brug af Random Forest modeller til klassificering, er, at den iboende træstruktur godt kan håndtere data, der ikke er blevet normaliseret, når den først dividerer det med værdien i hvert træniveau for hver variabel.

Fordi vi bruger træer, og at den resulterende klasse opnås ved at stemme, sammenligner vi ikke i sagens natur mellem forskellige værdier, kun mellem de samme typer værdier, så det er ikke nødvendigt at justere funktionerne til den samme skala i dette tilfælde . Det betyder, at Random Forest klassifikationsmodellen er skala invariant, og du behøver ikke udføre funktionsskalering.

I dette tilfælde er det trin i dataforbehandling, vi kan tage, at transformere det kategoriske RiskLevel kolonne til en numerisk.

Visualisering af data

Før transformation RiskLevel, lad os også hurtigt visualisere dataene ved at se på kombinationerne af punkter for hvert par funktioner med et scatterplot, og hvordan punkterne er fordelt ved at visualisere histogramkurven. For at gøre det, vil vi bruge Seaborn's pairplot() som kombinerer begge grunde. Den genererer begge plots for hver funktionskombination og viser punkterne farvekodet i henhold til deres risikoniveau med hue ejendom:

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

Ovenstående kode genererer:

Når man ser på plottet, ville den ideelle situation være at have en klar adskillelse mellem kurver og prikker. Som vi kan se, er de tre typer risikoklasser for det meste blandet sammen, da træer internt tegner linjer, når de afgrænser mellemrummene mellem punkter, kan vi antage, at flere træer i skoven måske kan begrænse flere rum og bedre klassificere punkterne.

Med den grundlæggende eksplorative dataanalyse udført, kan vi forbehandle RiskLevel kolonne.

Dataforbehandling til klassificering

For at være sikker er der kun tre klasser af RiskLevel i vores data, og at der ikke er tilføjet andre værdier fejlagtigt, kan vi bruge unique() for at vise kolonnens unikke værdier:

dataset['RiskLevel'].unique()

Dette udsender:

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

Klasserne er kontrolleret, nu er næste trin at transformere hver værdi til et tal. Da der er en rækkefølge mellem klassifikationer, kan vi bruge værdierne 0, 1 og 2 til at betegne lav, medium , høj risici. Der er mange måder at ændre kolonneværdierne efter Python's simpelt er bedre end komplekst motto, vi vil bruge .replace() metode, og blot erstatte dem med deres heltal repræsentationer:

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

Efter at have erstattet værdierne, kan vi opdele dataene i, hvad der skal bruges til træning af modellen, den funktioner or X, og hvad vi ønsker at forudsige, den etiketter or y:

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

Når X , y sæt er klar, vi kan bruge Scikit-Learn's train_test_split() metode til yderligere at opdele dem i tog- og testsæt:

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)

Her bruger vi 20 % af dataene til test og 80 % til træning.

Træning af en RandomForestClassifier

Scikit-Learn implementerede ensembler under sklearn.ensemble modul. Et ensemble af beslutningstræer, der bruges til klassificering, hvor der træffes en flertalsafstemning, implementeres som RandomForestClassifier.

Når vi har toget og testsættene, kan vi importere RandomForestClassifier klasse og lav modellen. For at starte, lad os skabe en skov med tre træer ved at indstille n_estimators parameter som 3, og med hvert træ med tre niveauer ved indstilling max_depthtil 2:

from sklearn.ensemble import RandomForestClassifier

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

For at tilpasse modellen omkring dataene – kalder vi fit() metode, ved at indsætte træningsfunktionerne og etiketterne:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

Vi kan nu sammenligne de forudsagte mærker med de rigtige mærker for at vurdere, hvor godt modellen klarede sig! Før vi evaluerer modellen, lad os tage et kig på ensemblet.

For at se lidt dybere ind i modellen, kan vi visualisere hvert af træerne, og hvordan de deler dataene. Dette kan gøres ved at bruge tree modul indbygget i Scikit-Learn, og derefter gennemgå hver af estimatorerne i ensemblet:

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

Ovenstående kode viser træplottene:

Læg mærke til, hvordan de tre træer er forskellige. Den første starter med BS funktion, den anden med DiastolicBP, og den tredje med BS igen. Selvom den tredje ser på et andet antal prøver. På højre gren beslutter de to første træer også at bruge Age i bladhøjde, mens det tredje træ ender med BS funktion. Med kun tre estimatorer er det tydeligt, hvordan opskalering giver en rig, mangfoldig repræsentation af den viden, der med succes kan samles i en meget nøjagtig model.

Jo flere træer i skoven, jo mere forskelligartet kan modellen være. Der er dog et punkt med faldende afkast, men da mange træer passer til en tilfældig delmængde af funktioner, vil der være en hel del lignende træer, der ikke byder på meget mangfoldighed i ensemblet, og som vil begynde at have for meget stemmekraft og skæv ensemblet til at blive overfittet på træningsdatasættet, hvilket skader generaliseringen til valideringssættet.

Der var tidligere lavet en hypotese om at have flere træer, og hvordan det kunne forbedre modelresultaterne. Lad os tage et kig på resultaterne, generere en ny model og se om hipotesen holder!

Evaluering af RandomForestClassifier

Scikit-Learn gør det nemt at oprette basislinjer ved at levere en DummyClassifier, som udsender forudsigelser uden at bruge input-funktionerne (helt tilfældige udgange). Hvis din model er bedre end DummyClassifier, nogle læring sker! For at maksimere indlæringen – kan du teste forskellige hyperparametre automatisk ved at bruge en RandomizedSearchCV or GridSearchCV. Udover at have en baseline, kan du evaluere din models ydeevne ud fra linsen af ​​flere metrikker.

Nogle traditionelle klassifikationsmetrikker, der kan bruges til at evaluere algoritmen, er præcision, genkaldelse, f1-score, nøjagtighed og forvirringsmatrix. Her er en kort forklaring på hver af dem:

1. Precision: når vores mål er at forstå, hvilke korrekte forudsigelsesværdier, der blev betragtet som korrekte af vores klassifikator. Præcision vil dividere de sande positive værdier med de prøver, der blev forudsagt som positive;

$$
præcision = frac{tekst{true positives}}{text{true positives} + text{false positives}}
$$

2. Recall: almindeligvis beregnet sammen med præcision for at forstå, hvor mange af de sande positive, der blev identificeret af vores klassifikator. Tilbagekaldelsen beregnes ved at dividere de sande positive med alt, der skulle have været forudsagt som positivt.

$$
recall = frac{tekst{sande positives}}{tekst{sande positives} + tekst{falske negativer}}
$$

3. f1 score: er den balancerede eller harmonisk middel af præcision og genkaldelse. Den laveste værdi er 0 og den højeste er 1. Hvornår f1-score er lig med 1, betyder det, at alle klasser var korrekt forudsagt – dette er en meget svær score at opnå med rigtige data (undtagelser findes næsten altid).

$$
tekst{f1-score} = 2* frac{tekst{præcision} * tekst{recall}}{tekst{præcision} + tekst{recall}}
$$

4. Forvirringsmatrix: når vi skal vide, hvor mange prøver vi fik rigtigt eller forkert for hver klasse. De værdier, der var korrekte og korrekt forudsagte, kaldes sande positive, dem, der blev forudsagt som positive, men ikke var positive, kaldes falske positive. Den samme nomenklatur af sande negativer , falske negativer bruges til negative værdier;

5. Nøjagtighed: beskriver, hvor mange forudsigelser vores klassificerer fik rigtige. Den laveste nøjagtighedsværdi er 0, og den højeste er 1. Denne værdi ganges normalt med 100 for at få en procentdel:

$$
nøjagtighed = frac{tekst{antal korrekte forudsigelser}}{tekst{samlet antal forudsigelser}}
$$

Du kan udføre følgende script for at importere de nødvendige biblioteker og se på resultaterne:

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

Outputtet vil se nogenlunde således ud:

                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

Bemærk i klassifikationsrapporten, at tilbagekaldelsen er høj, 0.89 for klasse 0, både præcision og tilbagekaldelse er høj for klasse 2, 0.74, 0.72 – og for klasse 1 er de lave, især tilbagekaldelsen på 0.17 og en præcision på 0.57 . Forholdet mellem tilbagekaldelse og præcision for alle tre klasser individuelt er fanget i F1 score, som er den harmoniske middelværdi mellem genkaldelse og præcision – modellen gør orden for klasse 0, ret dårligt for klasse 1 og anstændigt for klasse 2.

Modellen har meget svært ved at identificere sager med middel risiko.

Nøjagtigheden opnået af vores tilfældige skovklassificering med kun 3 træer er af 0.58 (58%) – det betyder, at den får lidt mere end halvdelen af ​​resultaterne rigtigt. Dette er en lav nøjagtighed og kan måske forbedres ved at tilføje flere træer.

Ved at se på forvirringsmatricen kan vi se, at de fleste fejl er, når man klassificerer 52 registreringer af middel risiko som lav risiko, hvad der giver yderligere indsigt i den lave tilbagekaldelse af klasse 1. Det er forudindtaget i forhold til at klassificere mellemrisikopatienter som lav- risikopatienter.

En anden ting, der kan kontrolleres for at generere endnu mere indsigt, er, hvilke funktioner der tages mest i betragtning af klassifikatoren, når de forudsiger. Dette er et vigtigt skridt at tage for maskinlæringssystemer, der kan forklares, og hjælper med at identificere og afbøde skævhed i modeller.

For at se det kan vi få adgang til feature_importances_ klassificererens egenskab. Dette vil give os en liste over procenter, så vi også kan få adgang til feature_names_in_ egenskab for at få navnet på hver funktion, organisere dem i en dataramme, sortere dem fra højeste til laveste og plotte resultatet:

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)

Læg mærke til, hvordan klassificeringen for det meste overvejer blodsukker, så lidt af det diastoliske tryk, kropstemperatur og bare lidt alder til at træffe en beslutning, dette kan også have at gøre med den lave tilbagekaldelse på klasse 1, måske har de medium risikodata at gøre med funktioner, der ikke bliver taget meget i betragtning af modellen. Du kan prøve at lege mere med funktionernes betydning for at undersøge dette, og se om ændringer på modellen påvirker de funktioner, der bruges, også hvis der er en væsentlig sammenhæng mellem nogle af funktionerne og de forudsagte klasser.

Det er endelig tid til at generere en ny model med flere træer for at se, hvordan det påvirker resultaterne. Lad os skabe rfc_ skov med 900 træer, 8 niveauer og samme frø. Vil resultaterne blive bedre?

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

Beregning og visning af metrics:

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

Dette udsender:

                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

Dette viser, hvordan tilføjelse af flere træer og mere specialiserede træer (højere niveauer) har forbedret vores målinger. Vi har stadig en lav tilbagekaldelse for klasse 1, men nøjagtigheden er nu på 74%. F1-scoren ved klassificering af højrisikotilfælde er på 0.85, hvilket betyder, at højrisikotilfælde nu lettere kan identificeres sammenlignet med 0.73 i den tidligere model!

I et dagligt projekt kan det være vigtigere at identificere højrisikotilfælde, for eksempel med en metrik svarende til præcision, som også er kendt som følsomhed i statistik. Prøv at justere nogle af modelparametrene og observer resultaterne.

Indtil nu har vi opnået en overordnet forståelse af, hvordan Random Forest kan bruges til at klassificere data – i næste afsnit kan vi bruge det samme datasæt på en anden måde for at se, hvordan den samme model forudsiger værdier med regression.

Brug af tilfældige skove til regression

I dette afsnit vil vi studere, hvordan en Random Forest-algoritme kan bruges til at løse regressionsproblemer ved hjælp af Scikit-Learn. De trin, der følges for at implementere denne algoritme, er næsten identiske med de trin, der udføres for klassificering, udover typen af ​​model og typen af ​​forudsagte data – det vil nu være kontinuerlige værdier – der er kun én forskel i dataforberedelsen.

Da regression er lavet for numeriske værdier – lad os vælge en numerisk værdi fra datasættet. Vi har set, at blodsukkeret var vigtigt i klassificeringen, så det burde være forudsigeligt baseret på andre funktioner (da hvis det korrelerer med en eller anden funktion, korrelerer den funktion også med den).

Efter hvad vi har gjort for klassificering, lad os først importere bibliotekerne og det samme datasæt. Hvis du allerede har gjort dette til klassifikationsmodellen, kan du springe denne del over og gå direkte til at forberede data til træning.

Import af biblioteker og 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")

Dataforbehandling til regression

Dette er en regressionsopgave, så i stedet for at forudsige klasser, kan vi forudsige en af ​​de numeriske kolonner i datasættet. I dette eksempel er BS kolonne vil blive forudsagt. Dette betyder y data vil indeholde blodsukkerdataog X data vil indeholde alle funktionerne udover blodsukkeret. Efter adskillelse af X , y data, kan vi opdele tog- og testsættene:

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)

Træning af en RandomForestRegressor

Nu hvor vi har skaleret vores datasæt, er det tid til at træne vores algoritme til at løse dette regressionsproblem, at ændre det lidt op – vi laver en model med 20 træer i skoven og hver med 4 niveauer. For at gøre det, kan du udføre følgende kode:

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)

Du kan finde detaljer for alle parametrene for RandomForestRegressor i den officielle dokumentation.

Da det ville kræve noget tid og dedikation at plotte og se på 20 træer, kan vi plotte kun det første til at se, hvordan det er forskelligt fra klassifikationstræet:

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

Bemærk, at regressionstræet allerede har en værdi tildelt de data, der falder på hver node. Det er de værdier, der beregnes som gennemsnit, når de 20 træer kombineres. I forlængelse af det, vi har gjort med klassificering, kan du også plotte egenskabernes betydninger for at se, hvilke variabler regressionsmodellen tager mere i betragtning ved beregning af værdier.

Det er tid til at gå videre til det sidste og sidste trin, når du løser et maskinlæringsproblem og evaluerer algoritmens ydeevne!

Evaluering af en RandomForestRegressor

For regressionsproblemer er de metrikker, der bruges til at evaluere en algoritme, gennemsnitlig absolut fejl (MAE), middelkvadrat-fejl (MSE) og rodmiddelkvadrat-fejl (RMSE).

1. Gennemsnitlig absolut fejl (MAE): Når vi trækker de forudsagte værdier fra de faktiske værdier, opnår fejlene, summerer vi de absolutte værdier af disse fejl og får deres middelværdi. Denne metrik giver en forestilling om den samlede fejl for hver forudsigelse af modellen, jo mindre (tættere på 0) jo bedre.

$$
mae = (frac{1}{n})sum_{i=1}^{n}venstre | Faktisk – forudsagt rigtigt |
$$

2. Mean Squared Error (MSE): den ligner MAE-metrikken, men den kvadrerer de absolutte værdier af fejlene. Ligesom med MAE, jo mindre, eller tættere på 0, jo bedre. MSE-værdien er kvadreret for at gøre store fejl endnu større. En ting at være meget opmærksom på, det er, at det normalt er en svær metrik at fortolke på grund af størrelsen af ​​dens værdier og det faktum, at de ikke er i samme skala af dataene.

$$
mse = sum_{i=1}^{D}(Faktisk – forudsagt)^2
$$

3. Root Mean Squared Error (RMSE): forsøger at løse det fortolkningsproblem, der er rejst med MSE, ved at få kvadratroden af ​​dens endelige værdi, for at skalere det tilbage til de samme enheder af dataene. Det er lettere at fortolke og godt, når vi skal vise eller vise den faktiske værdi af dataene med fejlen. Det viser, hvor meget dataene kan variere, så hvis vi har en RMSE på 4.35, kan vores model lave en fejl, enten fordi den tilføjede 4.35 til den faktiske værdi eller havde brug for 4.35 for at nå den faktiske værdi. Jo tættere på 0, jo bedre også.

$$
rmse = sqrt{ sum_{i=1}^{D}(Faktisk – forudsagt)^2}
$$

Vi kan bruge enhver af disse tre metrics til sammenligne modeller (hvis vi skal vælge en). Vi kan også sammenligne den samme regressionsmodel med forskellige argumentværdier eller med forskellige data og derefter overveje evalueringsmetrikken. Dette er kendt som justering af hyperparameter – tuning af de hyperparametre, der påvirker en indlæringsalgoritme, og observation af resultaterne.

Når du vælger mellem modeller, klarer de med de mindste fejl sig som regel bedre. Ved overvågning af modeller, hvis metrikken blev værre, så var en tidligere version af modellen bedre, eller der var en væsentlig ændring i dataene for, at modellen kunne klare sig dårligere, end den præsterede.

Du kan bruge følgende kode for at finde disse værdier:

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

Outputtet skal være:

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

Med 20 træer er rodmiddelkvadrat-fejlen 1.75, hvilket er lavt, men alligevel – ved at hæve antallet af træer og eksperimentere med de andre parametre, kan denne fejl sandsynligvis blive endnu mindre.

Fordele ved at bruge Random Forest

Som med enhver algoritme er der fordele og ulemper ved at bruge den. I de næste to afsnit tager vi et kig på fordele og ulemper ved at bruge tilfældig skov til klassificering og regression.

1. Den tilfældige skovalgoritme er ikke forudindtaget, da der er flere træer, og hvert træ trænes på en tilfældig delmængde af data. Grundlæggende er den tilfældige skovalgoritme afhængig af kraften fra "mængden"; derfor reduceres den overordnede grad af bias af algoritmen.
2. Denne algoritme er meget stabil. Selv hvis et nyt datapunkt introduceres i datasættet, påvirkes den overordnede algoritme ikke meget, da nye data kan påvirke ét træ, men det er meget svært for det at påvirke alle træerne.
3. Den tilfældige skov-algoritme fungerer godt, når du har både kategoriske og numeriske funktioner.
4. Den tilfældige skovalgoritme fungerer også godt, når data mangler værdier, eller de ikke er blevet skaleret.

Ulemper ved at bruge Random Forest

1. Den største ulempe ved tilfældige skove ligger i deres kompleksitet. De kræver meget flere beregningsressourcer på grund af det store antal beslutningstræer, der er samlet, når man træner store ensembler. Men – med moderne hardware tager træning selv en stor tilfældig skov ikke meget tid.

Gå videre – Håndholdt ende-til-ende-projekt

Din nysgerrige natur giver dig lyst til at gå længere? Vi anbefaler at tjekke vores Vejledt projekt: “Hands-on husprisforudsigelse – maskinlæring i Python”.

I dette guidede projekt – vil du lære, hvordan du bygger kraftfulde traditionelle maskinlæringsmodeller såvel som deep learning-modeller, bruger Ensemble Learning og træner meta-elever til at forudsige huspriser ud fra en pose Scikit-Learn og Keras-modeller.

Ved at bruge Keras, deep learning API bygget oven på Tensorflow, eksperimenterer vi med arkitekturer, bygger et ensemble af stablede modeller og træner en meta-lærer neuralt netværk (niveau-1 model) for at finde ud af prisen på et hus.

Dyb læring er fantastisk – men før man griber til det, anbefales det også at forsøge at løse problemet med enklere teknikker, som f.eks. overfladisk læring algoritmer. Vores baseline præstation vil være baseret på en Tilfældig skovregression algoritme. Derudover – vi vil udforske at skabe ensembler af modeller gennem Scikit-Learn via teknikker som f.eks sække , afstemning.

Dette er et ende-til-ende-projekt, og ligesom alle Machine Learning-projekter starter vi med – med Udforskende dataanalyse, efterfulgt af Dataforarbejdning og endelig Bygning lavvandet , Deep Learning-modeller for at passe til de data, vi tidligere har udforsket og renset.