Random Forest este un algoritm popular de învățare automată care aparține tehnicii de învățare supravegheată. Poate fi folosit atât pentru probleme de clasificare, cât și pentru probleme de regresie în ML. Se bazează pe conceptul de învăţare în ansamblu, care este un proces de combinarea mai multor clasificatori pentru a rezolva o problemă complexă și pentru a îmbunătăți performanța modelului.
Așa cum sugerează și numele, „Random Forest este un clasificator care conține un număr de arbori de decizie pe diferite subseturi ale setului de date dat și ia media pentru a îmbunătăți acuratețea predictivă a acelui set de date”. În loc să se bazeze pe un singur arbore de decizie, pădurea aleatorie preia predicția din fiecare copac și se bazează pe voturile majorității de predicții și prezice rezultatul final.
Numărul mai mare de copaci din pădure duce la o precizie mai mare și previne problema supraadaptării.
np.unic
Diagrama de mai jos explică funcționarea algoritmului Random Forest:
Notă: Pentru a înțelege mai bine algoritmul forestier aleatoriu, ar trebui să cunoașteți algoritmul arborelui decizional.
Ipoteze pentru Random Forest
Deoarece pădurea aleatoare combină mai mulți arbori pentru a prezice clasa setului de date, este posibil ca unii arbori de decizie să prezică rezultatul corect, în timp ce alții să nu prezinte. Dar împreună, toți copacii prezic rezultatul corect. Prin urmare, mai jos sunt două ipoteze pentru un clasificator de pădure aleatoriu mai bun:
- Ar trebui să existe niște valori reale în variabila caracteristică a setului de date, astfel încât clasificatorul să poată prezice rezultate precise, mai degrabă decât un rezultat ghicit.
- Predicțiile din fiecare arbore trebuie să aibă corelații foarte scăzute.
De ce să folosiți Random Forest?
Mai jos sunt câteva puncte care explică de ce ar trebui să folosim algoritmul Random Forest:
- Este nevoie de mai puțin timp de antrenament în comparație cu alți algoritmi.
- Acesta prezice ieșirea cu o precizie ridicată, chiar și pentru setul de date mare pe care îl rulează eficient.
- De asemenea, poate menține acuratețea atunci când lipsește o mare parte de date.
Cum funcționează algoritmul Random Forest?
Random Forest funcționează în două faze, mai întâi este de a crea pădurea aleatoare combinând N arbore de decizie, iar a doua este de a face predicții pentru fiecare copac creat în prima fază.
Procesul de lucru poate fi explicat în pașii și diagrama de mai jos:
Pasul 1: Selectați aleatoriu K puncte de date din setul de antrenament.
Pasul 2: Construiți arbori de decizie asociați cu punctele de date selectate (Subseturi).
Pasul 3: Alegeți numărul N pentru arborii de decizie pe care doriți să-l construiți.
structuri de date java
Pasul-4: Repetați pașii 1 și 2.
Pasul-5: Pentru punctele de date noi, găsiți predicțiile fiecărui arbore de decizie și atribuiți noile puncte de date categoriei care câștigă voturile majoritare.
Funcționarea algoritmului poate fi înțeleasă mai bine prin exemplul de mai jos:
Exemplu: Să presupunem că există un set de date care conține mai multe imagini de fructe. Deci, acest set de date este dat clasificatorului de pădure aleatoriu. Setul de date este împărțit în subseturi și dat fiecărui arbore de decizie. În timpul fazei de instruire, fiecare arbore de decizie produce un rezultat de predicție, iar când apare un nou punct de date, apoi pe baza majorității rezultatelor, clasificatorul Random Forest prezice decizia finală. Luați în considerare imaginea de mai jos:
Aplicații ale pădurii aleatorii
Există în principal patru sectoare în care pădurea aleatorie este folosită cel mai mult:
întinde copaci
Avantajele Random Forest
- Random Forest este capabil să efectueze atât sarcini de clasificare, cât și de regresie.
- Este capabil să manipuleze seturi mari de date cu o dimensionalitate ridicată.
- Îmbunătățește acuratețea modelului și previne problema de supraadaptare.
Dezavantajele pădurii aleatorii
- Deși pădurea aleatoare poate fi folosită atât pentru sarcini de clasificare, cât și pentru sarcini de regresie, nu este mai potrivită pentru sarcinile de regresie.
Implementarea Python a algoritmului forestier aleatoriu
Acum vom implementa arborele Algoritmului de pădure aleatorie folosind Python. Pentru aceasta, vom folosi același set de date „user_data.csv”, pe care l-am folosit în modelele de clasificare anterioare. Folosind același set de date, putem compara clasificatorul Random Forest cu alte modele de clasificare, cum ar fi Arborele de decizie Clasificator, KNN, SVM, regresie logistică etc.
Pașii de implementare sunt prezentați mai jos:
- Etapa de preprocesare a datelor
- Potrivirea algoritmului de pădure aleatorie la setul de antrenament
- Prezicerea rezultatului testului
- Testați acuratețea rezultatului (matricea de creare a confuziei)
- Vizualizarea rezultatului setului de testare.
1. Etapa de preprocesare a datelor:
Mai jos este codul pentru etapa de preprocesare:
# 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)
În codul de mai sus, am preprocesat datele. Unde am încărcat setul de date, care este dat ca:
2. Potrivirea algoritmului Random Forest la setul de antrenament:
Acum vom potrivi algoritmul de pădure aleatorie la setul de antrenament. Pentru a-l potrivi, vom importa RandomForestClassifier clasa de la sklearn.ansamblu bibliotecă. Codul este dat mai jos:
#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)
În codul de mai sus, obiectul clasificator preia parametrii de mai jos:
Ieșire:
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. Prezicerea rezultatului setului de testare
Deoarece modelul nostru este adaptat setului de antrenament, acum putem prezice rezultatul testului. Pentru predicție, vom crea un nou vector de predicție y_pred. Mai jos este codul pentru acesta:
#Predicting the test set result y_pred= classifier.predict(x_test)
Ieșire:
Vectorul de predicție este dat astfel:
centrarea unei imagini în css
Prin verificarea vectorului de predicție de mai sus și a vectorului real al setului de test, putem determina predicțiile incorecte făcute de clasificator.
4. Crearea matricei de confuzie
Acum vom crea matricea de confuzie pentru a determina predicțiile corecte și incorecte. Mai jos este codul pentru acesta:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Ieșire:
După cum putem vedea în matricea de mai sus, există 4+4= 8 predicții incorecte și 64+28= 92 predicții corecte.
5. Vizualizarea rezultatului setului de antrenament
Aici vom vizualiza rezultatul setului de antrenament. Pentru a vizualiza rezultatul setului de antrenament, vom reprezenta un grafic pentru clasificatorul de pădure aleatoriu. Clasificatorul va prezice da sau Nu pentru utilizatorii care fie au achiziționat, fie nu au achiziționat mașina SUV, așa cum am făcut în regresia logistică. Mai jos este codul pentru acesta:
java string.format
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()
Ieșire:
Imaginea de mai sus este rezultatul vizualizării pentru clasificatorul Random Forest care lucrează cu rezultatul setului de antrenament. Este foarte asemănător cu clasificatorul arborelui de decizie. Fiecare punct de date corespunde fiecărui utilizator al user_data, iar regiunile violet și verde sunt regiunile de predicție. Regiunea violet este clasificată pentru utilizatorii care nu au achiziționat mașina SUV, iar regiunea verde este pentru utilizatorii care au achiziționat SUV-ul.
Deci, în clasificatorul Random Forest, am luat 10 arbori care au prezis Da sau NU pentru variabila Cumpărat. Clasificatorul a preluat majoritatea predicțiilor și a furnizat rezultatul.
6. Vizualizarea rezultatului setului de testare
Acum vom vizualiza rezultatul setului de testare. Mai jos este codul pentru acesta:
#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()
Ieșire:
Imaginea de mai sus este rezultatul vizualizării setului de testare. Putem verifica dacă există un număr minim de predicții incorecte (8) fără problema Suprafitting. Vom obține rezultate diferite prin schimbarea numărului de arbori din clasificator.