Random Forest is een populair machine learning-algoritme dat behoort tot de begeleide leertechniek. Het kan worden gebruikt voor zowel classificatie- als regressieproblemen in ML. Het is gebaseerd op het concept van ensembleleren, dat is een proces van het combineren van meerdere classificatoren om een complex probleem op te lossen en de prestaties van het model te verbeteren.
Zoals de naam al doet vermoeden, 'Random Forest is een classifier die een aantal beslissingsbomen bevat over verschillende subsets van de gegeven dataset en het gemiddelde neemt om de voorspellende nauwkeurigheid van die dataset te verbeteren.' In plaats van te vertrouwen op één beslissingsboom, neemt het willekeurige bos de voorspelling van elke boom en baseert het zich op de meerderheid van de stemmen van de voorspellingen, en voorspelt het de uiteindelijke uitkomst.
Het grotere aantal bomen in het bos leidt tot een grotere nauwkeurigheid en voorkomt het probleem van overfitting.
faculteit in Java
In het onderstaande diagram wordt de werking van het Random Forest-algoritme uitgelegd:
Opmerking: Om het Random Forest-algoritme beter te begrijpen, moet u kennis hebben van het beslissingsboomalgoritme.
Aannames voor willekeurig bos
Omdat het willekeurige forest meerdere bomen combineert om de klasse van de dataset te voorspellen, is het mogelijk dat sommige beslissingsbomen de juiste uitvoer voorspellen, terwijl andere dat niet doen. Maar samen voorspellen alle bomen de juiste output. Daarom staan hieronder twee aannames voor een betere willekeurige bosclassificatie:
- Er moeten enkele werkelijke waarden in de kenmerkvariabele van de gegevensset voorkomen, zodat de classificator nauwkeurige resultaten kan voorspellen in plaats van een geraden resultaat.
- De voorspellingen van elke boom moeten zeer lage correlaties hebben.
Waarom Random Forest gebruiken?
Hieronder staan enkele punten die verklaren waarom we het Random Forest-algoritme moeten gebruiken:
- Het kost minder trainingstijd in vergelijking met andere algoritmen.
- Het voorspelt de output met hoge nauwkeurigheid, zelfs voor de grote dataset die het efficiënt uitvoert.
- Het kan ook de nauwkeurigheid behouden wanneer een groot deel van de gegevens ontbreekt.
Hoe werkt het Random Forest-algoritme?
Random Forest werkt in twee fasen. Ten eerste wordt er een willekeurig bos gecreëerd door N beslissingsbomen te combineren, en ten tweede worden er voorspellingen gedaan voor elke boom die in de eerste fase wordt gemaakt.
Het werkproces kan worden uitgelegd in de onderstaande stappen en diagram:
Stap 1: Selecteer willekeurige K-gegevenspunten uit de trainingsset.
Stap 2: Bouw de beslissingsbomen die zijn gekoppeld aan de geselecteerde gegevenspunten (subsets).
computer uitgevonden welk jaar
Stap 3: Kies het getal N voor de beslissingsbomen die u wilt bouwen.
Stap 4: Herhaal stap 1 en 2.
Stap 5: Zoek voor nieuwe datapunten de voorspellingen van elke beslissingsboom en wijs de nieuwe datapunten toe aan de categorie die de meerderheidsstemmen wint.
De werking van het algoritme kan beter worden begrepen aan de hand van het onderstaande voorbeeld:
Voorbeeld: Stel dat er een dataset is die meerdere fruitafbeeldingen bevat. Deze gegevensset wordt dus doorgegeven aan de willekeurige bosclassificator. De dataset wordt opgedeeld in subsets en aan elke beslisboom gegeven. Tijdens de trainingsfase produceert elke beslissingsboom een voorspellingsresultaat, en wanneer er een nieuw datapunt optreedt, voorspelt de Random Forest-classificator op basis van de meerderheid van de resultaten de uiteindelijke beslissing. Beschouw de onderstaande afbeelding:
zweven naar touw
Toepassingen van Random Forest
Er zijn hoofdzakelijk vier sectoren waar Random Forest het meest wordt gebruikt:
Voordelen van Random Forest
- Random Forest kan zowel classificatie- als regressietaken uitvoeren.
- Het is in staat grote datasets met een hoge dimensionaliteit te verwerken.
- Het verbetert de nauwkeurigheid van het model en voorkomt het probleem van overfitting.
Nadelen van willekeurig bos
- Hoewel een willekeurig forest kan worden gebruikt voor zowel classificatie- als regressietaken, is het niet geschikter voor regressietaken.
Python-implementatie van willekeurig bosalgoritme
Nu zullen we de Random Forest Algorithm-boom implementeren met behulp van Python. Hiervoor gebruiken we dezelfde dataset 'user_data.csv', die we in eerdere classificatiemodellen hebben gebruikt. Door dezelfde dataset te gebruiken, kunnen we de Random Forest-classificator vergelijken met andere classificatiemodellen zoals Beslissingsboom Classificator, KNN, SVM, logistieke regressie, enz.
Implementatiestappen worden hieronder gegeven:
- Gegevensvoorverwerkingsstap
- Het willekeurige forest-algoritme aanpassen aan de trainingsset
- Het voorspellen van het testresultaat
- Testnauwkeurigheid van het resultaat (Creation of Confusion-matrix)
- Het visualiseren van het resultaat van de testset.
1. Gegevensvoorverwerkingsstap:
Hieronder vindt u de code voor de voorverwerkingsstap:
# importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
In de bovenstaande code hebben we de gegevens voorbewerkt. Waar we de dataset hebben geladen, die wordt gegeven als:
2. Het Random Forest-algoritme aanpassen aan de trainingsset:
Nu passen we het Random Forest-algoritme aan de trainingsset aan. Om het te passen, zullen we de RandomForestClassifier klasse uit de sklearn.ensemble bibliotheek. De code staat hieronder:
#Fitting Decision Tree classifier to the training set from sklearn.ensemble import RandomForestClassifier classifier= RandomForestClassifier(n_estimators= 10, criterion='entropy') classifier.fit(x_train, y_train)
In de bovenstaande code heeft het classificatieobject de onderstaande parameters:
Uitgang:
RandomForestClassifier(bootstrap=True, class_weight=None, criterion='entropy', max_depth=None, max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=None, oob_score=False, random_state=None, verbose=0, warm_start=False)
3. Het voorspellen van het resultaat van de testset
Omdat ons model is aangepast aan de trainingsset, kunnen we nu het testresultaat voorspellen. Voor voorspellingen zullen we een nieuwe voorspellingsvector y_pred maken. Hieronder staat de code ervoor:
#Predicting the test set result y_pred= classifier.predict(x_test)
Uitgang:
alisa velenonok
De voorspellingsvector wordt gegeven als:
Door de bovenstaande voorspellingsvector en de echte vector van de testset te controleren, kunnen we de onjuiste voorspellingen van de classificator bepalen.
4. Het creëren van de verwarringsmatrix
Nu gaan we de verwarringsmatrix maken om de juiste en onjuiste voorspellingen te bepalen. Hieronder staat de code ervoor:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Uitgang:
data structuur
Zoals we in de bovenstaande matrix kunnen zien, is dat zo 4+4= 8 onjuiste voorspellingen En 64+28= 92 correcte voorspellingen.
5. Visualiseren van het resultaat van de trainingsset
Hier visualiseren we het resultaat van de trainingsset. Om het resultaat van de trainingsset te visualiseren, zullen we een grafiek uitzetten voor de Random Forest-classificator. De classificator voorspelt ja of nee voor de gebruikers die de SUV-auto wel of niet hebben gekocht, zoals we deden in Logistieke Regressie. Hieronder staat de code ervoor:
from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Uitgang:
De bovenstaande afbeelding is het visualisatieresultaat voor de Random Forest-classificator die werkt met het resultaat van de trainingsset. Het lijkt sterk op de classificatie van de beslissingsboom. Elk gegevenspunt komt overeen met elke gebruiker van de gebruikersgegevens, en de paarse en groene gebieden zijn de voorspellingsgebieden. De paarse regio is geclassificeerd voor de gebruikers die de SUV-auto niet hebben gekocht, en de groene regio is voor de gebruikers die de SUV hebben gekocht.
Dus in de Random Forest-classificator hebben we 10 bomen genomen die Ja of NEE hebben voorspeld voor de Aangeschafte variabele. De classificator nam het merendeel van de voorspellingen en leverde het resultaat.
6. Visualiseren van het resultaat van de testset
Nu gaan we het resultaat van de testset visualiseren. Hieronder staat de code ervoor:
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Uitgang:
De bovenstaande afbeelding is het visualisatieresultaat voor de testset. We kunnen controleren of er een minimum aantal onjuiste voorspellingen is (8) zonder dat er sprake is van overfitting. We krijgen verschillende resultaten door het aantal bomen in de classificator te veranderen.