Random Forest je popularan algoritam strojnog učenja koji pripada tehnici nadziranog učenja. Može se koristiti i za probleme klasifikacije i regresije u ML-u. Temelji se na konceptu učenje u ansamblu, što je proces od kombiniranje više klasifikatora za rješavanje složenog problema i poboljšanje izvedbe modela.
Kao što naziv govori, 'Random Forest je klasifikator koji sadrži niz stabala odlučivanja na različitim podskupovima danog skupa podataka i uzima prosjek za poboljšanje prediktivne točnosti tog skupa podataka.' Umjesto da se oslanja na jedno stablo odlučivanja, nasumična šuma uzima predviđanje iz svakog stabla i na temelju većine glasova predviđanja, te predviđa konačni rezultat.
Veći broj stabala u šumi dovodi do veće točnosti i sprječava problem prekomjernog opremanja.
stlc
Donji dijagram objašnjava rad algoritma Random Forest:
Napomena: da biste bolje razumjeli algoritam slučajne šume, trebali biste poznavati algoritam stabla odlučivanja.
Pretpostavke za slučajnu šumu
Budući da nasumična šuma kombinira više stabala za predviđanje klase skupa podataka, moguće je da neka stabla odlučivanja mogu predvidjeti točan izlaz, dok druga ne moraju. Ali zajedno, sva stabla predviđaju točan rezultat. Stoga su u nastavku dvije pretpostavke za bolji klasifikator slučajnih šuma:
- Trebale bi postojati neke stvarne vrijednosti u varijabli značajki skupa podataka kako bi klasifikator mogao predvidjeti točne rezultate, a ne pretpostavljeni rezultat.
- Predviđanja iz svakog stabla moraju imati vrlo niske korelacije.
Zašto koristiti Random Forest?
Ispod su neke točke koje objašnjavaju zašto bismo trebali koristiti algoritam Random Forest:
- Potrebno je manje vremena za obuku u usporedbi s drugim algoritmima.
- Predviđa rezultate s visokom točnošću, čak i za veliki skup podataka koji učinkovito izvodi.
- Također može održati točnost kada nedostaje velik dio podataka.
Kako radi algoritam Random Forest?
Random Forest radi u dvije faze, prva je stvaranje nasumične šume kombiniranjem N stabla odluka, a druga je izrada predviđanja za svako stablo stvoreno u prvoj fazi.
Proces rada može se objasniti u sljedećim koracima i dijagramu:
Korak 1: Odaberite nasumično K podatkovnih točaka iz skupa za vježbanje.
Korak 2: Izgradite stabla odlučivanja povezana s odabranim podatkovnim točkama (Podskupovi).
Korak-3: Odaberite broj N za stabla odlučivanja koja želite izgraditi.
Korak-4: Ponovite 1. i 2. korak.
java compareto metoda
Korak-5: Za nove podatkovne točke pronađite predviđanja svakog stabla odlučivanja i dodijelite nove podatkovne točke kategoriji koja osvoji većinu glasova.
Rad algoritma može se bolje razumjeti na primjeru u nastavku:
Primjer: Pretpostavimo da postoji skup podataka koji sadrži više slika voća. Dakle, ovaj se skup podataka daje klasifikatoru Random forest. Skup podataka je podijeljen u podskupove i dan svakom stablu odlučivanja. Tijekom faze obuke, svako stablo odlučivanja daje rezultat predviđanja, a kada se pojavi nova podatkovna točka, tada na temelju većine rezultata, klasifikator Random Forest predviđa konačnu odluku. Razmotrite sliku u nastavku:
Primjene slučajne šume
Postoje uglavnom četiri sektora u kojima se uglavnom koristi slučajna šuma:
Prednosti nasumične šume
- Nasumična šuma sposobna je obavljati i zadatke klasifikacije i regresije.
- Sposoban je rukovati velikim skupovima podataka visoke dimenzionalnosti.
- Povećava točnost modela i sprječava problem prekomjernog opremanja.
Nedostaci slučajne šume
- Iako se slučajna šuma može koristiti i za zadatke klasifikacije i za regresiju, nije prikladnija za zadatke regresije.
Python implementacija algoritma slučajnih šuma
Sada ćemo implementirati stablo Random Forest Algorithm koristeći Python. Za to ćemo koristiti isti skup podataka 'user_data.csv', koji smo koristili u prethodnim modelima klasifikacije. Korištenjem istog skupa podataka možemo usporediti klasifikator Random Forest s drugim modelima klasifikacije kao što su Klasifikator stabla odlučivanja, KNN, SVM, logistička regresija itd.
np std
Koraci implementacije navedeni su u nastavku:
- Korak prethodne obrade podataka
- Prilagođavanje algoritma slučajne šume skupu za obuku
- Predviđanje rezultata testa
- Testirajte točnost rezultata (Matrika stvaranja zabune)
- Vizualizacija rezultata ispitnog skupa.
1. Korak prethodne obrade podataka:
Ispod je kod za korak predobrade:
# 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)
U gornjem kodu unaprijed smo obradili podatke. Gdje smo učitali skup podataka, koji je dan kao:
2. Prilagodba algoritma Random Forest skupu za obuku:
Sada ćemo prilagoditi algoritam slučajne šume skupu za obuku. Da bismo ga uklopili, uvest ćemo RandomForestClassifier razreda iz sklearn.ansambl knjižnica. Kod je naveden u nastavku:
#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)
U gornjem kodu, objekt klasifikatora uzima sljedeće parametre:
Izlaz:
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. Predviđanje rezultata testa
Budući da je naš model prilagođen setu za vježbanje, sada možemo predvidjeti rezultat testa. Za predviđanje ćemo stvoriti novi vektor predviđanja y_pred. Ispod je kod za to:
#Predicting the test set result y_pred= classifier.predict(x_test)
Izlaz:
Vektor predviđanja je dan kao:
Provjerom gornjeg vektora predviđanja i stvarnog vektora skupa testova možemo utvrditi netočna predviđanja koja je napravio klasifikator.
java kraj
4. Stvaranje matrice zabune
Sada ćemo izraditi matricu zabune kako bismo odredili točna i netočna predviđanja. Ispod je kod za to:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Izlaz:
Kao što možemo vidjeti u gornjoj matrici, postoje 4+4= 8 netočnih predviđanja i 64+28= 92 točna predviđanja.
5. Vizualizacija rezultata treninga
Ovdje ćemo vizualizirati rezultat skupa treninga. Kako bismo vizualizirali rezultat skupa za obuku, iscrtat ćemo graf za klasifikator slučajnih šuma. Klasifikator će predvidjeti da ili ne za korisnike koji su ili kupili ili nisu kupili SUV automobil kao što smo učinili u logističkoj regresiji. Ispod je kod za to:
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()
Izlaz:
Gornja slika rezultat je vizualizacije za klasifikator Random Forest koji radi s rezultatom skupa za obuku. Vrlo je sličan klasifikatoru stabla odlučivanja. Svaka podatkovna točka odgovara svakom korisniku user_data, a ljubičasta i zelena područja su područja predviđanja. Ljubičasto područje je klasificirano za korisnike koji nisu kupili SUV automobil, a zeleno područje je za korisnike koji su kupili SUV.
if i else u bashu
Dakle, u klasifikatoru Random Forest uzeli smo 10 stabala koja su predvidjela Da ili NE za varijablu Kupljeno. Klasifikator je uzeo većinu predviđanja i dao rezultat.
6. Vizualizacija rezultata testa
Sada ćemo vizualizirati rezultat skupa testova. Ispod je kod za to:
#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()
Izlaz:
Gornja slika rezultat je vizualizacije za testni skup. Možemo provjeriti postoji li minimalni broj netočnih predviđanja (8) bez problema s pretjeranim uklapanjem. Promjenom broja stabala u klasifikatoru dobit ćemo drugačije rezultate.