Ostateczny przewodnik po algorytmie losowego lasu z Pythonem i Scikit-Learn

Wprowadzenie

Algorytm losowego lasu jest jednym z najbardziej elastycznych, wydajnych i szeroko stosowanych algorytmów klasyfikacja i regresja, zbudowany jako zespół drzew decyzyjnych.

Jeśli nie jesteś z nimi zaznajomiony – nie martw się, omówimy wszystkie te pojęcia.

W tym szczegółowym praktycznym przewodniku zbudujemy plik intuicja o tym, jak działają drzewa decyzyjne, jak ensembling wzmacnia poszczególne klasyfikatory i regresory, czym są losowe lasy i zbudować losowy klasyfikator lasu i regresor za pomocą Pythona i Scikit-Learn, poprzez kompleksowy mini-projekt i odpowiedzieć na pytanie badawcze.

Weź pod uwagę, że należysz obecnie do grupy badawczej, która analizuje dane dotyczące kobiet. Grupa zebrała 100 rekordów danych i chce mieć możliwość uporządkowania tych początkowych zapisów, dzieląc kobiety na kategorie: będące lub nie w ciąży oraz mieszkające na obszarach wiejskich lub miejskich. Naukowcy chcą zrozumieć, ile kobiet znalazłoby się w każdej kategorii.

Istnieje struktura obliczeniowa, która dokładnie to robi, to jest drzewo Struktura. Używając struktury drzewiastej, będziesz mógł reprezentować różne działy dla każdej kategorii.

Drzewa decyzyjne

Jak wypełnić węzły drzewa? To jest gdzie drzewa decyzyjne wpaść w ostrość.

Najpierw możemy podzielić rekordy według ciąż, potem możemy je podzielić według zamieszkania na obszarach miejskich lub wiejskich. Zauważ, że moglibyśmy to zrobić w innej kolejności, dzieląc początkowo według obszaru, w którym mieszkają kobiety i po ich stanie ciąży. Z tego widać, że drzewo ma nieodłączną hierarchię. Oprócz organizowania informacji, drzewo organizuje informacje w sposób hierarchiczny – kolejność, w jakiej pojawiają się informacje, ma znaczenie i w rezultacie prowadzi do różnych drzew.

Poniżej znajduje się przykład drzewa, które zostało opisane:

Na obrazie drzewa jest 7 kwadratów, z których ten na górze odpowiada łącznie 100 kobietom, ten górny kwadrat jest połączony z dwoma kwadratami poniżej, które dzielą kobiety na podstawie ich liczby 78 kobiet niebędących w ciąży i 22 kobiet w ciąży, oraz z obu poprzednich kwadratów są cztery kwadraty; dwa połączone z każdym kwadratem powyżej, które dzielą kobiety na podstawie ich obszaru, w przypadku kobiet niebędących w ciąży 45 mieszka na obszarach miejskich, 33 na obszarach wiejskich, a dla kobiet w ciąży 14 mieszka na obszarach wiejskich i 8 w obszarach miejskich. Wystarczy spojrzeć na drzewo, aby łatwo zrozumieć te podziały i zobaczyć, jak każda „warstwa” wywodzi się z poprzednich, te warstwy są drzewem poziomy, poziomy opisują głębokość drzewa:

Zauważ na powyższym obrazku, że jest to pierwszy poziom drzewa Poziom 0 gdzie jest tylko jeden kwadrat, po którym następuje Poziom 1 gdzie są dwa kwadraty i Poziom 2 gdzie są cztery kwadraty. To jest głębokość 2 drzewo.

Na poziomie 0 znajduje się kwadrat, z którego pochodzi drzewo, pierwszy, zwany Węzeł główny, ten pierwiastek ma dwa węzły potomne na poziomie 1, tj węzły nadrzędne do czterech węzłów na poziomie 2. Zobacz, że „kwadraty”, o których mówiliśmy do tej pory, tak naprawdę nazywają się węzły; i że każdy poprzedni węzeł jest rodzicem kolejnych węzłów, które są jego dziećmi. Nazywane są węzły potomne każdego poziomu, które mają tego samego rodzica rodzeństwo, jak widać na następnym obrazku:

Na poprzednim obrazie również wyświetlamy poziom 1 jako będący węzły wewnętrzne, gdy znajdą się między korzeniem a ostatnimi węzłami, którymi są węzły liści. Węzły liściowe są ostatnią częścią drzewa, gdybyśmy ze 100 początkowych kobiet mieli powiedzieć, ile jest w ciąży i mieszka na obszarach wiejskich, moglibyśmy to zrobić, patrząc na liście. Tak więc liczba na liściach odpowiadałaby na pierwsze pytanie badawcze.

Gdyby istniały nowe zapisy dotyczące kobiet, a drzewo, które wcześniej służyło do ich kategoryzacji, zostało teraz użyte do decydowania, czy kobieta może, czy nie może być częścią badań, czy nadal by funkcjonowało? Drzewo stosowałoby te same kryteria, a kobieta byłaby uprawniona do udziału, gdyby była w ciąży i mieszkała na obszarach wiejskich.

Patrząc na powyższy obrazek, możemy zobaczyć, że odpowiedzi na pytania każdego węzła drzewa – „czy ona jest uczestniczką?”, „czy jest w ciąży?”, „czy mieszka na wsi?” – brzmią tak, tak, i tak, więc wydaje się, że drzewo może rzeczywiście doprowadzić do decyzji, w tym przypadku, że kobieta może wziąć udział w badaniu.

To jest esencja drzew decyzyjnych w, wykonane w sposób ręczny. Korzystając z uczenia maszynowego, możemy zbudować model, który automatycznie konstruuje to drzewo za nas, w taki sposób, aby zmaksymalizować trafność ostatecznych decyzji.

W poprzednich przykładach zauważ, jak drzewo mogłoby to zrobić klasyfikować nowe dane jako uczestnik lub nieuczestnik, lub też można zmienić pytania na – „ile jest uczestników?”, „ile jest w ciąży?”, „ile mieszka na obszarach wiejskich?” – co prowadzi nas do znalezienia ilość ciężarnych uczestniczek mieszkających na obszarach wiejskich.

Kiedy dane są sklasyfikowane, oznacza to, że drzewo wykonuje a klasyfikacja zadanie, a kiedy ilość danych zostanie znaleziona, drzewo wykonuje a regresja zadanie. Oznacza to, że drzewo decyzyjne może być wykorzystywane zarówno do zadań – klasyfikacji, jak i regresji.

Teraz, gdy rozumiemy, czym jest drzewo decyzyjne, jak można go używać i jaką nomenklaturą się je opisuje, możemy zastanawiać się nad jego ograniczeniami.

Zrozumienie lasów losowych

Co się dzieje z decyzją, jeśli jakiś uczestnik mieszka na podziale na miasto i wieś? Czy drzewo dodałoby ten rekord do obszarów wiejskich czy miejskich? Wydaje się, że trudno jest dopasować te dane do struktury, którą mamy obecnie, ponieważ są one dość jasne.

Ponadto, co jeśli kobieta mieszkająca na łodzi weźmie udział w badaniach, czy zostanie to uznane za wiejskie czy miejskie? Podobnie jak w poprzednim przypadku, jest to trudny punkt danych do sklasyfikowania, biorąc pod uwagę dostępne opcje w drzewie.

Myśląc nieco więcej o przykładzie drzewa decyzyjnego, jesteśmy w stanie zobaczyć, że może on poprawnie klasyfikować nowe dane, biorąc pod uwagę, że jest już zgodny ze wzorcem, który już ma drzewo - ale kiedy istnieją rekordy różniące się od danych początkowych, które zdefiniowały drzewo, struktura drzewiasta jest zbyt sztywna, co uniemożliwia klasyfikację rekordów.

Oznacza to, że drzewo decyzyjne może być ścisłe i ograniczone w swoich możliwościach. Idealne drzewo decyzyjne byłoby bardziej elastyczne i zdolne do uwzględnienia bardziej szczegółowych, niewidocznych danych.

Jeśli chodzi o odpowiedź na pytanie początkowe, to już wiemy, że będzie ona zakodowana w liściach drzew – ale co się zmienia, gdy mamy wiele drzew zamiast jednego?

Jeśli drzewa zostaną połączone w celu klasyfikacji, wynik zostanie określony przez większość odpowiedzi, jest to tzw głosowanie większościowe; aw przypadku regresji liczba podana przez każde drzewo w lesie będzie wynosić uśrednione.

Zespoły uczenia się i modele

Ta metoda jest znana jako kompletne uczenie się. Stosując uczenie zespołowe, możesz łączyć ze sobą dowolne algorytmy, o ile możesz zapewnić, że dane wyjściowe można przeanalizować i połączyć z innymi wynikami (ręcznie lub przy użyciu istniejących bibliotek). Zazwyczaj łączysz ze sobą wiele modeli tego samego typu, takich jak wiele drzew decyzyjnych, ale nie ograniczasz się tylko do łączenia zespołami tego samego typu.

Ensembling to praktycznie gwarantowany sposób na lepsze uogólnienie problemu i wyciśnięcie niewielkiego wzrostu wydajności. W niektórych przypadkach składanie modeli daje a znaczący wzrost mocy predykcyjnej, a czasami tylko niewielki. Zależy to od zestawu danych, który trenujesz i oceniasz, a także od samych modeli.

Łączenie drzew decyzyjnych razem daje plony znaczący zwiększenie wydajności w porównaniu z pojedynczymi drzewami. Podejście to zostało spopularyzowane w społecznościach zajmujących się badaniami i stosowanym uczeniem maszynowym i było tak powszechne, że zespół drzew decyzyjnych został potocznie nazwany las, a powszechny typ tworzonego lasu (las drzew decyzyjnych na losowym podzbiorze cech) spopularyzował nazwę losowe lasy.

Biorąc pod uwagę użycie na szeroką skalę, biblioteki takie jak Scikit-Learn zaimplementowały opakowania dla RandomForestRegressorsi RandomForestClassifiers, zbudowane na podstawie ich własnych implementacji drzewa decyzyjnego, aby umożliwić naukowcom uniknięcie tworzenia własnych zespołów.

Zanurzmy się w przypadkowych lasach!

Jak działa algorytm losowego lasu?

Poniżej przedstawiono podstawowe kroki wykonywane podczas wykonywania algorytmu losowego lasu:

1. Wybierz liczbę losowych rekordów, może to być dowolna liczba, np. 4, 20, 76, 150, a nawet 2.000 ze zbioru danych (tzw. N dokumentacja). Liczba będzie zależeć od szerokości zbioru danych, im szerszy, tym większy N może być. Tutaj jest przypadkowy część w nazwie algorytmu pochodzi!
2. Na ich podstawie zbuduj drzewo decyzyjne N losowe rekordy;
3. W zależności od liczby drzew zdefiniowanych dla algorytmu lub liczby drzew w lesie powtórz kroki 1 i 2. Spowoduje to wygenerowanie większej liczby drzew ze zbiorów losowych rekordów danych;
4. Po kroku 3 następuje ostatni krok, czyli przewidywanie wyników:
   • W przypadku klasyfikacji: każde drzewo w lesie będzie przewidywało kategorię, do której należy nowy rekord. Następnie nowy rekord zostaje przypisany do kategorii, która zdobędzie większość głosów.
   • W przypadku regresji: każde drzewo w lesie przewiduje wartość dla nowego rekordu, a ostateczna wartość prognozy zostanie obliczona poprzez wzięcie średniej ze wszystkich wartości przewidywanych przez wszystkie drzewa w lesie.

Każde drzewo pasujące do losowego podzbioru cech z konieczności nie będzie miało wiedzy o niektórych innych cechach, co jest korygowane przez składanie, przy jednoczesnym obniżeniu kosztów obliczeniowych.

Z intuicją w zakresie działania drzew i zrozumieniem losowych lasów – jedyne, co pozostaje, to ćwiczyć ich budowanie, trenowanie i dostosowywanie ich do danych!

Budowanie i trenowanie modeli lasów losowych za pomocą Scikit-Learn

Nie bez powodu przykłady stosowane do tej pory dotyczą ciąży, powierzchni mieszkalnej i kobiet.

W 2020 roku naukowcy z Bangladeszu zauważyli, że śmiertelność wśród kobiet w ciąży jest nadal bardzo wysoka, zwłaszcza biorąc pod uwagę te, które mieszkają na obszarach wiejskich. Z tego powodu wykorzystali system monitorowania IOT analizować ryzyko dla zdrowia matki. System IOT zebrał dane z różnych szpitali, przychodni i placówek opieki zdrowotnej dla matek z obszarów wiejskich Bangladeszu.

Zebrane dane zostały następnie zorganizowane w pliku z wartościami rozdzielanymi przecinkami (csv) i przesłane do Repozytorium uczenia maszynowego UCI.

To są dane, których użyjemy do ćwiczeń i spróbujemy zrozumieć, czy kobieta w ciąży ma Niska, średni or wysoka ryzyko śmierci.

Używanie losowego lasu do klasyfikacji

Ponieważ chcemy wiedzieć, czy kobieta ma Niska, średni or wysoka ryzyko zgonu, oznacza to, że przeprowadzimy klasyfikację z trzema klasami. Gdy problem ma więcej niż dwie klasy, nazywa się go wieloklasowa problem, w przeciwieństwie do A dwójkowy problem (gdzie zwykle wybierasz między dwiema klasami 0 i 1).

W tym pierwszym przykładzie zaimplementujemy wieloklasowy model klasyfikacji z klasyfikatorem Random Forest i Scikit-Learn w Pythonie.

Aby rozwiązać ten problem, wykonamy zwykłe kroki uczenia maszynowego, które obejmują ładowanie bibliotek, odczytywanie danych, przeglądanie statystyk podsumowujących i tworzenie wizualizacji danych w celu lepszego ich zrozumienia. Następnie wstępne przetwarzanie i dzielenie danych, a następnie generowanie, trenowanie i ocena modelu.

Importowanie bibliotek

Będziemy używać Pandas do odczytywania danych, Seaborn i Matplotlib do ich wizualizacji, a NumPy do świetnych metod użytkowych:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

Importowanie zestawu danych

Poniższy kod importuje zestaw danych i ładuje go do Pythona DataFrame:

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

Aby spojrzeć na pierwsze pięć wierszy danych, wykonujemy head() polecenie:

dataset.head()

To daje:

    Age SystolicBP  DiastolicBP BS      BodyTemp    HeartRate   RiskLevel
0   25  130         80          15.0    98.0        86          high risk
1   35  140         90          13.0    98.0        70          high risk
2   29  90          70          8.0     100.0       80          high risk
3   30  140         85          7.0     98.0        70          high risk
4   35  120         60          6.1     98.0        76          low risk

Tutaj możemy zobaczyć wszystkie atrybuty zebrane podczas badania.

• Wiek: wiek w latach.
• SystolicBP: górna wartość ciśnienia krwi w mmHg, istotna cecha podczas ciąży.
• DiastolicBP: niższa wartość ciśnienia krwi w mmHg, kolejna istotna cecha podczas ciąży.
• BS: poziomy glukozy we krwi wyrażone jako stężenie molowe, mmol/l.
• HeartRate: tętno spoczynkowe w uderzeniach na minutę.
• Poziom ryzyka: poziom ryzyka podczas ciąży.
• BodyTemp: temperatura ciała.

Teraz, gdy wiemy więcej o tym, co jest mierzone, możemy przyjrzeć się typom danych info():

dataset.info()

To skutkuje:

RangeIndex: 1014 entries, 0 to 1013
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   Age          1014 non-null   int64  
 1   SystolicBP   1014 non-null   int64  
 2   DiastolicBP  1014 non-null   int64  
 3   BS           1014 non-null   float64
 4   BodyTemp     1014 non-null   float64
 5   HeartRate    1014 non-null   int64  
 6   RiskLevel    1014 non-null   object 
dtypes: float64(2), int64(4), object(1)
memory usage: 55.6+ KB

Od patrzenia na RangeIndex linii, widzimy, że jest 1014 rekordów i kolumna Non-Null Count informuje, że w danych nie ma braków danych. Oznacza to, że nie będziemy musieli podejmować żadnych działań w przypadku brakujących danych!

W Dtype kolumnie, możemy zobaczyć typ każdej zmiennej. W tej chwili, float64 kolumny takie BS i BodyTemp mają wartości liczbowe, które mogą zmieniać się w dowolnym zakresie, na przykład 15.0, 15.51, 15.76, 17.28, co czyni je numerycznie ciągły (zawsze możesz dodać 0 do liczby zmiennoprzecinkowej, reklama nieskończona). Z drugiej strony zmienne takie jak np Age, SystolicBP, DiastolicBP, HeartRate są typu int64, oznacza to, że liczby zmieniają się tylko o jednostkę, np. 11, 12, 13, 14 – nie będziemy mieć tętna 77.78, tylko 77 lub 78 – to są numerycznie dyskretny wartości. I my też mamy RiskLevel z object typu, oznacza to zwykle, że zmienna jest tekstem i prawdopodobnie będziemy musieli przekształcić ją w liczbę. Ponieważ poziom ryzyka rośnie od niskiego do wysokiego, istnieje dorozumiany porządek w kategoriach, co wskazuje, że jest to a kategorycznie porządkowy zmienna.

Po zapoznaniu się z typami danych możemy użyć describe() wziąć szczyt w niektórych statystykach opisowych, takich jak średnie wartości każdej kolumny, odchylenie standardowe, kwantyle, minimalne i maksymalne wartości danych:

dataset.describe().T 

Powyższy kod wyświetla:

            count   mean        std         min     25%     50%     75%     max
Age         1014.0  29.871795   13.474386   10.0    19.0    26.0    39.0    70.0
SystolicBP  1014.0  113.198225  18.403913   70.0    100.0   120.0   120.0   160.0
DiastolicBP 1014.0  76.460552   13.885796   49.0    65.0    80.0    90.0    100.0
BS          1014.0  8.725986    3.293532    6.0     6.9     7.5     8.0     19.0
BodyTemp    1014.0  98.665089   1.371384    98.0    98.0    98.0    98.0    103.0
HeartRate   1014.0  74.301775   8.088702    7.0     70.0    76.0    80.0    90.0
RiskLevel   1014.0  0.867850    0.807353    0.0     0.0     1.0     2.0     2.0

Zauważ, że dla większości kolumn, oznaczać wartości są dalekie od odchylenie standardowe (std) – oznacza to, że dane niekoniecznie mają dobrze zachowany rozkład statystyczny. Gdyby tak było, pomogłoby to modelowi w przewidywaniu ryzyka. To, co można tutaj zrobić, to wstępne przetworzenie danych, aby uczynić je bardziej reprezentatywnymi, tak jakby były to dane z całej światowej populacji lub więcej znormalizowany. Ale zaleta przy korzystaniu z modeli losowego lasu dla klasyfikacja, polega na tym, że nieodłączna struktura drzewa może dobrze radzić sobie z danymi, które nie zostały znormalizowane, po podzieleniu ich przez wartość na każdym poziomie drzewa dla każdej zmiennej.

Ponadto, ponieważ używamy drzew i że wynikowa klasa zostanie uzyskana w drodze głosowania, z natury nie porównujemy różnych wartości, tylko między tymi samymi typami wartości, więc dostosowanie funkcji do tej samej skali nie jest w tym przypadku konieczne . Oznacza to, że model klasyfikacyjny Random Forest jest niezmiennik skalii nie trzeba wykonywać skalowania funkcji.

W takim przypadku etapem wstępnego przetwarzania danych, który możemy wykonać, jest przekształcenie kategoryczne RiskLevel kolumnę na numeryczną.

Wizualizacja danych

Przed transformacją RiskLevel, szybko zwizualizujmy dane, patrząc na kombinacje punktów dla każdej pary obiektów za pomocą wykresu rozrzutu i jak punkty są rozmieszczone, wizualizując krzywą histogramu. Aby to zrobić, użyjemy Seaborn's pairplot() która łączy obie działki. Generuje oba wykresy dla każdej kombinacji cech i wyświetla punkty zakodowane kolorami zgodnie z ich poziomem ryzyka hue własność:

g = sns.pairplot(dataset, hue='RiskLevel')
g.fig.suptitle("Scatterplot and histogram of pairs of variables color coded by risk level", 
               fontsize = 14, 
               y=1.05); 

Powyższy kod generuje:

Patrząc na wykres, idealną sytuacją byłoby wyraźne oddzielenie krzywych od kropek. Jak widać, trzy rodzaje klas ryzyka są w większości pomieszane, ponieważ drzewa wewnętrznie rysują linie podczas wyznaczania przestrzeni między punktami, możemy postawić hipotezę, że więcej drzew w lesie może ograniczyć więcej przestrzeni i lepiej sklasyfikować punkty.

Po przeprowadzeniu podstawowej eksploracyjnej analizy danych możemy wstępnie przetworzyć plik RiskLevel Kolumna.

Wstępne przetwarzanie danych w celu klasyfikacji

Dla pewności są tylko trzy klasy RiskLevel w naszych danych i że żadne inne wartości nie zostały dodane błędnie, możemy użyć unique() aby wyświetlić unikalne wartości kolumny:

dataset['RiskLevel'].unique()

To daje:

array(['high risk', 'low risk', 'mid risk'], dtype=object)

Klasy są sprawdzone, teraz kolejnym krokiem jest przekształcenie każdej wartości na liczbę. Ponieważ istnieje kolejność między klasyfikacjami, możemy użyć wartości 0, 1 i 2 do oznaczania Niska, średni i wysoka ryzyko. Istnieje wiele sposobów zmiany wartości kolumn, zgodnie z Pythonem proste jest lepsze niż złożone motto, będziemy używać .replace() metodę i po prostu zastąp je ich reprezentacjami całkowitymi:

dataset['RiskLevel'] = dataset['RiskLevel'].replace('low risk', 0).replace('mid risk', 1).replace('high risk', 2)

Po zamianie wartości możemy podzielić dane na to, co będzie służyło do trenowania modelu, tj cechy or X, a to, co chcemy przewidzieć, to Etykiety or y:

y = dataset['RiskLevel']
X = dataset.drop(['RiskLevel'], axis=1)

Po X i y zestawy są gotowe, możemy skorzystać z Scikit-Learn train_test_split() metodę dalszego podziału ich na zbiory pociągów i testy:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

Tutaj używamy 20% danych do testowania i 80% do szkolenia.

Trenowanie RandomForestClassifier

Scikit-Learn zrealizował zespoły pod sklearn.ensemble moduł. Zespół drzew decyzyjnych służących do klasyfikacji, w których podejmowana jest większość głosów, jest realizowany jako RandomForestClassifier.

Mając pociąg i zestawy testowe możemy importować RandomForestClassifier klasę i stworzyć model. Na początek stwórzmy las z trzema drzewami według ustawienia n_estimators parametr jako 3, a każde drzewo ma trzy poziomy, przez ustawienie max_depthdo 2:

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=3, 
                             max_depth=2,
                             random_state=SEED)

Aby dopasować model wokół danych – nazywamy fit() metoda, przekazując cechy i etykiety szkoleniowe:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

Możemy teraz porównać przewidywane etykiety z rzeczywistymi etykietami, aby ocenić, jak dobrze spisał się model! Zanim ocenimy model, przyjrzyjmy się zespołowi.

Aby przyjrzeć się nieco głębiej modelowi, możemy zwizualizować każde z drzew i sposób, w jaki dzielą one dane. Można to zrobić za pomocą tree moduł wbudowany w Scikit-Learn, a następnie przeglądanie każdego z estymatorów w zespole:

from sklearn import tree

features = X.columns.values 
classes = ['0', '1', '2'] 



for estimator in rfc.estimators_:
    print(estimator)
    plt.figure(figsize=(12,6))
    tree.plot_tree(estimator,
                   feature_names=features,
                   class_names=classes,
                   fontsize=8, 
                   filled=True, 
                   rounded=True)
    plt.show()

Powyższy kod wyświetla wykresy drzewa:

Zwróć uwagę, czym różnią się te trzy drzewa. Pierwsza zaczyna się od BS funkcja, druga z DiastolicBP, a trzeci z BS ponownie. Chociaż trzeci patrzy na inną liczbę próbek. Na prawej gałęzi pierwsze dwa drzewa również decydują o użyciu Age na poziomie liścia, podczas gdy trzecie drzewo kończy się na BS funkcja. Mając tylko trzy estymatory, jasne jest, jak skalowanie w górę daje bogatą, zróżnicowaną reprezentację wiedzy, którą można z powodzeniem połączyć w bardzo dokładny model.

Im więcej drzew w lesie, tym bardziej różnorodny może być model. Istnieje jednak punkt malejących zwrotów, ponieważ przy wielu drzewach pasujących do losowego podzbioru cech, będzie sporo podobnych drzew, które nie oferują dużej różnorodności w zespole i które zaczną mieć zbyt duża siła głosu i przekrzywić zespół, aby był nadmiernie dopasowany do zbioru danych treningowych, szkodząc uogólnieniu zbioru walidacyjnego.

Wcześniej postawiono hipotezę dotyczącą posiadania większej liczby drzew i tego, jak mogłoby to poprawić wyniki modelu. Przyjrzyjmy się wynikom, wygenerujmy nowy model i sprawdźmy, czy hipoteza się sprawdza!

Ocena RandomForestClassifier

Scikit-Learn ułatwia tworzenie linii bazowych, udostępniając DummyClassifier, który generuje prognozy bez użycia funkcji wejściowych (całkowicie losowe wyjścia). Jeśli twój model jest lepszy niż DummyClassifier, kilka nauka się dzieje! Aby zmaksymalizować naukę – możesz automatycznie przetestować różne hiperparametry, używając a RandomizedSearchCV or GridSearchCV. Oprócz linii bazowej możesz ocenić wydajność swojego modelu na podstawie kilku metryk.

Niektóre tradycyjne metryki klasyfikacji, których można użyć do oceny algorytmu, to precyzja, przypominanie, wynik f1, dokładność i macierz zamieszania. Oto krótkie wyjaśnienie każdego z nich:

1. Detaliczność: gdy naszym celem jest zrozumienie, jakie prawidłowe wartości predykcji zostały uznane przez nasz klasyfikator za prawidłowe. Precyzja podzieli te prawdziwie dodatnie wartości przez próbki, które przewidywano jako dodatnie;

$$
precyzja = frac{tekst{prawdziwe trafienia}}{tekst{prawdziwe trafienia} + tekst{fałszywe trafienia}}
$$

2. Odwołanie: często obliczane wraz z precyzją, aby zrozumieć, ile prawdziwych pozytywów zostało zidentyfikowanych przez nasz klasyfikator. Wycofanie jest obliczane poprzez podzielenie prawdziwych pozytywów przez wszystko, co powinno być przewidywane jako pozytywne.

$$
przywołaj = frac{tekst{prawdziwe pozytywy}}{tekst{prawdziwie pozytywy} + tekst{fałszywie pozytywy}}
$$

3. Wynik F1: czy zrównoważony lub Średnia harmoniczna precyzji i przypomnienia. Najniższa wartość to 0, a najwyższa to 1. Kiedy f1-score jest równy 1, oznacza to, że wszystkie klasy zostały poprawnie przewidziane – jest to bardzo trudny wynik do uzyskania na rzeczywistych danych (wyjątki prawie zawsze istnieją).

$$
tekst{f1-score} = 2* frac{tekst{precyzja} * tekst{przypomnij}}{tekst{precyzja} + tekst{przypomnij}}
$$

4. Macierz zamieszania: kiedy musimy wiedzieć, ile próbek otrzymaliśmy dobrze lub źle kazda klasa. Wartości, które były poprawne i poprawnie przewidziane, nazywane są prawdziwe pozytywy, nazywane są te, które były przewidywane jako dodatnie, ale nie były dodatnie fałszywe alarmy. Ta sama nomenklatura prawdziwe negatywy i fałszywe negatywy służy do wartości ujemnych;

5. Dokładność: opisuje, ile przewidywań nasz klasyfikator wykonał poprawnie. Najniższa wartość dokładności wynosi 0, a najwyższa 1. Ta wartość jest zwykle mnożona przez 100, aby uzyskać wartość procentową:

$$
dokładność = frac{tekst{liczba poprawnych prognoz}}{tekst{całkowita liczba prognoz}}
$$

Możesz wykonać następujący skrypt, aby zaimportować niezbędne biblioteki i spojrzeć na wyniki:

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk)')

print(classification_report(y_test,y_pred))

Wynik będzie wyglądał mniej więcej tak:

                precision    recall  f1-score   support

           0       0.53      0.89      0.66        80
           1       0.57      0.17      0.26        76
           2       0.74      0.72      0.73        47

    accuracy                           0.58       203
   macro avg       0.61      0.59      0.55       203
weighted avg       0.59      0.58      0.53       203

W raporcie klasyfikacyjnym zauważ, że powtarzalność jest wysoka, 0.89 dla klasy 0, zarówno precyzja, jak i powtarzalność są wysokie dla klasy 2, 0.74, 0.72 – a dla klasy 1 są one niskie, zwłaszcza powtarzalność 0.17 i precyzja 0.57 . Zależność między wycofaniem a precyzją dla wszystkich trzech klas z osobna jest ujęta w pliku F1 wynik, który jest średnią harmoniczną między pamięcią a precyzją – robi model w porządku jak na klasę 0, dość źle jak na klasę 1 i nieźle jak na klasę 2.

Model ma bardzo duże trudności z identyfikacją przypadki średniego ryzyka.

Dokładność osiągnięta przez nasz losowy klasyfikator lasów z zaledwie 3 drzewami wynosi 0.58 (58%) – oznacza to, że nieco ponad połowa wyników jest prawidłowa. Jest to niska dokładność i być może można ją poprawić, dodając więcej drzew.

Patrząc na macierz nieporozumień, możemy zobaczyć, że większość błędów występuje przy klasyfikowaniu 52 rekordów średniego ryzyka jako niskiego ryzyka, co daje dalszy wgląd w niski poziom przypominalności klasy 1. Jest on obciążony w kierunku klasyfikowania pacjentów średniego ryzyka jako pacjentów niskiego ryzyka. ryzykownych pacjentów.

Kolejną rzeczą, którą można sprawdzić, aby uzyskać jeszcze lepszy wgląd, jest to, jakie cechy są najczęściej brane pod uwagę przez klasyfikator podczas przewidywania. To ważny krok do podjęcia wytłumaczalne systemy uczenia maszynowegooraz pomaga identyfikować i łagodzić błędy w modelach.

Aby to zobaczyć, możemy uzyskać dostęp do feature_importances_ właściwość klasyfikatora. To da nam listę procentów, dzięki czemu możemy również uzyskać dostęp do feature_names_in_ właściwość, aby uzyskać nazwę każdej funkcji, ułożyć je w ramce danych, posortować od najwyższej do najniższej i wykreślić wynik:

features_df = pd.DataFrame({'features': rfc.feature_names_in_, 'importances': rfc.feature_importances_ })


features_df_sorted = features_df.sort_values(by='importances', ascending=False)


g = sns.barplot(data=features_df_sorted, x='importances', y ='features', palette="rocket")
sns.despine(bottom = True, left = True)
g.set_title('Feature importances')
g.set(xlabel=None)
g.set(ylabel=None)
g.set(xticks=[])
for value in g.containers:
    g.bar_label(value, padding=2)

Zwróć uwagę, jak klasyfikator bierze pod uwagę głównie cukier we krwi, następnie trochę ciśnienia rozkurczowego, temperatury ciała i trochę wieku, aby podjąć decyzję, może to mieć również związek z niską pamięcią w klasie 1, być może dane o średnim ryzyku mają związek z cechami, które nie są brany pod uwagę przez model. Możesz spróbować bardziej poeksperymentować z ważnością funkcji, aby to zbadać i sprawdzić, czy zmiany w modelu wpływają na używane funkcje, a także czy istnieje znaczący związek między niektórymi funkcjami a przewidywanymi klasami.

W końcu nadszedł czas, aby wygenerować nowy model z większą liczbą drzew, aby zobaczyć, jak wpłynie to na wyniki. Stwórzmy rfc_ las z 900 drzewami, 8 poziomami i tym samym nasieniem. Czy wyniki się poprawią?

rfc_ = RandomForestClassifier(n_estimators=900, 
                             max_depth=7,
                             random_state=SEED)
rfc_.fit(X_train, y_train)
y_pred = rfc_.predict(X_test)

Obliczanie i wyświetlanie metryk:

cm_ = confusion_matrix(y_test, y_pred)
sns.heatmap(cm_, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk) for 900 trees with 8 levels')

print(classification_report(y_test,y_pred))

To daje:

                precision    recall  f1-score   support

           0       0.68      0.86      0.76        80
           1       0.75      0.58      0.65        76
           2       0.90      0.81      0.85        47

    accuracy                           0.74       203
   macro avg       0.78      0.75      0.75       203
weighted avg       0.76      0.74      0.74       203

To pokazuje, jak dodanie większej liczby drzew i bardziej wyspecjalizowanych drzew (wyższych poziomów) poprawiło nasze wskaźniki. Nadal mamy niską pamięć dla klasy 1, ale dokładność wynosi teraz 74%. Wynik F1 przy klasyfikowaniu przypadków wysokiego ryzyka wynosi 0.85, co oznacza, że ​​przypadki wysokiego ryzyka są teraz łatwiej identyfikowane w porównaniu do 0.73 w poprzednim modelu!

W codziennym projekcie ważniejsza może być identyfikacja przypadków wysokiego ryzyka, na przykład za pomocą metryki podobnej do precyzji, która jest również znana jako wrażliwość w statystykach. Spróbuj dostosować niektóre parametry modelu i obserwuj wyniki.

Do tej pory uzyskaliśmy ogólne zrozumienie, w jaki sposób Random Forest może być używany do klasyfikowania danych – w następnej sekcji możemy użyć tego samego zestawu danych w inny sposób, aby zobaczyć, jak ten sam model przewiduje wartości z regresją.

Używanie lasów losowych do regresji

W tej sekcji zbadamy, w jaki sposób można użyć algorytmu losowego lasu do rozwiązywania problemów z regresją za pomocą Scikit-Learn. Kroki wykonane w celu wdrożenia tego algorytmu są prawie identyczne z krokami wykonanymi w celu klasyfikacji, poza typem modelu i typem przewidywanych danych – które będą teraz wartościami ciągłymi – istnieje tylko jedna różnica w przygotowaniu danych.

Ponieważ regresja jest wykonywana wartości liczbowe – wybierzmy wartość liczbową ze zbioru danych. Widzieliśmy, że poziom cukru we krwi był ważny w klasyfikacji, więc powinien być przewidywalny na podstawie innych cech (ponieważ jeśli koreluje z jakąś cechą, ta cecha również z nią koreluje).

Po tym, co zrobiliśmy dla klasyfikacji, najpierw zaimportujmy biblioteki i ten sam zestaw danych. Jeśli już to zrobiłeś dla modelu klasyfikacji, możesz pominąć tę część i przejść bezpośrednio do przygotowywania danych do trenowania.

Importowanie bibliotek i danych

import pandas as pd
import numpy as np
import maplotlib.pyplot as plt
import seaborn as sns

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

Wstępne przetwarzanie danych na potrzeby regresji

Jest to zadanie regresji, więc zamiast przewidywać klasy, możemy przewidzieć jedną z liczbowych kolumn zbioru danych. W tym przykładzie BS kolumna będzie przewidywana. To oznacza y dane będą zawierać dane dotyczące cukru we krwi, X dane będą zawierać wszystkie cechy poza poziomem cukru we krwi. Po oddzieleniu X i y danych, możemy podzielić zestawy pociągów i testów:

from sklearn.model_selection import train_test_split

SEED = 42

y = dataset['BS']
X = dataset.drop(['BS'], axis=1) 

X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

Szkolenie RandomForestRegressor

Teraz, gdy przeskalowaliśmy nasz zbiór danych, nadszedł czas, aby wytrenować nasz algorytm, aby rozwiązał ten problem regresji, aby go trochę zmienić – stworzymy model z 20 drzewami w lesie, a każde z nich ma 4 poziomy. Aby to zrobić, możesz wykonać następujący kod:

from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor(n_estimators=20, 
                            max_depth=3, 
                            random_state=SEED)

rfr.fit(X_train, y_train)
y_pred = rfr.predict(X_test)

Możesz znaleźć szczegółowe informacje o wszystkich parametrach RandomForestRegressor w oficjalnej dokumentacji.

Ponieważ wykreślenie i przejrzenie 20 drzew wymagałoby trochę czasu i poświęcenia, możemy wykreślić tylko pierwsze, aby zobaczyć, czym różni się ono od drzewa klasyfikacyjnego:

from sklearn import tree

features = X.columns

first_tree = rfr.estimators_[0]

plt.figure(figsize=(15,6))
tree.plot_tree(first_tree,
               feature_names=features,
               fontsize=8, 
               filled=True, 
               rounded=True);

Zauważ, że drzewo regresji ma już przypisaną wartość do danych przypadającą na każdy węzeł. Są to wartości, które zostaną uśrednione podczas łączenia 20 drzew. Po tym, co zrobiliśmy z klasyfikacją, możesz również wykreślić znaczenie funkcji, aby zobaczyć, które zmienne model regresji bierze bardziej pod uwagę podczas obliczania wartości.

Nadszedł czas, aby przejść do ostatniego i ostatniego kroku podczas rozwiązywania problemu uczenia maszynowego i oceny wydajności algorytmu!

Ocena RandomForestRegressor

W przypadku problemów z regresją metrykami używanymi do oceny algorytmu są średni błąd bezwzględny (MAE), błąd średniokwadratowy (MSE) i pierwiastek błędu średniokwadratowego (RMSE).

1. Średni błąd bezwzględny (MAE): kiedy odejmiemy przewidywane wartości od rzeczywistych wartości, uzyskując błędy, zsumuj wartości bezwzględne tych błędów i uzyskaj ich średnią. Ta metryka daje wyobrażenie o całkowitym błędzie dla każdej prognozy modelu, im mniejszy (bliższy 0), tym lepszy.

$$
mae = (frac{1}{n})sum_{i=1}^{n}w lewo | Rzeczywiste – Przewidywane prawo |
$$

2. Błąd średniokwadratowy (MSE): jest podobny do metryki MAE, ale podnosi do kwadratu wartości bezwzględne błędów. Również, podobnie jak w przypadku MAE, im mniejsza lub bliższa 0, tym lepiej. Wartość MSE jest podnoszona do kwadratu, aby duże błędy były jeszcze większe. Jedną rzeczą, na którą należy zwrócić szczególną uwagę, jest to, że zwykle jest to trudna miara do interpretacji ze względu na rozmiar jej wartości i fakt, że nie mieszczą się one w tej samej skali danych.

$$
mse = suma_{i=1}^{D}(Rzeczywiste – Przewidywane)^2
$$

3. Pierwiastek błędu średniokwadratowego (RMSE): próbuje rozwiązać problem interpretacji związany z MSE, uzyskując pierwiastek kwadratowy z jego końcowej wartości, aby przeskalować go z powrotem do tych samych jednostek danych. Łatwiej jest interpretować i dobrze, gdy musimy wyświetlić lub pokazać rzeczywistą wartość danych z błędem. Pokazuje, jak bardzo dane mogą się różnić, więc jeśli mamy RMSE równy 4.35, nasz model może popełnić błąd, ponieważ albo dodał 4.35 do rzeczywistej wartości, albo potrzebował 4.35, aby uzyskać rzeczywistą wartość. Im bliżej 0, tym lepiej.

$$
rmse = sqrt{ sum_{i=1}^{D}(Rzeczywiste – Przewidywane)^2}
$$

Możemy użyć dowolnego z tych trzech wskaźników, aby porównać modele (jeśli musimy wybrać jeden). Możemy również porównać ten sam model regresji z różnymi wartościami argumentów lub z różnymi danymi, a następnie rozważyć metryki oceny. Jest to znane jako strojenie hiperparametrów – strojenie hiperparametrów wpływających na algorytm uczenia i obserwację wyników.

Przy wyborze pomiędzy modelami te z najmniejszymi błędami zazwyczaj lepiej sobie radzą. Podczas monitorowania modeli, jeśli metryki się pogorszyły, oznaczało to, że poprzednia wersja modelu była lepsza lub wystąpiły znaczące zmiany w danych, aby model działał gorzej niż działał.

Możesz użyć następującego kodu, aby znaleźć te wartości:

from sklearn.metrics import mean_absolute_error, mean_squared_error

print('Mean Absolute Error:', mean_absolute_error(y_test, y_pred))
print('Mean Squared Error:', mean_squared_error(y_test, y_pred))
print('Root Mean Squared Error:', np.sqrt(mean_squared_error(y_test, y_pred)))

Dane wyjściowe powinny być:

Mean Absolute Error: 1.127893702896059
Mean Squared Error: 3.0802988503933326
Root Mean Squared Error: 1.755078018320933

Przy 20 drzewach średni błąd kwadratowy pierwiastka wynosi 1.75, co jest wartością niską, ale mimo to – zwiększając liczbę drzew i eksperymentując z innymi parametrami, błąd ten prawdopodobnie mógłby być jeszcze mniejszy.

Zalety korzystania z Random Forest

Jak w przypadku każdego algorytmu, korzystanie z niego ma zalety i wady. W następnych dwóch sekcjach przyjrzymy się zaletom i wadom używania lasu losowego do klasyfikacji i regresji.

1. Algorytm losowego lasu nie jest obciążony, ponieważ istnieje wiele drzew, a każde drzewo jest uczone na losowym podzbiorze danych. Zasadniczo algorytm losowego lasu opiera się na potędze „tłumu”; dlatego ogólny stopień błędu algorytmu jest zmniejszony.
2. Algorytm ten jest bardzo stabilny. Nawet jeśli nowy punkt danych zostanie wprowadzony do zbioru danych, ogólny algorytm nie ulegnie znacznej zmianie, ponieważ nowe dane mogą mieć wpływ na jedno drzewo, ale bardzo trudno jest wpłynąć na wszystkie drzewa.
3. Algorytm losowego lasu działa dobrze, gdy masz zarówno cechy jakościowe, jak i liczbowe.
4. Algorytm lasu losowego sprawdza się również wtedy, gdy w danych brakuje wartości lub nie zostały one przeskalowane.

Wady korzystania z losowego lasu

1. Główną wadą losowych lasów jest ich złożoność. Wymagają znacznie większych zasobów obliczeniowych ze względu na dużą liczbę połączonych ze sobą drzew decyzyjnych podczas uczenia dużych zespołów. Chociaż – przy nowoczesnym sprzęcie wytrenowanie nawet dużego losowego lasu nie zajmuje dużo czasu.

Idąc dalej — ręczny kompleksowy projekt

Twoja dociekliwość sprawia, że ​​chcesz iść dalej? Zalecamy sprawdzenie naszego Projekt z przewodnikiem: „Praktyczne przewidywanie cen domów — uczenie maszynowe w Pythonie”.

W tym projekcie z przewodnikiem dowiesz się, jak budować zaawansowane modele tradycyjnego uczenia maszynowego, a także modele uczenia głębokiego, wykorzystywać Ensemble Learning i szkolić metauczących się, aby przewidywać ceny domów z zestawu modeli Scikit-Learn i Keras.

Korzystając z Keras, interfejsu API do uczenia głębokiego zbudowanego na bazie Tensorflow, będziemy eksperymentować z architekturami, budować zestaw modeli ułożonych w stos i szkolić metauczeń sieć neuronowa (model poziomu 1), aby ustalić wycenę domu.

Głębokie uczenie jest niesamowite – ale zanim się do niego zastosuje, warto również spróbować rozwiązać problem za pomocą prostszych technik, takich jak płytkie uczenie się algorytmy. Nasza wyjściowa wydajność będzie oparta na Regresja losowego lasu algorytm. Dodatkowo – będziemy badać tworzenie zestawów modeli poprzez Scikit-Learn za pomocą technik takich jak parcianka i głosowanie.

Jest to projekt typu end-to-end i tak jak wszystkie projekty uczenia maszynowego, zaczniemy od – od Analiza danych rozpoznawczych, śledzony przez Wstępne przetwarzanie danych i w końcu Budowanie płytkie i Modele głębokiego uczenia aby dopasować dane, które wcześniej zbadaliśmy i oczyściliśmy.