Random Forest-algoritme met Python en Scikit-Learn

Random forest is een type machine-learning-algoritme onder supervisie dat is gebaseerd op ensembleleren. Ensemble-leren is een vorm van leren waarbij verschillende soorten algoritmen of hetzelfde algoritme meerdere keren worden gecombineerd om een krachtiger voorspellingsmodel te vormen. Het random forest algoritme combineert meerdere algoritmen van hetzelfde type, d.w.z. meerdere beslisbomen, wat resulteert in een bos van bomen, vandaar de naam “Random Forest”. Het Random Forest-algoritme kan zowel voor regressie- als classificatietaken worden gebruikt.

Hoe het Random Forest-algoritme werkt

De volgende basisstappen zijn betrokken bij het uitvoeren van het Random Forest-algoritme:

1. Kies N willekeurige records uit de dataset.
2. Bouw een beslisboom op basis van deze N records.
3. Kies het aantal bomen dat je in je algoritme wilt hebben en herhaal stap 1 en 2.
4. In het geval van een regressieprobleem voorspelt elke boom in het bos voor een nieuw record een waarde voor Y (output). De uiteindelijke waarde kan worden berekend door het gemiddelde te nemen van alle waarden die door alle bomen in het bos zijn voorspeld. Of, in het geval van een classificatieprobleem, voorspelt elke boom in het woud de categorie waartoe het nieuwe record behoort. Tenslotte wordt het nieuwe record toegewezen aan de categorie die de meerderheid van de stemmen wint.

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 random forest voor classificatie en regressie.

1. Het random forest algoritme is niet bevooroordeeld, omdat er meerdere bomen zijn en elke boom wordt getraind op een subset van gegevens. In principe vertrouwt het random forest algoritme op de kracht van “de menigte”; daarom is de algemene bevooroordeeldheid van het algoritme verminderd.
2. Dit algoritme is zeer stabiel. Zelfs als er een nieuw gegevenspunt in de dataset wordt geïntroduceerd, wordt het algoritme niet veel beïnvloed, omdat nieuwe gegevens invloed kunnen hebben op één boom, maar het is heel 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 als gegevens ontbrekende waarden hebben of als ze niet goed geschaald zijn (hoewel we in dit artikel het schalen van kenmerken alleen voor demonstratiedoeleinden hebben uitgevoerd).

Voordelen van het gebruik van Random Forest

1. Een groot nadeel van random forests ligt in hun complexiteit. Ze vereisen veel meer rekenkracht, vanwege het grote aantal beslisbomen dat wordt samengevoegd.
2. Door hun complexiteit vereisen ze veel meer tijd om te trainen dan andere vergelijkbare algoritmen.

In de rest van dit artikel zullen we zien hoe Python’s Scikit-Learn bibliotheek kan worden gebruikt om het random forest algoritme te implementeren voor het oplossen van regressie-, maar ook classificatieproblemen.

Deel 1: Random Forest gebruiken voor regressie

In dit deel zullen we bestuderen hoe random forests kunnen worden gebruikt om regressieproblemen op te lossen met Scikit-Learn. In de volgende sectie zullen we classificatieproblemen oplossen via random forests.

Probleemstelling

Het probleem hier is het voorspellen van het benzineverbruik (in miljoenen gallons) in 48 van de Amerikaanse staten op basis van benzinebelasting (in centen), inkomen per hoofd van de bevolking (dollars), verharde snelwegen (in mijlen) en het deel van de bevolking met het rijbewijs.

Oplossing

Om dit regressieprobleem op te lossen zullen we gebruik maken van het random forest algoritme via de Scikit-Learn Python bibliotheek. We zullen de traditionele machine learning pijplijn volgen om dit probleem op te lossen. Volg deze stappen:

1. Bibliotheken importeren

Uitvoeren van de volgende code om de benodigde bibliotheken te importeren:

import pandas as pdimport numpy as np

2. Dataset importeren

De dataset voor dit probleem is beschikbaar op:

https://drive.google.com/file/d/1mVmGNx6cbfvRHC_DvF12ZL3wGLSHD9f_/view

In het kader van deze tutorial is de dataset gedownload naar de map “Datasets” van de “D”-schijf. U moet het bestandspad aanpassen aan uw eigen instellingen.

U voert het volgende commando uit om de dataset te importeren:

dataset = pd.read_csv('D:\Datasets\petrol_consumption.csv')

Om een overzicht te krijgen van hoe de dataset eruitziet, voert u het volgende commando uit:

dataset.head()

We kunnen zien dat de waarden in onze dataset niet erg goed geschaald zijn. We zullen ze verkleinen voordat we het algoritme gaan trainen.

3. Voorbereiden van data voor training

Twee taken worden in dit deel uitgevoerd. De eerste taak is het verdelen van de gegevens in ‘attributen’- en ‘label’-sets. De resulterende data wordt vervolgens verdeeld in training- en testsets.

Het volgende script verdeelt data in attributen en labels:

X = dataset.iloc.valuesy = dataset.iloc.values

Finishing, laten we de data verdelen in training- en testsets:

from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

4. Feature Scaling

We weten dat onze dataset nog geen geschaalde waarde heeft, bijvoorbeeld het veld Average_Income heeft waarden in het bereik van duizenden terwijl Petrol_tax waarden in het bereik van tientallen heeft. Daarom zou het nuttig zijn om onze gegevens te schalen (hoewel, zoals eerder vermeld, deze stap niet zo belangrijk is voor het random forests algoritme). Om dit te doen, zullen we gebruik maken van Scikit-Learn’s StandardScaler klasse. Voer daarvoor de volgende code uit:

# Feature Scalingfrom sklearn.preprocessing import StandardScalersc = StandardScaler()X_train = sc.fit_transform(X_train)X_test = sc.transform(X_test)

5. Het algoritme trainen

Nu we onze dataset hebben geschaald, is het tijd om ons random forest algoritme te trainen om dit regressieprobleem op te lossen. Voer de volgende code uit:

from sklearn.ensemble import RandomForestRegressorregressor = RandomForestRegressor(n_estimators=20, random_state=0)regressor.fit(X_train, y_train)y_pred = regressor.predict(X_test)

De RandomForestRegressor klasse van de sklearn.ensemble bibliotheek wordt gebruikt om regressieproblemen op te lossen via random forest. De belangrijkste parameter van de RandomForestRegressor klasse is de n_estimators parameter. Deze parameter bepaalt het aantal bomen in het random forest. We zullen beginnen met n_estimator=20 om te zien hoe ons algoritme presteert. Details over alle parameters van RandomForestRegressor vindt u hier.

6. Evalueren van het algoritme

De laatste en laatste stap van het oplossen van een machine learning probleem is het evalueren van de prestaties van het algoritme. Voor regressieproblemen zijn de metrieken die worden gebruikt om een algoritme te evalueren de gemiddelde absolute fout, de gemiddelde kwadraatfout en de wortelgemiddelde kwadraatfout. Voer de volgende code uit om deze waarden te vinden:

from sklearn import metricsprint('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred))print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))

De uitvoer zal er ongeveer zo uitzien:

Mean Absolute Error: 51.765Mean Squared Error: 4216.16675Root Mean Squared Error: 64.932016371

Met 20 bomen bedraagt de root mean squared error 64,93, wat meer is dan 10 procent van het gemiddelde benzineverbruik, nl. 576,77. Dit kan er onder meer op wijzen dat we te weinig schatters (bomen) hebben gebruikt.

Als het aantal schatters wordt veranderd in 200, zijn de resultaten als volgt:

Mean Absolute Error: 47.9825Mean Squared Error: 3469.7007375Root Mean Squared Error: 58.9041657058

De volgende grafiek toont de afname van de waarde van de root mean squared error (RMSE) met betrekking tot het aantal schatters. Hier bevat de X-as het aantal schatters en de Y-as de waarde van de RMS.

U kunt zien dat de foutwaarden afnemen met de toename van het aantal schatters. Na 200 neemt de foutafname af, dus daarom is 200 een goed getal voor n_estimators. U kunt spelen met het aantal bomen en andere parameters om te zien of u zelf betere resultaten kunt krijgen.

Deel 2: Random Forest gebruiken voor classificatie

Probleemdefinitie

De taak hier is te voorspellen of een bankbiljet authentiek is of niet, gebaseerd op vier attributen, nl.

Oplossing

Dit is een binair classificatieprobleem en we zullen een random forest classifier gebruiken om dit probleem op te lossen. De stappen die worden gevolgd om dit probleem op te lossen zijn vergelijkbaar met de stappen die worden uitgevoerd voor regressie.

1. Bibliotheken importeren

import pandas as pdimport numpy as np

2. Dataset importeren

De dataset kan worden gedownload van de volgende link:

https://drive.google.com/file/d/13nw-uRXPY8XIZQxKRNZ3yYlho-CYm_Qt/view

De gedetailleerde informatie over de gegevens is beschikbaar op de volgende link:

https://archive.ics.uci.edu/ml/datasets/banknote+authentication

De volgende code importeert de dataset:

dataset = pd.read_csv("D:/Datasets/bill_authentication.csv")

Om een high level view van de dataset te krijgen, voert u het volgende commando uit:

dataset.head()

Zoals bij de regressiedataset het geval was, zijn de waarden in deze dataset niet erg goed geschaald. De dataset wordt geschaald voordat het algoritme wordt getraind.

3. Gegevens voorbereiden voor training

De volgende code verdeelt de gegevens in attributen en labels:

X = dataset.iloc.valuesy = dataset.iloc.values

De volgende code verdeelt de gegevens in trainings- en testsets:

from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

4. Feature Scaling

Zoals eerder, werkt feature scaling op dezelfde manier:

# Feature Scalingfrom sklearn.preprocessing import StandardScalersc = StandardScaler()X_train = sc.fit_transform(X_train)X_test = sc.transform(X_test)

5. Het algoritme trainen

En nogmaals, nu we onze dataset hebben geschaald, kunnen we onze random forests trainen om dit classificatieprobleem op te lossen. Hiervoor voeren we de volgende code uit:

from sklearn.ensemble import RandomForestRegressorregressor = RandomForestRegressor(n_estimators=20, random_state=0)regressor.fit(X_train, y_train)y_pred = regressor.predict(X_test)

In het geval van regressie hebben we de RandomForestRegressor klasse van de sklearn.ensemble bibliotheek gebruikt. Voor classificatie gebruiken we RandomForestClassifier class van de sklearn.ensemble bibliotheek. RandomForestClassifier klasse neemt ook n_estimators als parameter. Zoals voorheen definieert deze parameter het aantal bomen in ons willekeurige bos. We beginnen weer met 20 bomen. Details over alle parameters van RandomForestClassifier vindt u hier.

6. Evaluatie van het algoritme

Voor classificatie problemen zijn de metrieken die gebruikt worden om een algoritme te evalueren: nauwkeurigheid, verwarring matrix, precisie recall, en F1 waarden. Voer het volgende script uit om deze waarden te vinden:

from sklearn.metrics import classification_report, confusion_matrix, accuracy_scoreprint(confusion_matrix(y_test,y_pred))print(classification_report(y_test,y_pred))print(accuracy_score(y_test, y_pred))

De output zal er ongeveer zo uitzien:

 1 117]] precision recall f1-score support 0 0.99 0.99 0.99 157 1 0.98 0.99 0.99 118 avg / total 0.99 0.99 0.99 2750.989090909091

De nauwkeurigheid van onze random forest classifier met 20 bomen is 98,90%. In tegenstelling tot voorheen heeft het veranderen van het aantal schatters voor dit probleem de resultaten niet significant verbeterd, zoals te zien is in de volgende grafiek. Hier bevat de X-as het aantal schatters en de Y-as de nauwkeurigheid.

98,90% is een vrij goede nauwkeurigheid, dus het heeft niet veel zin om ons aantal schatters toch te verhogen. We zien dat het verhogen van het aantal schatters de nauwkeurigheid niet verder heeft verbeterd.

Om de nauwkeurigheid te verbeteren, stel ik voor dat je wat speelt met andere parameters van de RandomForestClassifier klasse en kijkt of je onze resultaten kunt verbeteren.

Bronnen

Wil je meer leren over Scikit-Learn en andere nuttige machine learning algoritmen zoals random forests? U kunt enkele meer gedetailleerde bronnen bekijken, zoals een online cursus:

• Data Science in Python, Pandas, Scikit-learn, Numpy, Matplotlib
• Python for Data Science and Machine Learning Bootcamp
• Machine Learning A-Z: Hands-On Python & R In Data Science