Random Forest to popularny algorytm uczenia maszynowego należący do techniki uczenia nadzorowanego. Można go stosować zarówno do problemów klasyfikacji, jak i regresji w ML. Opiera się na koncepcji nauka zespołowa, który jest procesem łączenie wielu klasyfikatorów w celu rozwiązania złożonego problemu i poprawy wydajności modelu.
Jak sama nazwa wskazuje, „Random Forest to klasyfikator zawierający wiele drzew decyzyjnych w różnych podzbiorach danego zbioru danych i obliczający średnią w celu poprawy dokładności predykcyjnej tego zbioru danych”. Zamiast polegać na jednym drzewie decyzyjnym, losowy las pobiera przewidywania z każdego drzewa i na podstawie większości głosów przewidywań, a następnie przewiduje ostateczny wynik.
Większa liczba drzew w lesie zapewnia większą dokładność i zapobiega problemowi nadmiernego dopasowania.
tablica obiektów Java
Poniższy diagram wyjaśnia działanie algorytmu Random Forest:
Uwaga: Aby lepiej zrozumieć algorytm losowego lasu, powinieneś znać algorytm drzewa decyzyjnego.
Założenia dotyczące losowego lasu
Ponieważ las losowy łączy wiele drzew w celu przewidzenia klasy zbioru danych, możliwe jest, że niektóre drzewa decyzyjne będą w stanie przewidzieć prawidłowe wyniki, a inne nie. Ale razem wszystkie drzewa przewidują prawidłowy wynik. Dlatego poniżej znajdują się dwa założenia lepszego losowego klasyfikatora leśnego:
- W zmiennej cechy zbioru danych powinny znajdować się pewne rzeczywiste wartości, aby klasyfikator mógł przewidzieć dokładne wyniki, a nie wynik zgadnięty.
- Przewidywania z każdego drzewa muszą mieć bardzo niskie korelacje.
Dlaczego warto używać Losowego Lasu?
Poniżej znajduje się kilka punktów wyjaśniających, dlaczego powinniśmy używać algorytmu Random Forest:
- Zajmuje mniej czasu na szkolenie w porównaniu do innych algorytmów.
- Przewiduje dane wyjściowe z dużą dokładnością, nawet w przypadku dużego zestawu danych działa wydajnie.
- Może także zachować dokładność w przypadku braku dużej części danych.
Jak działa algorytm Random Forest?
Random Forest działa w dwóch fazach: pierwsza polega na utworzeniu losowego lasu poprzez połączenie N drzew decyzyjnych, a druga polega na dokonaniu prognoz dla każdego drzewa utworzonego w pierwszej fazie.
Proces pracy można wyjaśnić w poniższych krokach i schemacie:
Krok 1: Wybierz losowe K punktów danych ze zbioru szkoleniowego.
Krok 2: Zbuduj drzewa decyzyjne powiązane z wybranymi punktami danych (podzbiorami).
Dekodowanie JavaScript Base64
Krok 3: Wybierz liczbę N dla drzew decyzyjnych, które chcesz zbudować.
Krok 4: Powtórz kroki 1 i 2.
Krok 5: W przypadku nowych punktów danych znajdź przewidywania każdego drzewa decyzyjnego i przypisz nowe punkty danych do kategorii, która zdobędzie większość głosów.
Działanie algorytmu można lepiej zrozumieć na poniższym przykładzie:
Przykład: Załóżmy, że istnieje zbiór danych zawierający wiele obrazów owoców. Zatem ten zbiór danych jest przekazywany losowemu klasyfikatorowi leśnemu. Zbiór danych jest dzielony na podzbiory i przypisywany do każdego drzewa decyzyjnego. Podczas fazy uczenia każde drzewo decyzyjne generuje wynik przewidywania, a gdy pojawi się nowy punkt danych, klasyfikator Random Forest przewiduje ostateczną decyzję na podstawie większości wyników. Rozważ poniższy obraz:
GB kontra MB
Zastosowania losowego lasu
Istnieją głównie cztery sektory, w których najczęściej używany jest las losowy:
Zalety losowego lasu
- Random Forest może wykonywać zarówno zadania klasyfikacji, jak i regresji.
- Jest w stanie obsługiwać duże zbiory danych o dużej wymiarowości.
- Zwiększa to dokładność modelu i zapobiega problemowi nadmiernego dopasowania.
Wady losowego lasu
- Chociaż losowy las może być używany zarówno do zadań klasyfikacji, jak i regresji, nie jest on bardziej odpowiedni do zadań regresji.
Implementacja algorytmu losowego lasu w Pythonie
Teraz zaimplementujemy drzewo algorytmu Random Forest Algorithm przy użyciu języka Python. W tym celu użyjemy tego samego zbioru danych „user_data.csv”, którego używaliśmy w poprzednich modelach klasyfikacji. Korzystając z tego samego zbioru danych, możemy porównać klasyfikator Random Forest z innymi modelami klasyfikacji, takimi jak Klasyfikator drzewa decyzyjnego, KNN, SVM, regresja logistyczna itp.
Kroki wdrożenia podano poniżej:
- Etap wstępnego przetwarzania danych
- Dopasowanie algorytmu losowego lasu do zbioru uczącego
- Przewidywanie wyniku testu
- Sprawdź dokładność wyniku (macierz tworzenia zamieszania)
- Wizualizacja wyniku zestawu testowego.
1. Etap wstępnego przetwarzania danych:
Poniżej znajduje się kod etapu wstępnego przetwarzania:
# 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)
W powyższym kodzie dane zostały wstępnie przetworzone. Gdzie załadowaliśmy zbiór danych, który jest podany jako:
2. Dopasowanie algorytmu Random Forest do zbioru uczącego:
Teraz dopasujemy algorytm losowego lasu do zbioru uczącego. Aby to dopasować, zaimportujemy plik RandomForestClassifier klasa z sklearn.zespół biblioteka. Kod podano poniżej:
#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)
W powyższym kodzie obiekt klasyfikatora przyjmuje poniższe parametry:
Wyjście:
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. Przewidywanie wyniku zestawu testowego
Ponieważ nasz model jest dopasowany do zbioru uczącego, możemy więc teraz przewidzieć wynik testu. W celu przewidywania utworzymy nowy wektor przewidywania y_pred. Poniżej znajduje się jego kod:
#Predicting the test set result y_pred= classifier.predict(x_test)
Wyjście:
ile miast jest w nas
Wektor predykcyjny jest podany jako:
Sprawdzając powyższy wektor predykcyjny i wektor rzeczywisty zbioru testowego, możemy określić błędne przewidywania dokonane przez klasyfikator.
4. Tworzenie macierzy zamieszania
Teraz utworzymy macierz zamieszania, aby określić prawidłowe i niepoprawne przewidywania. Poniżej znajduje się jego kod:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Wyjście:
rj12 kontra rj11
Jak widać na powyższej matrycy, są 4+4= 8 błędnych przewidywań I 64+28= 92 prawidłowe przewidywania.
5. Wizualizacja wyniku treningu
Tutaj zwizualizujemy wynik zestawu treningowego. Aby zwizualizować wynik zbioru uczącego, narysujemy wykres dla klasyfikatora Random Forest. Klasyfikator przewidzi odpowiedź „tak” lub „nie” dla użytkowników, którzy kupili lub nie kupili samochód typu SUV, tak jak to zrobiliśmy w przypadku regresji logistycznej. Poniżej znajduje się jego kod:
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()
Wyjście:
Powyższy obraz przedstawia wynik wizualizacji klasyfikatora Random Forest pracującego z wynikiem zbioru uczącego. Jest bardzo podobny do klasyfikatora drzewa decyzyjnego. Każdy punkt danych odpowiada każdemu użytkownikowi user_data, a fioletowe i zielone obszary to regiony predykcji. Region fioletowy jest klasyfikowany dla użytkowników, którzy nie kupili samochodu typu SUV, a obszar zielony obejmuje użytkowników, którzy kupili samochód typu SUV.
Zatem w klasyfikatorze Random Forest wzięliśmy 10 drzew, które przewidziały Tak lub Nie dla zmiennej Zakupionej. Klasyfikator przyjął większość przewidywań i dostarczył wynik.
6. Wizualizacja wyniku zestawu testowego
Teraz zwizualizujemy wynik zestawu testowego. Poniżej znajduje się jego kod:
#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()
Wyjście:
Powyższy obraz przedstawia wynik wizualizacji zbioru testowego. Możemy sprawdzić, czy istnieje minimalna liczba błędnych przewidywań (8) bez problemu nadmiernego dopasowania. Inne wyniki otrzymamy zmieniając liczbę drzew w klasyfikatorze.