Definitieve gids voor het willekeurige bosalgoritme met Python en Scikit-Learn

Introductie

Het Random Forest-algoritme is een van de meest flexibele, krachtige en meest gebruikte algoritmen voor classificatie en regressie, gebouwd als een ensemble van beslissingsbomen.

Als u hier niet bekend mee bent, hoeft u zich geen zorgen te maken, we behandelen al deze concepten.

In deze uitgebreide praktische gids bouwen we een intuïtie over hoe beslissingsbomen werken, hoe ensembling individuele classifiers en regressors stimuleert, wat willekeurige forests zijn en een willekeurige forest-classifier en regressor bouwen met behulp van Python en Scikit-Learn, via een end-to-end miniproject, en een onderzoeksvraag beantwoorden.

Bedenk dat u momenteel deel uitmaakt van een onderzoeksgroep die gegevens over vrouwen analyseert. De groep heeft 100 datarecords verzameld en wil die eerste records kunnen ordenen door de vrouwen in te delen in categorieën: wel of niet zwanger zijn en wonen op het platteland of in de stad. De onderzoekers willen begrijpen hoeveel vrouwen in elke categorie zouden zitten.

Er is een rekenstructuur die precies dat doet, het is de boom structuur. Door een boomstructuur te gebruiken, kunt u de verschillende divisies voor elke categorie weergeven.

Beslissingsbomen

Hoe vul je de knopen van een boom? Dit is waar Beslissingsbomen in beeld komen.

Ten eerste kunnen we de gegevens indelen op zwangerschap, daarna kunnen we ze indelen op wonen in stedelijke of landelijke gebieden. Merk op dat we dit in een andere volgorde zouden kunnen doen, aanvankelijk delend door het gebied waar de vrouwen wonen en daarna door hun zwangerschapsstatus. Hieruit kunnen we zien dat de boom een ​​inherente hiërarchie heeft. Naast het organiseren van informatie, organiseert een boom informatie op een hiërarchische manier - de volgorde waarin de informatie verschijnt, is van belang en leidt als resultaat tot verschillende bomen.

Hieronder is een voorbeeld van de beschreven boom:

In de afbeelding van de boom zijn er 7 vierkanten, de bovenste die goed is voor het totaal van 100 vrouwen, dit bovenste vierkant is verbonden met twee vierkanten eronder, die de vrouwen verdelen op basis van hun aantal van 78 niet-zwanger en 22 zwanger, en van beide vorige vierkanten zijn er vier vierkanten; twee verbonden met elk vierkant erboven die de vrouwen verdelen op basis van hun gebied, voor de niet-zwangeren wonen er 45 in een stedelijk gebied, 33 in een landelijk gebied en voor de zwangere wonen er 14 in een landelijk gebied en 8 in een stedelijk gebied. Door gewoon naar de boom te kijken, is het gemakkelijk om die onderverdelingen te begrijpen en te zien hoe elke "laag" is afgeleid van vorige, die lagen zijn de boom niveaus, de niveaus beschrijven de diepte van de boom:

Zie in de afbeelding hierboven dat het eerste boomniveau is level 0 waar er maar één vierkant is, gevolgd door level 1 waar er twee vierkanten zijn, en level 2 waar vier vierkanten zijn. Dit is een diepte 2 boom.

In niveau 0 wordt het vierkant waaruit de boom stamt, de eerste genoemd root knooppunt, deze wortel heeft er twee kind knooppunten op niveau 1, dat zijn bovenliggende knooppunten naar de vier knooppunten in niveau 2. Zie dat de "vierkanten" die we tot nu toe hebben genoemd, eigenlijk worden genoemd knooppunten; en dat elk vorig knooppunt een ouder is van de volgende knooppunten, dat zijn zijn kinderen. De onderliggende knooppunten van elk niveau die dezelfde ouder hebben, worden aangeroepen broers en zussen, zoals te zien is in de volgende afbeelding:

In de vorige afbeelding geven we ook niveau 1 weer als de inwendige knooppunten, als ze zich eenmaal tussen de root en de laatste knooppunten bevinden, dat zijn de blad knooppunten. De bladknopen zijn het laatste deel van een boom. Als we van de 100 eerste vrouwen zouden zeggen hoeveel er zwanger zijn en op het platteland wonen, zouden we dit kunnen doen door naar de bladeren te kijken. Dus het nummer bij de bladeren zou de eerste onderzoeksvraag beantwoorden.

Als er nieuwe gegevens van vrouwen waren, en de boom die eerder werd gebruikt om ze te categoriseren, nu zou worden gebruikt om te beslissen of een vrouw wel of niet deel kon uitmaken van het onderzoek, zou die dan nog functioneren? De boom zou dezelfde criteria gebruiken en een vrouw zou in aanmerking komen om deel te nemen als ze zwanger is en in een landelijk gebied woont.

Door naar de afbeelding hierboven te kijken, kunnen we zien dat de antwoorden op de vragen van elk boomknooppunt - "is ze een deelnemer?", "is ze zwanger?", "woont ze in een landelijk gebied?" - ja zijn, ja, en ja, het lijkt er dus op dat de boom ideed kan leiden tot een beslissing, in dit geval, dat de vrouw mocht deelnemen aan het onderzoek.

Dit is de essentie van beslisbomen in, handmatig gedaan. Met behulp van Machine Learning kunnen we een model construeren dat deze boom automatisch voor ons construeert, op zo'n manier dat de nauwkeurigheid van de uiteindelijke beslissingen wordt gemaximaliseerd.

Bekijk in de voorgaande voorbeelden hoe de boom dat ook zou kunnen classificeren nieuwe gegevens als deelnemer of niet-deelnemer, of de vragen kunnen ook worden gewijzigd in - "hoeveel deelnemers zijn er?", "hoeveel zijn er zwanger?", "hoeveel wonen er in een landelijk gebied?" - waardoor we de hoeveelheid van zwangere deelnemers die in een landelijk gebied wonen.

Wanneer de gegevens geclassificeerd zijn, betekent dit dat de boom een classificatie taak, en wanneer de hoeveelheid gegevens is gevonden, voert de boom een regressie taak. Dit betekent dat de beslisboom voor beide taken kan worden gebruikt – classificatie en regressie.

Nu we begrijpen wat een beslisboom is, hoe deze kan worden gebruikt en welke nomenclatuur wordt gebruikt om hem te beschrijven, kunnen we ons afvragen wat de beperkingen ervan zijn.

Willekeurige bossen begrijpen

Wat gebeurt er met het besluit als een deelnemer woont op de scheiding tussen stad en platteland? Zou de boom dit record toevoegen aan landelijk of stedelijk? Het lijkt moeilijk om deze gegevens in te passen in de structuur die we momenteel hebben, omdat het vrij duidelijk is.

En wat als een vrouw die op een boot woont aan het onderzoek deelneemt, zou het dan als landelijk of stedelijk worden beschouwd? Op dezelfde manier als het vorige geval, is het een uitdagend gegevenspunt om te classificeren gezien de beschikbare opties in de boomstructuur.

Door wat meer na te denken over het voorbeeld van de beslisboom, kunnen we zien dat het nieuwe gegevens correct kan classificeren, aangezien het al een patroon volgt dat de boom al heeft - maar als er records zijn die verschillen van de initiële gegevens die de boom definieerden, de boomstructuur is te rigide, waardoor de records niet classificeerbaar zijn.

Dit betekent dat de beslisboom strikt en beperkt in zijn mogelijkheden kan zijn. Een ideale beslisboom zou flexibeler zijn en meer genuanceerde ongeziene gegevens kunnen bevatten.

Wat betreft het antwoord op de initiële vraag, we weten al dat het zal worden gecodeerd in de boombladeren - maar wat verandert er als we veel bomen hebben in plaats van één?

Als de bomen worden gecombineerd voor een classificatie, wordt het resultaat bepaald door de meerderheid van de antwoorden, dit wordt genoemd meerderheid van stemmen; en in het geval van een regressie, zal het aantal gegeven door elke boom in het bos zijn gemiddeld.

Ensemble leren en modelensembles

Deze methode staat bekend als: ensemble leren. Bij het gebruik van ensembleleren kunt u alle algoritmen combineren, zolang u ervoor kunt zorgen dat de uitvoer kan worden geparseerd en gecombineerd met andere uitvoer (handmatig of met behulp van bestaande bibliotheken). Doorgaans verzamelt u meerdere modellen van hetzelfde type samen, zoals meerdere beslissingsbomen, maar u bent niet beperkt tot alleen maar deelnemen aan ensembles van hetzelfde modeltype.

Ensembleren is een praktisch gegarandeerde manier om een ​​probleem beter te generaliseren en er een kleine prestatieverbetering uit te persen. In sommige gevallen levert het assembleren van modellen een aanzienlijke toename in voorspellend vermogen, en soms slechts een klein beetje. Dit is afhankelijk van de dataset waarop u traint en evalueert, evenals de modellen zelf.

Beslisbomen samenvoegen levert op aanzienlijke prestatieverbeteringen vergeleken met individuele bomen. Deze benadering werd gepopulariseerd in de onderzoeks- en toegepaste machine learning-gemeenschappen, en was zo gebruikelijk dat het ensemble van beslissingsbomen in de volksmond een Bos, en het gemeenschappelijke type forest dat werd gecreëerd (een forest van beslissingsbomen op een willekeurige subset van kenmerken) maakte de naam populair willekeurige bossen.

Gezien het grootschalige gebruik hebben bibliotheken zoals Scikit-Learn wrappers geïmplementeerd voor RandomForestRegressors en RandomForestClassifiers, gebouwd bovenop hun eigen beslisboomimplementaties, zodat onderzoekers hun eigen ensembles niet hoeven te bouwen.

Laten we in willekeurige bossen duiken!

Hoe werkt het willekeurige bosalgoritme?

Hieronder volgen de basisstappen bij het uitvoeren van het random forest-algoritme:

1. Kies een aantal willekeurige records, dit kan elk getal zijn, zoals 4, 20, 76, 150 of zelfs 2.000 uit de dataset (genaamd N verslagen). Het aantal hangt af van de breedte van de dataset, hoe breder, hoe groter N kan zijn. Dit is waar de willekeurige deel in de naam van het algoritme komt van!
2. Bouw op basis daarvan een beslisboom N willekeurige records;
3. Herhaal stappen 1 en 2 volgens het aantal bomen dat is gedefinieerd voor het algoritme, of het aantal bomen in het bos. Dit genereert meer bomen uit sets van willekeurige gegevensrecords;
4. Na stap 3 komt de laatste stap, het voorspellen van de resultaten:
   • In geval van classificatie: elke boom in het bos zal de categorie voorspellen waartoe het nieuwe record behoort. Daarna wordt het nieuwe record toegewezen aan de categorie die de meeste stemmen wint.
   • In geval van regressie: elke boom in het bos voorspelt een waarde voor het nieuwe record, en de uiteindelijke voorspellingswaarde wordt berekend door een gemiddelde te nemen van alle waarden die door alle bomen in het bos zijn voorspeld.

Elke boom die op een willekeurige subset van kenmerken past, heeft noodzakelijkerwijs geen kennis van sommige andere kenmerken, wat wordt verholpen door samenvoeging, terwijl de rekenkosten lager blijven.

Met een intuïtie over hoe bomen werken en een goed begrip van willekeurige bossen - het enige dat overblijft is oefenen met het bouwen, trainen en afstemmen op gegevens!

Willekeurige bosmodellen bouwen en trainen met Scikit-Learn

De tot nu toe gebruikte voorbeelden hebben niet voor niets betrekking op zwangerschap, woonoppervlakte en vrouwen.

In 2020 merkten onderzoekers uit Bangladesh dat de sterfte onder zwangere vrouwen nog steeds erg hoog is, zeker gezien degenen die op het platteland wonen. Daarom gebruikten ze een IOT-bewakingssysteem analyseer het risico op de gezondheid van de moeder. Het IOT-systeem verzamelde gegevens van verschillende ziekenhuizen, gemeenschapsklinieken en gezondheidszorg voor moeders in de plattelandsgebieden van Bangladesh.

De verzamelde gegevens werden vervolgens georganiseerd in een bestand met door komma's gescheiden waarden (csv) en geüpload naar UCI's machine learning-repository.

Dit zijn de gegevens die we zullen gebruiken om te oefenen en proberen te begrijpen of een zwangere vrouw een lage, Medium or hoog risico op overlijden.

Willekeurig bos gebruiken voor classificatie

Omdat we willen weten of de vrouw een lage, Medium or hoog risico op overlijden, dit betekent dat we een indeling gaan maken met drie klassen. Als een probleem meer dan twee klassen heeft, wordt het een genoemd multiclass probleem, in tegenstelling tot a binair probleem (waarbij u tussen twee klassen kiest, typisch 0 en 1).

In dit eerste voorbeeld zullen we een classificatiemodel met meerdere klassen implementeren met een Random Forest-classificatie en Scikit-Learn van Python.

We zullen de gebruikelijke machine learning-stappen volgen om dit probleem op te lossen, namelijk het laden van bibliotheken, het lezen van de gegevens, het bekijken van samenvattende statistieken en het maken van gegevensvisualisaties om het beter te begrijpen. Vervolgens de gegevens voorbewerken en splitsen, gevolgd door het genereren, trainen en evalueren van een model.

Bibliotheken importeren

We zullen Panda's gebruiken om de gegevens te lezen, Seaborn en Matplotlib om het te visualiseren, en NumPy voor de geweldige hulpprogramma-methoden:

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

De gegevensset importeren

De volgende code importeert de dataset en laadt deze in een python DataFrame:

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

Om naar de eerste vijf regels van de gegevens te kijken, voeren we de head() opdracht:

dataset.head()

Dit levert op:

    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

Hier kunnen we alle attributen zien die tijdens het onderzoek zijn verzameld.

• Leeftijd: leeftijden in jaren.
• SystolicBP: bovenwaarde van de bloeddruk in mmHg, een belangrijk kenmerk tijdens de zwangerschap.
• Diastolische bloeddruk: lagere waarde van de bloeddruk in mmHg, een ander belangrijk kenmerk tijdens de zwangerschap.
• BS: bloedglucosewaarden in termen van een molaire concentratie, mmol/L.
• HeartRate: rusthartslag in slagen per minuut.
• RiskLevel: risiconiveau tijdens de zwangerschap.
• BodyTemp: de lichaamstemperatuur.

Nu we meer begrijpen over wat er wordt gemeten, kunnen we kijken naar de soorten gegevens waarmee info():

dataset.info()

Dit resulteert in:

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

Van het kijken naar de RangeIndex lijn, kunnen we zien dat er 1014 records zijn en de kolom Non-Null Count informeert dat de gegevens geen ontbrekende waarden hebben. Dit betekent dat we geen behandeling hoeven uit te voeren voor ontbrekende gegevens!

In het Dtype kolom, kunnen we het type van elke variabele zien. Momenteel, float64 kolommen zoals BS en BodyTemp numerieke waarden hebben die in elk bereik kunnen variëren, zoals 15.0, 15.51, 15.76, 17.28, waardoor ze numeriek continu (je kunt altijd een 0 toevoegen aan een getal met drijvende komma, ad infinitem). Aan de andere kant, variabelen zoals Age, SystolicBP, DiastolicBP en HeartRate zijn van het type int64, dit betekent dat de cijfers alleen per eenheid veranderen, zoals 11, 12, 13, 14 – we hebben geen hartslag van 77.78, het is 77 of 78 – dat zijn numeriek discreet waarden. En dat hebben we ook RiskLevel met een object type, geeft dit meestal aan dat de variabele een tekst is en dat we deze waarschijnlijk moeten omzetten in een getal. Aangezien het risiconiveau van laag naar hoog groeit, is er een impliciete volgorde in de categorieën, dit geeft aan dat het een categorisch ordinaal variabel.

Nadat we naar gegevenstypen hebben gekeken, kunnen we gebruiken describe() om een ​​piek te nemen bij enkele beschrijvende statistieken, zoals de gemiddelde waarden van elke kolom, de standaarddeviatie, kwantielen, minimale en maximale gegevenswaarden:

dataset.describe().T 

De bovenstaande code wordt weergegeven:

            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

Merk op dat voor de meeste kolommen de gemiddelde waarden zijn verre van de standaarddeviatie (standaard) – dit geeft aan dat de gegevens niet noodzakelijkerwijs een goed gedragen statistische verdeling volgen. Als dat zo was, zou het het model hebben geholpen bij het voorspellen van het risico. Wat hier kan worden gedaan, is de gegevens voorbewerken om ze representatiever te maken alsof het gegevens zijn van de hele wereldbevolking, of meer genormaliseerde. Maar een voordeel bij het gebruik van Random Forest-modellen voor classificatie, is dat de inherente boomstructuur goed kan omgaan met gegevens die niet zijn genormaliseerd, als deze eenmaal is gedeeld door de waarde in elk boomniveau voor elke variabele.

Omdat we bomen gebruiken en de resulterende klasse wordt verkregen door te stemmen, vergelijken we ook niet inherent tussen verschillende waarden, alleen tussen dezelfde soorten waarden, dus het is in dit geval niet nodig om de kenmerken op dezelfde schaal aan te passen . Dit betekent dat het Random Forest-classificatiemodel dat is schaal invariant, en u hoeft functies niet te schalen.

In dit geval is de stap in de voorverwerking van gegevens die we kunnen nemen, het transformeren van het categorische RiskLevel kolom in een numerieke.

De gegevens visualiseren

Voor het transformeren RiskLevel, laten we de gegevens ook snel visualiseren door te kijken naar de combinaties van punten voor elk paar kenmerken met een spreidingsdiagram en hoe de punten zijn verdeeld door de histogramcurve te visualiseren. Om dat te doen, zullen we Seaborn's gebruiken pairplot() die beide percelen combineert. Het genereert beide plots voor elke kenmerkcombinatie en geeft de punten weer met een kleurcode volgens hun risiconiveau met de hue eigendom:

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

De bovenstaande code genereert:

Als je naar de plot kijkt, zou de ideale situatie zijn om een ​​duidelijke scheiding te hebben tussen curven en stippen. Zoals we kunnen zien, worden de drie soorten risicoklassen meestal door elkaar gehaald, aangezien bomen intern lijnen trekken bij het afbakenen van de ruimtes tussen punten, kunnen we veronderstellen dat meer bomen in het bos meer ruimtes kunnen beperken en de punten beter kunnen classificeren.

Nu de basis verkennende gegevensanalyse is uitgevoerd, kunnen we de gegevens voorbewerken RiskLevel kolom.

Gegevensvoorverwerking voor classificatie

Voor de zekerheid zijn er maar drie klassen van RiskLevel in onze gegevens, en dat er geen andere waarden ten onrechte zijn toegevoegd, kunnen we gebruiken unique() om de unieke waarden van de kolom weer te geven:

dataset['RiskLevel'].unique()

Dit levert op:

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

De klassen zijn gecontroleerd, nu is de volgende stap om elke waarde om te zetten in een getal. Omdat er een volgorde is tussen classificaties, kunnen we de waarden 0, 1 en 2 gebruiken om aan te duiden lage, Medium en hoog risico's. Er zijn veel manieren om de kolomwaarden te wijzigen, in navolging van Python simpel is beter dan complex motto, zullen we gebruik maken van de .replace() methode, en vervang ze eenvoudig door hun representaties van gehele getallen:

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

Nadat we de waarden hebben vervangen, kunnen we de gegevens verdelen in wat zal worden gebruikt voor het trainen van het model, de functionaliteiten or X, en wat we willen voorspellen, de labels or y:

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

Wanneer de X en y sets zijn klaar, we kunnen Scikit-Learn's gebruiken train_test_split() methode om ze verder te verdelen in de trein- en testsets:

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)

Hier gebruiken we 20% van de data voor testen en 80% voor training.

Een RandomForestClassifier trainen

Scikit-Learn implementeerde ensembles onder de sklearn.ensemble moduul. Een ensemble van beslissingsbomen die worden gebruikt voor classificatie, waarin een meerderheid van stemmen wordt genomen, wordt geïmplementeerd als de RandomForestClassifier.

Met de trein- en testsets kunnen we de RandomForestClassifier klasse en maak het model. Laten we om te beginnen een bos met drie bomen maken door in te stellen n_estimators parameter als 3, en waarbij elke boom drie niveaus heeft, door in te stellen max_depthnaar 2:

from sklearn.ensemble import RandomForestClassifier

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

Om het model rond de gegevens te passen, noemen we de fit() methode, het doorgeven van de trainingskenmerken en labels:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

We kunnen nu de voorspelde labels vergelijken met de echte labels om te evalueren hoe goed het model het deed! Laten we, voordat we het model evalueren, het ensemble eens bekijken.

Om wat dieper in het model te kijken, kunnen we elk van de bomen visualiseren en hoe ze de gegevens verdelen. Dit kan door gebruik te maken van de tree module ingebouwd in Scikit-Learn, en vervolgens door elk van de schatters in het ensemble lopen:

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

De bovenstaande code geeft de boomplots weer:

Merk op hoe de drie bomen verschillen. De eerste begint met de BS functie, de tweede met DiastolicBP, en de derde met BS opnieuw. Al kijkt de derde naar een ander aantal monsters. Op de rechtertak bepalen de eerste twee bomen ook het gebruik Age op bladniveau, terwijl de derde boom eindigt met BS voorzien zijn van. Met slechts drie schatters is het duidelijk hoe opschalen een rijke, diverse weergave van de kennis oplevert die met succes kan worden gecombineerd tot een zeer nauwkeurig model.

Hoe meer bomen in het bos, hoe diverser het model kan zijn. Er is echter een punt van afnemende meeropbrengsten, aangezien er veel bomen passen op een willekeurige subset van kenmerken, er zullen nogal wat vergelijkbare bomen zijn die niet veel diversiteit in het ensemble bieden, en die beginnen te hebben te veel stemrecht en scheef het ensemble om overfit te zijn op de trainingsdataset, wat de generalisatie naar de validatieset schaadt.

Er is eerder een hypothese gemaakt over het hebben van meer bomen en hoe dit de modelresultaten zou kunnen verbeteren. Laten we de resultaten eens bekijken, een nieuw model genereren en kijken of de hypothese klopt!

De RandomForestClassifier evalueren

Scikit-Learn maakt het gemakkelijk om basislijnen te creëren door een DummyClassifier, die voorspellingen uitvoert zonder de invoerfuncties te gebruiken (totaal willekeurige uitgangen). Als uw model beter is dan de DummyClassifier, sommige leren gebeurt! Om het leren te maximaliseren, kunt u verschillende hyperparameters automatisch testen met behulp van een RandomizedSearchCV or GridSearchCV. Naast het hebben van een basislijn, kunt u de prestaties van uw model evalueren vanuit de lens van verschillende statistieken.

Enkele traditionele classificatiestatistieken die kunnen worden gebruikt om het algoritme te evalueren, zijn precisie, herinnering, f1-score, nauwkeurigheid en verwarringsmatrix. Hier is een korte uitleg over elk van hen:

1. precisie: wanneer het ons doel is om te begrijpen welke correcte voorspellingswaarden door onze classificator als correct werden beschouwd. Precisie deelt die echte positieve waarden door de monsters die als positief werden voorspeld;

$$
precisie = frac{tekst{true positives}}{text{true positives} + text{false positives}}
$$

2. Terugroepen: gewoonlijk berekend samen met precisie om te begrijpen hoeveel van de echte positieven werden geïdentificeerd door onze classificator. De terugroepactie wordt berekend door de echte positieven te delen door alles wat als positief had moeten worden voorspeld.

$$
recall = frac{tekst{true positives}}{text{true positives} + text{false negatives}}
$$

3. F1-score: is de gebalanceerde of harmonisch gemiddelde van precisie en herinnering. De laagste waarde is 0 en de hoogste is 1. Wanneer f1-score gelijk is aan 1, betekent dit dat alle klassen correct werden voorspeld - dit is een zeer moeilijke score om te verkrijgen met echte gegevens (uitzonderingen zijn er bijna altijd).

$$
tekst{f1-score} = 2* frac{tekst{precisie} * tekst{herinnering}}{tekst{precisie} + tekst{herinnering}}
$$

4. Verwarring Matrix: wanneer we moeten weten voor hoeveel monsters we goed of fout zijn elke klas. De waarden die correct en correct voorspeld waren, worden genoemd echte positieven, degenen die als positief werden voorspeld maar niet positief waren, worden genoemd valse positieven. Dezelfde nomenclatuur van echte negatieven en valse negatieven wordt gebruikt voor negatieve waarden;

5. Nauwkeurigheid: beschrijft hoeveel voorspellingen onze classifier juist had. De laagste nauwkeurigheidswaarde is 0 en de hoogste is 1. Die waarde wordt meestal vermenigvuldigd met 100 om een ​​percentage te verkrijgen:

$$
nauwkeurigheid = frac{text{aantal correcte voorspellingen}}{text{totaal aantal voorspellingen}}
$$

U kunt het volgende script uitvoeren om de benodigde bibliotheken te importeren en de resultaten te bekijken:

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

De uitvoer ziet er ongeveer zo uit:

                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

Merk in het classificatierapport op dat de recall hoog is, 0.89 voor klasse 0, zowel de precisie als de recall zijn hoog voor klasse 2, 0.74, 0.72 - en voor klasse 1 zijn ze laag, met name de recall van 0.17 en een precisie van 0.57 . De relatie tussen het terugroepen en de precisie voor alle drie de klassen afzonderlijk wordt vastgelegd in de F1 score, wat het harmonische gemiddelde is tussen herinnering en precisie – het model doet okay voor klasse 0, redelijk slecht voor klasse 1 en redelijk voor klasse 2.

Het model heeft het erg moeilijk bij het identificeren van de gevallen met gemiddeld risico.

De nauwkeurigheid die wordt bereikt door onze willekeurige bosclassificator met slechts 3 bomen is van 0.58 (58%) – dit betekent dat iets meer dan de helft van de resultaten goed is. Dit is een lage nauwkeurigheid en kan misschien worden verbeterd door meer bomen toe te voegen.

Door naar de verwarringsmatrix te kijken, kunnen we zien dat de meeste fouten worden gemaakt bij het classificeren van 52 records met gemiddeld risico als laag risico, wat meer inzicht geeft in de lage herinnering van klasse 1. Het is geneigd om patiënten met gemiddeld risico te classificeren als laag risico. risico patiënten.

Een ander ding dat kan worden gecontroleerd om nog meer inzicht te genereren, is met welke kenmerken de classificator het meest rekening houdt bij het voorspellen. Dit is een belangrijke stap om voor te zetten verklaarbare machine learning-systemen, en helpt bij het identificeren en verminderen van vertekeningen in modellen.

Om dat te zien, hebben we toegang tot de feature_importances_ eigenschap van de classificator. Dit geeft ons een lijst met percentages, zodat we ook toegang hebben tot de feature_names_in_ eigenschap om de naam van elke functie te krijgen, deze in een dataframe te ordenen, ze van hoog naar laag te sorteren en het resultaat uit te zetten:

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)

Merk op hoe de classificator meestal rekening houdt met de bloed suiker, dan een beetje van de diastolische druk, lichaamstemperatuur en slechts een beetje leeftijd om een ​​beslissing te nemen, dit kan ook te maken hebben met de lage herinnering aan klasse 1, misschien hebben de gemiddelde risicogegevens te maken met kenmerken die niet worden veel rekening mee gehouden door het model. U kunt proberen meer te spelen met het belang van functies om dit te onderzoeken en te zien of wijzigingen in het model van invloed zijn op de functies die worden gebruikt, ook als er een significante relatie is tussen sommige functies en de voorspelde klassen.

Het is eindelijk tijd om een ​​nieuw model met meer bomen te genereren om te zien hoe dit de resultaten beïnvloedt. Laten we de maken rfc_ bos met 900 bomen, 8 niveaus en hetzelfde zaad. Zullen de resultaten verbeteren?

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

De statistieken berekenen en weergeven:

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

Dit levert op:

                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

Dit laat zien hoe het toevoegen van meer bomen en meer gespecialiseerde bomen (hogere niveaus) onze statistieken heeft verbeterd. We hebben nog steeds een lage recall voor klasse 1, maar de nauwkeurigheid is nu 74%. De F1-score bij het classificeren van gevallen met een hoog risico is 0.85, wat betekent dat gevallen met een hoog risico nu gemakkelijker kunnen worden geïdentificeerd in vergelijking met 0.73 in het vorige model!

In een dagelijks project kan het belangrijker zijn om gevallen met een hoog risico te identificeren, bijvoorbeeld met een maatstaf die vergelijkbaar is met precisie, ook wel bekend als gevoeligheid bij statistieken. Probeer enkele van de modelparameters aan te passen en bekijk de resultaten.

Tot nu toe hebben we een algemeen begrip verkregen van hoe Random Forest kan worden gebruikt voor het classificeren van gegevens. In de volgende sectie kunnen we dezelfde dataset op een andere manier gebruiken om te zien hoe hetzelfde model waarden voorspelt met regressie.

Willekeurige forests gebruiken voor regressie

In deze sectie zullen we bestuderen hoe een Random Forest-algoritme kan worden gebruikt om regressieproblemen op te lossen met behulp van Scikit-Learn. De stappen die worden gevolgd om dit algoritme te implementeren zijn bijna identiek aan de stappen die worden uitgevoerd voor classificatie, behalve het type model en het type voorspelde gegevens - dat zullen nu continue waarden zijn - is er slechts één verschil in de gegevensvoorbereiding.

Omdat regressie is gedaan voor numerieke waarden – laten we een numerieke waarde uit de dataset kiezen. We hebben gezien dat bloedsuiker belangrijk was in de classificatie, dus het zou voorspelbaar moeten zijn op basis van andere kenmerken (want als het correleert met een bepaald kenmerk, correleert dat kenmerk er ook mee).

In navolging van wat we hebben gedaan voor classificatie, gaan we eerst de bibliotheken en dezelfde dataset importeren. Als je dit al hebt gedaan voor het classificatiemodel, kun je dit deel overslaan en direct doorgaan met het voorbereiden van gegevens voor training.

Bibliotheken en gegevens importeren

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

Gegevensvoorverwerking voor regressie

Dit is een regressietaak, dus in plaats van klassen te voorspellen, kunnen we een van de numerieke kolommen van de dataset voorspellen. In dit voorbeeld is de BS kolom wordt voorspeld. Dit betekent de y gegevens zullen bevatten bloedsuiker gegevens en X gegevens bevatten alle functies naast de bloedsuikerspiegel. Na het scheiden van de X en y gegevens kunnen we de trein- en testsets splitsen:

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)

Een RandomForestRegressor trainen

Nu we onze dataset hebben geschaald, is het tijd om ons algoritme te trainen om dit regressieprobleem op te lossen, om het een beetje te veranderen – we zullen een model maken met 20 bomen in het bos en elk met 4 niveaus. Om dit te doen, kunt u de volgende code uitvoeren:

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)

U kunt details vinden voor alle parameters van RandomForestRegressor in de officiële documentatie.

Aangezien het plotten en bekijken van 20 bomen enige tijd en toewijding zou vergen, kunnen we alleen de eerste plotten om te zien hoe deze verschilt van de classificatieboom:

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

Merk op dat de regressieboom al een waarde heeft toegewezen aan de gegevens die op elk knooppunt vallen. Dat zijn de waarden die worden gemiddeld bij het combineren van de 20 bomen. In navolging van wat we hebben gedaan met classificatie, kunt u ook het belang van kenmerken plotten om te zien met welke variabelen het regressiemodel meer rekening houdt bij het berekenen van waarden.

Het is tijd om door te gaan naar de laatste en laatste stap bij het oplossen van een machine learning-probleem en de prestaties van het algoritme te evalueren!

Een RandomForestRegressor evalueren

Voor regressieproblemen zijn de metrieken die worden gebruikt om een ​​algoritme te evalueren, mean absolute error (MAE), mean squared error (MSE) en root mean squared error (RMSE).

1. Gemiddelde absolute fout (MAE): wanneer we de voorspelde waarden aftrekken van de werkelijke waarden, de fouten verkrijgen, de absolute waarden van die fouten optellen en hun gemiddelde krijgen. Deze statistiek geeft een idee van de algehele fout voor elke voorspelling van het model, hoe kleiner (dichter bij 0) hoe beter.

$$
mae = (frac{1}{n})sum_{i=1}^{n}links | Werkelijk – Voorspeld juist |
$$

2. Gemiddelde kwadratische fout (MSE): het is vergelijkbaar met de MAE-metriek, maar het kwadrateert de absolute waarden van de fouten. Ook, net als bij MAE, hoe kleiner, of dichter bij 0, hoe beter. De MSE-waarde wordt gekwadrateerd om grote fouten nog groter te maken. Een ding om goed op te letten, is dat het meestal een moeilijke metriek is om te interpreteren vanwege de grootte van de waarden en het feit dat ze niet op dezelfde schaal van de gegevens staan.

$$
mse = sum_{i=1}^{D}(Eigenlijk – Voorspeld)^2
$$

3. Root Mean Squared Error (RMSE): probeert het interpretatieprobleem op te lossen dat met de MSE is opgeworpen door de vierkantswortel van de uiteindelijke waarde te krijgen, om het terug te schalen naar dezelfde eenheden van de gegevens. Het is gemakkelijker te interpreteren en goed wanneer we de werkelijke waarde van de gegevens met de fout moeten weergeven of tonen. Het laat zien hoeveel de gegevens kunnen variëren, dus als we een RMSE van 4.35 hebben, kan ons model een fout maken omdat het 4.35 heeft toegevoegd aan de werkelijke waarde, of omdat het 4.35 nodig had om tot de werkelijke waarde te komen. Hoe dichter bij 0, hoe beter ook.

$$
rmse = sqrt{ sum_{i=1}^{D}(Eigenlijk – Voorspeld)^2}
$$

We kunnen elk van deze drie metrische gegevens gebruiken om: vergelijken modellen (als we er een moeten kiezen). We kunnen hetzelfde regressiemodel ook vergelijken met verschillende argumentwaarden of met verschillende gegevens en dan de evaluatiestatistieken in overweging nemen. Dit staat bekend als afstemming van hyperparameters – afstemmen van de hyperparameters die een leeralgoritme beïnvloeden en het observeren van de resultaten.

Bij het kiezen tussen modellen presteren de modellen met de kleinste fouten meestal beter. Als bij het monitoren van modellen de statistieken slechter werden, was een eerdere versie van het model beter, of was er een significante wijziging in de gegevens waardoor het model slechter presteerde dan het presteerde.

U kunt de volgende code gebruiken om deze waarden te vinden:

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

De output zou moeten zijn:

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

Met 20 bomen is de root mean squared error 1.75 wat laag is, maar toch – door het aantal bomen te verhogen en te experimenteren met de andere parameters, zou deze fout waarschijnlijk nog kleiner kunnen worden.

Voordelen van het gebruik van Random Forest

Zoals bij elk algoritme, zijn er voor- en nadelen aan het gebruik ervan. In de volgende twee secties bekijken we de voor- en nadelen van het gebruik van willekeurige forests voor classificatie en regressie.

1. Het random forest-algoritme is niet bevooroordeeld, aangezien er meerdere bomen zijn en elke boom wordt getraind op een willekeurige subset van gegevens. Kortom, het random forest-algoritme vertrouwt op de kracht van "de menigte"; daarom wordt de algehele mate van vertekening van het algoritme verminderd.
2. Dit algoritme is zeer stabiel. Zelfs als er een nieuw datapunt in de dataset wordt geïntroduceerd, wordt het algehele algoritme niet veel beïnvloed, aangezien nieuwe data één boom kunnen beïnvloeden, maar het is erg moeilijk om alle bomen te beïnvloeden.
3. Het random forest-algoritme werkt goed als je zowel categorische als numerieke kenmerken hebt.
4. Het random forest-algoritme werkt ook goed wanneer gegevens ontbrekende waarden hebben of niet zijn geschaald.

Nadelen van het gebruik van Random Forest

1. Het grootste nadeel van willekeurige bossen ligt in hun complexiteit. Ze vereisen veel meer rekenkracht vanwege het grote aantal samengevoegde beslissingsbomen bij het trainen van grote ensembles. Maar met moderne hardware kost het trainen van zelfs een groot willekeurig forest niet veel tijd.

Verder gaan - Hand-held end-to-end project

Je leergierige karakter maakt dat je verder wilt gaan? We raden aan om onze Begeleid project: "Hands-on huizenprijsvoorspelling - machinaal leren in Python".

In dit begeleide project leer je hoe je krachtige traditionele machine learning-modellen en deep learning-modellen bouwt, Ensemble Learning gebruikt en meta-leerlingen traint om huizenprijzen te voorspellen uit een zak met Scikit-Learn- en Keras-modellen.

Met Keras, de deep learning-API die bovenop Tensorflow is gebouwd, experimenteren we met architecturen, bouwen we een ensemble van gestapelde modellen en trainen we een meta-leerling neuraal netwerk (niveau-1-model) om de prijs van een huis te berekenen.

Diep leren is verbazingwekkend - maar voordat u er gebruik van maakt, is het raadzaam om ook te proberen het probleem op te lossen met eenvoudigere technieken, zoals met oppervlakkig leren algoritmen. Onze basisprestaties zullen gebaseerd zijn op een Willekeurige bosregressie algoritme. Daarnaast zullen we onderzoeken hoe we ensembles van modellen kunnen maken via Scikit-Learn via technieken zoals: zakken en stemming.

Dit is een end-to-end-project, en net als bij alle Machine Learning-projecten beginnen we met – met Verkennende gegevensanalyse, Gevolgd door Data Preprocessing en tot slot Ondiep bouwen en Diepe leermodellen om te passen bij de gegevens die we eerder hebben onderzocht en opgeschoond.