Random Forest är en populär maskininlärningsalgoritm som tillhör den övervakade inlärningstekniken. Den kan användas för både klassificerings- och regressionsproblem i ML. Det bygger på konceptet ensemble lärande, som är en process av att kombinera flera klassificerare för att lösa ett komplext problem och för att förbättra modellens prestanda.
Som namnet antyder, 'Random Forest är en klassificerare som innehåller ett antal beslutsträd på olika delmängder av den givna datamängden och tar genomsnittet för att förbättra den prediktiva noggrannheten för den datamängden.' Istället för att förlita sig på ett beslutsträd, tar den slumpmässiga skogen förutsägelsen från varje träd och baseras på majoritetens röster av förutsägelser, och den förutsäger den slutliga produktionen.
Det större antalet träd i skogen leder till högre noggrannhet och förhindrar problemet med övermontering.
konvertera sträng till json java
Diagrammet nedan förklarar hur Random Forest-algoritmen fungerar:
Obs: För att bättre förstå Random Forest Algorithm bör du ha kunskap om Decision Tree Algorithm.
Antaganden för Random Forest
Eftersom den slumpmässiga skogen kombinerar flera träd för att förutsäga klassen för datamängden, är det möjligt att vissa beslutsträd kan förutsäga rätt utdata, medan andra kanske inte. Men tillsammans förutsäger alla träd den korrekta produktionen. Nedan följer därför två antaganden för en bättre slumpmässig skogklassificerare:
- Det bör finnas några faktiska värden i funktionsvariabeln för datamängden så att klassificeraren kan förutsäga korrekta resultat snarare än ett gissat resultat.
- Förutsägelserna från varje träd måste ha mycket låga korrelationer.
Varför använda Random Forest?
Nedan följer några punkter som förklarar varför vi bör använda Random Forest-algoritmen:
- Det tar mindre träningstid jämfört med andra algoritmer.
- Den förutsäger utdata med hög noggrannhet, även för den stora datamängden den körs effektivt.
- Det kan också bibehålla noggrannheten när en stor del av data saknas.
Hur fungerar Random Forest-algoritmen?
Random Forest fungerar i två faser första är att skapa den slumpmässiga skogen genom att kombinera N beslutsträd, och andra är att göra förutsägelser för varje träd som skapas i den första fasen.
Arbetsprocessen kan förklaras i nedanstående steg och diagram:
Steg 1: Välj slumpmässiga K datapunkter från träningsuppsättningen.
om annars loop i java
Steg 2: Bygg beslutsträden som är associerade med de valda datapunkterna (delmängder).
Steg 3: Välj siffran N för beslutsträd som du vill bygga.
Steg-4: Upprepa steg 1 och 2.
Steg-5: För nya datapunkter, hitta prognoserna för varje beslutsträd och tilldela de nya datapunkterna till den kategori som vinner majoritetens röster.
Algoritmens funktion kan bättre förstås av exemplet nedan:
Exempel: Anta att det finns en datauppsättning som innehåller flera fruktbilder. Så denna datauppsättning ges till slumpmässig skogsklassificerare. Datauppsättningen är uppdelad i delmängder och ges till varje beslutsträd. Under träningsfasen producerar varje beslutsträd ett prediktionsresultat, och när en ny datapunkt inträffar, baserat på majoriteten av resultaten, förutsäger Random Forest-klassificeraren det slutliga beslutet. Tänk på bilden nedan:
Tillämpningar av Random Forest
Det finns huvudsakligen fyra sektorer där Random skog mest används:
Fördelar med Random Forest
- Random Forest kan utföra både klassificerings- och regressionsuppgifter.
- Den kan hantera stora datamängder med hög dimensionalitet.
- Det förbättrar modellens noggrannhet och förhindrar övermonteringsproblemet.
Nackdelar med Random Forest
- Även om slumpmässig skog kan användas för både klassificerings- och regressionsuppgifter, är den inte mer lämpad för regressionsuppgifter.
Python-implementering av Random Forest Algorithm
Nu kommer vi att implementera Random Forest Algorithm-trädet med Python. För detta kommer vi att använda samma dataset 'user_data.csv', som vi har använt i tidigare klassificeringsmodeller. Genom att använda samma datauppsättning kan vi jämföra Random Forest-klassificeraren med andra klassificeringsmodeller som t.ex Beslutsträd Klassificerare, KNN, SVM, Logistic Regression, etc.
Implementeringssteg ges nedan:
- Steg för förbehandling av data
- Anpassa Random forest-algoritmen till träningssetet
- Förutsäga testresultatet
- Testa resultatets noggrannhet (Skapa förvirringsmatris)
- Visualisera testsetresultatet.
1. Steg för dataförbehandling:
Nedan är koden för förbehandlingssteget:
# 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)
I ovanstående kod har vi förbehandlat datan. Där vi har laddat datamängden, som ges som:
2. Anpassa Random Forest-algoritmen till träningsuppsättningen:
Nu kommer vi att anpassa Random forest-algoritmen till träningsuppsättningen. För att passa den kommer vi att importera RandomForestClassifier klass från sklearn.ensemble bibliotek. Koden ges nedan:
js set
#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)
I koden ovan tar klassificeringsobjektet följande parametrar:
Produktion:
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. Förutsäga testsetresultatet
Eftersom vår modell är anpassad till träningssetet, så nu kan vi förutsäga testresultatet. För förutsägelse kommer vi att skapa en ny förutsägelsevektor y_pred. Nedan är koden för det:
statisk i c
#Predicting the test set result y_pred= classifier.predict(x_test)
Produktion:
Prediktionsvektorn ges som:
Genom att kontrollera ovanstående prediktionsvektor och testset real vektor, kan vi fastställa de felaktiga förutsägelser som görs av klassificeraren.
4. Skapa förvirringsmatrisen
Nu kommer vi att skapa förvirringsmatrisen för att bestämma de korrekta och felaktiga förutsägelserna. Nedan är koden för det:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Produktion:
Som vi kan se i matrisen ovan finns det 4+4= 8 felaktiga förutsägelser och 64+28= 92 korrekta förutsägelser.
5. Visualisera träningen Ställ in resultat
Här kommer vi att visualisera träningsuppsättningens resultat. För att visualisera träningsuppsättningens resultat kommer vi att rita en graf för Random forest classifier. Klassificeraren kommer att förutsäga ja eller nej för de användare som antingen har köpt eller inte köpt SUV-bilen som vi gjorde i Logistic Regression. Nedan är koden för det:
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()
Produktion:
Bilden ovan är visualiseringsresultatet för Random Forest-klassificeraren som arbetar med träningsuppsättningens resultat. Det är mycket likt Beslutsträdsklassificeraren. Varje datapunkt motsvarar varje användare av user_data, och de lila och gröna regionerna är prediktionsregionerna. Den lila regionen klassificeras för de användare som inte köpte SUV-bilen, och den gröna regionen är för de användare som köpte SUV:en.
Så i Random Forest-klassificeraren har vi tagit 10 träd som har förutspått Ja eller NEJ för variabeln Köpt. Klassificeraren tog majoriteten av förutsägelserna och gav resultatet.
ipconfig för ubuntu
6. Visualisera testsetresultatet
Nu ska vi visualisera testsetresultatet. Nedan är koden för det:
#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()
Produktion:
Bilden ovan är visualiseringsresultatet för testsetet. Vi kan kontrollera att det finns ett minsta antal felaktiga förutsägelser (8) utan problemet med Overfitting. Vi kommer att få olika resultat genom att ändra antalet träd i klassificeraren.