Random Forest és un popular algorisme d'aprenentatge automàtic que pertany a la tècnica d'aprenentatge supervisat. Es pot utilitzar tant per a problemes de classificació com de regressió en ML. Es basa en el concepte de aprenentatge conjunt, que és un procés de combinant múltiples classificadors per resoldre un problema complex i millorar el rendiment del model.
Com el seu nom indica, 'Random Forest és un classificador que conté una sèrie d'arbres de decisió en diversos subconjunts del conjunt de dades donat i pren la mitjana per millorar la precisió predictiva d'aquest conjunt de dades'. En lloc de confiar en un arbre de decisió, el bosc aleatori pren la predicció de cada arbre i es basa en els vots majoritaris de les prediccions, i prediu la sortida final.
El major nombre d'arbres al bosc condueix a una major precisió i evita el problema del sobreajustament.
vba
El diagrama següent explica el funcionament de l'algorisme Random Forest:
Nota: per entendre millor l'algoritme del bosc aleatori, hauríeu de conèixer l'algoritme de l'arbre de decisions.
Supòsits per a Random Forest
Com que el bosc aleatori combina diversos arbres per predir la classe del conjunt de dades, és possible que alguns arbres de decisió puguin predir la sortida correcta, mentre que altres no. Però junts, tots els arbres prediuen la sortida correcta. Per tant, a continuació hi ha dos supòsits per a un millor classificador de boscos aleatoris:
- Hi hauria d'haver alguns valors reals a la variable característica del conjunt de dades perquè el classificador pugui predir resultats precisos en lloc d'un resultat endevinat.
- Les prediccions de cada arbre han de tenir correlacions molt baixes.
Per què utilitzar Random Forest?
A continuació es mostren alguns punts que expliquen per què hauríem d'utilitzar l'algorisme Random Forest:
- Es necessita menys temps d'entrenament en comparació amb altres algorismes.
- Preveu la sortida amb gran precisió, fins i tot per al gran conjunt de dades que s'executa de manera eficient.
- També pot mantenir la precisió quan falten una gran proporció de dades.
Com funciona l'algoritme Random Forest?
Random Forest treballa en dues fases, primer és crear el bosc aleatori combinant N arbre de decisió i, segon, fer prediccions per a cada arbre creat en la primera fase.
El procés de treball es pot explicar en els passos i el diagrama següents:
Pas 1: Seleccioneu K punts de dades aleatoris del conjunt d'entrenament.
Pas-2: Construeix els arbres de decisió associats als punts de dades seleccionats (subconjunts).
Pas-3: Trieu el número N per als arbres de decisió que voleu construir.
Pas-4: Repetiu els passos 1 i 2.
afegint a la matriu java
Pas-5: Per als punts de dades nous, cerqueu les prediccions de cada arbre de decisió i assigneu els punts de dades nous a la categoria que obtingui la majoria de vots.
El funcionament de l'algorisme es pot entendre millor amb l'exemple següent:
Exemple: Suposem que hi ha un conjunt de dades que conté diverses imatges de fruites. Per tant, aquest conjunt de dades es dóna al classificador de boscos aleatoris. El conjunt de dades es divideix en subconjunts i es dóna a cada arbre de decisió. Durant la fase d'entrenament, cada arbre de decisió produeix un resultat de predicció i, quan es produeix un nou punt de dades, basant-se en la majoria dels resultats, el classificador Random Forest prediu la decisió final. Considereu la imatge següent:
Aplicacions de Random Forest
Hi ha principalment quatre sectors on el bosc aleatori s'utilitza principalment:
Avantatges de Random Forest
- Random Forest és capaç de realitzar tasques de classificació i regressió.
- És capaç de gestionar grans conjunts de dades amb una gran dimensionalitat.
- Millora la precisió del model i evita el problema d'ajustament excessiu.
Desavantatges de Random Forest
- Tot i que el bosc aleatori es pot utilitzar tant per a tasques de classificació com de regressió, no és més adequat per a tasques de regressió.
Implementació de Python de l'algoritme forestal aleatori
Ara implementarem l'arbre Random Forest Algorithm mitjançant Python. Per a això, utilitzarem el mateix conjunt de dades 'user_data.csv', que hem utilitzat en models de classificació anteriors. Utilitzant el mateix conjunt de dades, podem comparar el classificador Random Forest amb altres models de classificació com ara Classificador d'arbre de decisió, KNN, SVM, regressió logística, etc.
llista de dards
Els passos d'implementació es detallen a continuació:
- Pas de preprocessament de dades
- Ajustar l'algoritme de bosc aleatori al conjunt d'entrenament
- Predicció del resultat de la prova
- Prova de precisió del resultat (Matriu de creació de confusió)
- Visualització del resultat del conjunt de proves.
1. Pas de preprocessament de dades:
A continuació es mostra el codi per al pas de preprocessament:
# 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)
En el codi anterior, hem preprocessat les dades. On hem carregat el conjunt de dades, que es dóna com:
2. Ajustar l'algorisme Random Forest al conjunt d'entrenament:
Ara ajustarem l'algorisme del bosc aleatori al conjunt d'entrenament. Per adaptar-lo, importarem el RandomForestClassifier classe de la sklearn.ensemble biblioteca. El codi es mostra a continuació:
#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)
Al codi anterior, l'objecte classificador pren els paràmetres següents:
Sortida:
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. Predicció del resultat del conjunt de proves
Com que el nostre model s'adapta al conjunt d'entrenament, ara podem predir el resultat de la prova. Per a la predicció, crearem un nou vector de predicció y_pred. A continuació es mostra el codi per a això:
#Predicting the test set result y_pred= classifier.predict(x_test)
Sortida:
El vector de predicció es dóna com:
Comprovant el vector de predicció anterior i el vector real del conjunt de proves, podem determinar les prediccions incorrectes fetes pel classificador.
canviar el nom del directori de Linux
4. Creació de la matriu de confusió
Ara crearem la matriu de confusió per determinar les prediccions correctes i incorrectes. A continuació es mostra el codi per a això:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Sortida:
Com podem veure a la matriu anterior, n'hi ha 4+4= 8 prediccions incorrectes i 64+28= 92 prediccions correctes.
5. Visualització del resultat del conjunt d'entrenament
Aquí visualitzarem el resultat del conjunt d'entrenament. Per visualitzar el resultat del conjunt d'entrenament dibuixarem un gràfic per al classificador de boscos aleatoris. El classificador predirà sí o no per als usuaris que hagin comprat o no el cotxe SUV com vam fer a la regressió logística. A continuació es mostra el codi per a això:
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()
Sortida:
La imatge de dalt és el resultat de la visualització del classificador Random Forest que treballa amb el resultat del conjunt d'entrenament. És molt semblant al classificador de l'arbre de decisions. Cada punt de dades correspon a cada usuari de user_data, i les regions morades i verdes són les regions de predicció. La regió porpra es classifica per als usuaris que no van comprar el cotxe SUV, i la regió verda és per als usuaris que van comprar el SUV.
forma completa ide
Així doncs, al classificador Random Forest, hem pres 10 arbres que han predit Sí o NO per a la variable Comprada. El classificador va agafar la majoria de les prediccions i va proporcionar el resultat.
6. Visualització del resultat del conjunt de proves
Ara visualitzarem el resultat del conjunt de la prova. A continuació es mostra el codi per a això:
#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()
Sortida:
La imatge de dalt és el resultat de la visualització del conjunt de proves. Podem comprovar que hi ha un nombre mínim de prediccions incorrectes (8) sense el problema Overfitting. Obtindrem resultats diferents canviant el nombre d'arbres del classificador.