Random Forest er en populær maskinlæringsalgoritme som tilhører veiledet læringsteknikk. Den kan brukes til både klassifikasjons- og regresjonsproblemer i ML. Det er basert på konseptet ensemble læring, som er en prosess av å kombinere flere klassifikatorer for å løse et komplekst problem og forbedre ytelsen til modellen.
Som navnet tilsier, 'Random Forest er en klassifiserer som inneholder et antall beslutningstrær på ulike delsett av det gitte datasettet og tar gjennomsnittet for å forbedre den prediktive nøyaktigheten til det datasettet.' I stedet for å stole på ett beslutningstre, tar den tilfeldige skogen spådommen fra hvert tre og basert på flertallet av spådommer, og den forutsier det endelige resultatet.
Det større antallet trær i skogen fører til høyere nøyaktighet og forhindrer problemet med overtilpasning.
forskjellen mellom firma og selskap
Diagrammet nedenfor forklarer hvordan Random Forest-algoritmen fungerer:
Merk: For bedre å forstå Random Forest Algorithm, bør du ha kunnskap om Decision Tree Algorithm.
Forutsetninger for Random Forest
Siden den tilfeldige skogen kombinerer flere trær for å forutsi klassen til datasettet, er det mulig at noen beslutningstrær kan forutsi riktig utgang, mens andre ikke. Men sammen spår alle trærne riktig utgang. Nedenfor er derfor to forutsetninger for en bedre tilfeldig skogklassifiserer:
- Det bør være noen faktiske verdier i funksjonsvariabelen til datasettet slik at klassifikatoren kan forutsi nøyaktige resultater i stedet for et gjettet resultat.
- Spådommene fra hvert tre må ha svært lave korrelasjoner.
Hvorfor bruke Random Forest?
Nedenfor er noen punkter som forklarer hvorfor vi bør bruke Random Forest-algoritmen:
- Det tar mindre treningstid sammenlignet med andre algoritmer.
- Den forutsier utdata med høy nøyaktighet, selv for det store datasettet den kjører effektivt.
- Det kan også opprettholde nøyaktigheten når en stor andel av data mangler.
Hvordan fungerer Random Forest-algoritmen?
Random Forest fungerer i to-fase, først er å skape den tilfeldige skogen ved å kombinere N beslutningstre, og for det andre er å lage spådommer for hvert tre opprettet i den første fasen.
Arbeidsprosessen kan forklares i trinnene og diagrammet nedenfor:
Trinn 1: Velg tilfeldige K-datapunkter fra treningssettet.
Steg 2: Bygg beslutningstrærene knyttet til de valgte datapunktene (delsett).
Trinn-3: Velg tallet N for beslutningstrær du vil bygge.
det vakreste smilet
Trinn-4: Gjenta trinn 1 og 2.
Trinn-5: For nye datapunkter, finn spådommene for hvert beslutningstre, og tilordne de nye datapunktene til kategorien som vinner flertallet av stemmene.
Virkemåten til algoritmen kan forstås bedre av eksemplet nedenfor:
Eksempel: Anta at det er et datasett som inneholder flere fruktbilder. Så dette datasettet er gitt til Random skogklassifisereren. Datasettet er delt inn i delsett og gitt til hvert beslutningstre. I løpet av treningsfasen produserer hvert beslutningstre et prediksjonsresultat, og når et nytt datapunkt oppstår, basert på flertallet av resultatene, forutsier Random Forest-klassifisereren den endelige avgjørelsen. Tenk på bildet nedenfor:
Anvendelser av Random Forest
Det er hovedsakelig fire sektorer der tilfeldig skog mest brukes:
les excel-fil i java
Fordeler med Random Forest
- Random Forest er i stand til å utføre både klassifiserings- og regresjonsoppgaver.
- Den er i stand til å håndtere store datasett med høy dimensjonalitet.
- Det forbedrer nøyaktigheten til modellen og forhindrer overmonteringsproblemet.
Ulemper med Random Forest
- Selv om tilfeldig skog kan brukes til både klassifisering og regresjonsoppgaver, er den ikke mer egnet for regresjonsoppgaver.
Python-implementering av Random Forest Algorithm
Nå skal vi implementere Random Forest Algorithm-treet ved å bruke Python. Til dette vil vi bruke samme datasett 'user_data.csv', som vi har brukt i tidligere klassifiseringsmodeller. Ved å bruke samme datasett kan vi sammenligne Random Forest-klassifikatoren med andre klassifikasjonsmodeller som f.eks Beslutningstre Klassifisering, KNN, SVM, Logistisk Regresjon, etc.
Implementeringstrinn er gitt nedenfor:
- Dataforbehandlingstrinn
- Tilpasse den tilfeldige skogalgoritmen til treningssettet
- Forutsi testresultatet
- Test nøyaktigheten av resultatet (oppretting av forvirringsmatrise)
- Visualisere testsettets resultat.
1. Dataforbehandlingstrinn:
Nedenfor er koden for forhåndsbehandlingstrinnet:
# 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 koden ovenfor har vi forhåndsbehandlet dataene. Hvor vi har lastet inn datasettet, som er gitt som:
2. Tilpasse Random Forest-algoritmen til treningssettet:
Nå skal vi tilpasse Random forest-algoritmen til treningssettet. For å passe den, vil vi importere RandomForestClassifier klasse fra sklearn.ensemble bibliotek. Koden er gitt 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 koden ovenfor tar klassifiseringsobjektet følgende parametere:
Produksjon:
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. Forutsi resultatet av testsettet
Siden vår modell er tilpasset treningssettet, så nå kan vi forutsi testresultatet. For prediksjon vil vi lage en ny prediksjonsvektor y_pred. Nedenfor er koden for det:
#Predicting the test set result y_pred= classifier.predict(x_test)
Produksjon:
Prediksjonsvektoren er gitt som:
fang og prøv java
Ved å sjekke prediksjonsvektoren ovenfor og testsettets reelle vektor, kan vi bestemme de ukorrekte prediksjonene gjort av klassifikatoren.
4. Opprette forvirringsmatrisen
Nå skal vi lage forvirringsmatrisen for å bestemme de riktige og ukorrekte spådommene. Nedenfor er koden for det:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Produksjon:
Som vi kan se i matrisen ovenfor, er det 4+4= 8 feil spådommer og 64+28= 92 riktige spådommer.
5. Visualisere treningen Sett resultat
Her skal vi visualisere treningssettets resultat. For å visualisere resultatet av treningssettet vil vi plotte en graf for tilfeldig skogklassifikatoren. Klassifisereren vil forutsi ja eller nei for brukerne som enten har kjøpt eller ikke kjøpt SUV-bilen slik vi gjorde i Logistic Regression. Nedenfor er koden for det:
ulv eller rev
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()
Produksjon:
Bildet ovenfor er visualiseringsresultatet for Random Forest-klassifiseringen som arbeider med treningssettets resultat. Det ligner veldig mye på Decision-treeklassifikatoren. Hvert datapunkt tilsvarer hver bruker av user_data, og de lilla og grønne områdene er prediksjonsområdene. Den lilla regionen er klassifisert for brukerne som ikke kjøpte SUV-bilen, og den grønne regionen er for brukerne som kjøpte SUV-en.
Så, i Random Forest-klassifikatoren, har vi tatt 10 trær som har forutsagt Ja eller NEI for den kjøpte variabelen. Klassifisereren tok flertallet av spådommene og ga resultatet.
6. Visualisere testsettets resultat
Nå skal vi visualisere testsettets resultat. Nedenfor er koden for 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()
Produksjon:
Bildet ovenfor er visualiseringsresultatet for testsettet. Vi kan sjekke at det er et minimum antall ukorrekte spådommer (8) uten Overfitting-problemet. Vi vil få forskjellige resultater ved å endre antall trær i klassifikatoren.