Random Forest er en populær maskinlæringsalgoritme, der hører til den overvågede læringsteknik. Det kan bruges til både klassifikations- og regressionsproblemer i ML. Det er baseret på begrebet ensemble læring, som er en proces af at kombinere flere klassifikatorer for at løse et komplekst problem og forbedre modellens ydeevne.
Som navnet antyder, 'Random Forest er en klassifikator, der indeholder et antal beslutningstræer på forskellige delmængder af det givne datasæt og tager gennemsnittet for at forbedre den forudsigelige nøjagtighed af dette datasæt.' I stedet for at stole på ét beslutningstræ, tager den tilfældige skov forudsigelsen fra hvert træ og er baseret på flertalsafstemninger af forudsigelser, og den forudsiger det endelige output.
Det større antal træer i skoven fører til højere nøjagtighed og forhindrer problemet med overfitting.
java dato til streng
Nedenstående diagram forklarer, hvordan Random Forest-algoritmen fungerer:
Bemærk: For bedre at forstå Random Forest Algorithm bør du have kendskab til Decision Tree Algorithm.
Forudsætninger for Random Forest
Da den tilfældige skov kombinerer flere træer for at forudsige datasættets klasse, er det muligt, at nogle beslutningstræer kan forudsige det korrekte output, mens andre måske ikke. Men tilsammen forudsiger alle træerne det korrekte output. Nedenfor er derfor to antagelser for en bedre tilfældig skovklassifikator:
- Der bør være nogle faktiske værdier i datasættets funktionsvariabel, så klassifikatoren kan forudsige nøjagtige resultater i stedet for et gættet resultat.
- Forudsigelserne fra hvert træ skal have meget lave korrelationer.
Hvorfor bruge Random Forest?
Nedenfor er nogle punkter, der forklarer, hvorfor vi bør bruge Random Forest-algoritmen:
- Det tager mindre træningstid sammenlignet med andre algoritmer.
- Den forudsiger output med høj nøjagtighed, selv for det store datasæt, den kører effektivt.
- Det kan også opretholde nøjagtigheden, når en stor del af data mangler.
Hvordan fungerer Random Forest-algoritmen?
Random Forest fungerer i to-fase, først er at skabe den tilfældige skov ved at kombinere N beslutningstræ, og for det andet er at lave forudsigelser for hvert træ, der er skabt i den første fase.
Arbejdsprocessen kan forklares i nedenstående trin og diagram:
Trin 1: Vælg tilfældige K datapunkter fra træningssættet.
Trin-2: Byg de beslutningstræer, der er knyttet til de valgte datapunkter (undersæt).
Trin-3: Vælg tallet N for beslutningstræer, som du vil bygge.
mylivecricket ind
Trin-4: Gentag trin 1 og 2.
Trin-5: For nye datapunkter skal du finde forudsigelserne for hvert beslutningstræ og tildele de nye datapunkter til den kategori, der vinder flertalsafstemningerne.
Algoritmens virkemåde kan bedre forstås af nedenstående eksempel:
Eksempel: Antag, at der er et datasæt, der indeholder flere frugtbilleder. Så dette datasæt er givet til den tilfældige skovklassifikator. Datasættet er opdelt i delmængder og givet til hvert beslutningstræ. Under træningsfasen producerer hvert beslutningstræ et forudsigelsesresultat, og når et nyt datapunkt opstår, forudsiger Random Forest-klassifikatoren den endelige beslutning baseret på størstedelen af resultaterne. Overvej billedet nedenfor:
Anvendelser af Random Forest
Der er hovedsageligt fire sektorer, hvor tilfældig skov mest anvendes:
konvertering af int til dobbelt java
Fordele ved Random Forest
- Random Forest er i stand til at udføre både klassifikations- og regressionsopgaver.
- Den er i stand til at håndtere store datasæt med høj dimensionalitet.
- Det forbedrer modellens nøjagtighed og forhindrer overmonteringsproblemet.
Ulemper ved Random Forest
- Selvom tilfældig skov kan bruges til både klassifikations- og regressionsopgaver, er den ikke mere velegnet til regressionsopgaver.
Python Implementering af Random Forest Algorithm
Nu vil vi implementere Random Forest Algorithm-træet ved hjælp af Python. Til dette vil vi bruge det samme datasæt 'user_data.csv', som vi har brugt i tidligere klassifikationsmodeller. Ved at bruge samme datasæt kan vi sammenligne Random Forest-klassifikatoren med andre klassifikationsmodeller som f.eks Beslutningstræ Klassificering, KNN, SVM, Logistisk Regression mv.
Implementeringstrin er angivet nedenfor:
- Dataforbehandlingstrin
- Tilpasning af Random forest-algoritmen til træningssættet
- Forudsigelse af testresultatet
- Test nøjagtigheden af resultatet (oprettelse af forvirringsmatrix)
- Visualisering af testsætresultatet.
1. Dataforbehandlingstrin:
Nedenfor er koden til forbehandlingstrinnet:
# 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 ovenstående kode har vi forbehandlet dataene. Hvor vi har indlæst datasættet, som er givet som:
2. Tilpasning af Random Forest-algoritmen til træningssættet:
Nu vil vi tilpasse Random forest-algoritmen til træningssættet. For at passe det importerer vi RandomForestClassifier klasse fra sklearn.ensemble bibliotek. Koden er angivet nedenfor:
#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 ovenstående kode tager klassificeringsobjektet nedenstående parametre:
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. Forudsigelse af testsætresultatet
Da vores model er tilpasset træningssættet, så nu kan vi forudsige testresultatet. Til forudsigelse vil vi oprette en ny forudsigelsesvektor y_pred. Nedenfor er koden til det:
#Predicting the test set result y_pred= classifier.predict(x_test)
Produktion:
Forudsigelsesvektoren er givet som:
strengformater
Ved at kontrollere ovenstående forudsigelsesvektor og testsættets reelle vektor kan vi bestemme de forkerte forudsigelser udført af klassifikatoren.
4. Oprettelse af forvirringsmatricen
Nu vil vi oprette forvirringsmatricen for at bestemme de korrekte og forkerte forudsigelser. Nedenfor er koden til det:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Produktion:
Som vi kan se i ovenstående matrix, er der 4+4= 8 forkerte forudsigelser og 64+28= 92 rigtige forudsigelser.
5. Visualisering af træningen Sæt resultat
Her vil vi visualisere træningssættets resultat. For at visualisere træningssættets resultat vil vi plotte en graf for Tilfældig skovklassifikatoren. Klassificeringen vil forudsige ja eller nej for de brugere, der enten har købt eller ikke købt SUV-bilen, som vi gjorde i Logistic Regression. Nedenfor er koden til det:
ulv eller ræv
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:
Ovenstående billede er visualiseringsresultatet for Random Forest-klassifikatoren, der arbejder med træningssættets resultat. Det minder meget om Decision Tree-klassifikatoren. Hvert datapunkt svarer til hver bruger af user_data, og de lilla og grønne områder er forudsigelsesregionerne. Den lilla region er klassificeret for de brugere, der ikke har købt SUV-bilen, og den grønne region er for de brugere, der har købt SUV'en.
Så i Random Forest-klassifikatoren har vi taget 10 træer, der har forudsagt Ja eller NEJ for den købte variabel. Klassificereren tog størstedelen af forudsigelserne og leverede resultatet.
6. Visualisering af testsætresultatet
Nu vil vi visualisere testsættets resultat. Nedenfor er koden til 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:
Ovenstående billede er visualiseringsresultatet for testsættet. Vi kan kontrollere, at der er et minimum antal ukorrekte forudsigelser (8) uden Overfitting-problemet. Vi vil få forskellige resultater ved at ændre antallet af træer i klassificeringen.