logo

Algorytm losowego lasu

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:

Algorytm losowego lasu

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
Algorytm losowego lasu

Zastosowania losowego lasu

Istnieją głównie cztery sektory, w których najczęściej używany jest las losowy:

    Bankowość:Sektor bankowy najczęściej wykorzystuje ten algorytm do identyfikacji ryzyka kredytowego.Medycyna:Za pomocą tego algorytmu można zidentyfikować trendy chorobowe i ryzyko choroby.Zagospodarowanie terenu:Za pomocą tego algorytmu możemy zidentyfikować obszary o podobnym użytkowaniu gruntów.Marketing:Za pomocą tego algorytmu można zidentyfikować trendy marketingowe.

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:

Algorytm losowego lasu

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:

    n_estymatory=Wymagana liczba drzew w Losowym Lesie. Wartość domyślna to 10. Możemy wybrać dowolną liczbę, ale musimy zadbać o kwestię nadmiernego dopasowania.kryterium=Jest to funkcja służąca do analizy dokładności podziału. Tutaj przyjęliśmy „entropię” jako zysk informacyjny.

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:

Algorytm losowego lasu

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
Algorytm losowego lasu

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:

Algorytm losowego lasu

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:

Algorytm losowego lasu

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.