Definitiver Leitfaden zum Random Forest-Algorithmus mit Python und Scikit-Learn

Einleitung

Der Random-Forest-Algorithmus ist einer der flexibelsten, leistungsstärksten und am weitesten verbreiteten Algorithmen für Klassifikation und Regression, gebaut als Ensemble von Entscheidungsbäumen.

Wenn Sie damit nicht vertraut sind – keine Sorge, wir werden alle diese Konzepte behandeln.

In diesem ausführlichen praktischen Leitfaden erstellen wir eine Intuition über die Funktionsweise von Entscheidungsbäumen, wie Ensembling einzelne Klassifikatoren und Regressoren verstärkt, was Random Forests sind und wie man einen Random Forest Klassifikator und Regressor mit Python und Scikit-Learn durch ein End-to-End-Miniprojekt erstellt und eine Forschungsfrage beantwortet.

Stellen Sie sich vor, Sie sind derzeit Teil einer Forschungsgruppe, die Daten über Frauen analysiert. Die Gruppe hat 100 Datensätze gesammelt und möchte in der Lage sein, diese ersten Datensätze zu organisieren, indem sie die Frauen in Kategorien einteilt: schwanger oder nicht schwanger und in ländlichen oder städtischen Gebieten lebend. Die Forscher wollen verstehen, wie viele Frauen in jeder Kategorie wären.

Es gibt eine Rechenstruktur, die genau das tut, nämlich die Baum Struktur. Durch die Verwendung einer Baumstruktur können Sie die verschiedenen Abteilungen für jede Kategorie darstellen.

Entscheidungsbäume

Wie füllt man die Knoten eines Baums? Das ist wo Entscheidungsbäume in den Fokus kommen.

Zuerst können wir die Aufzeichnungen nach Schwangerschaft unterteilen, danach können wir sie nach dem Leben in städtischen oder ländlichen Gebieten unterteilen. Beachten Sie, dass wir dies in einer anderen Reihenfolge tun könnten, indem wir zunächst nach dem Wohnort der Frauen und danach nach ihrem Schwangerschaftsstatus unterteilen. Daraus können wir erkennen, dass der Baum eine inhärente Hierarchie hat. Neben der Organisation von Informationen organisiert ein Baum Informationen hierarchisch – die Reihenfolge, in der die Informationen angezeigt werden, ist von Bedeutung und führt als Ergebnis zu verschiedenen Bäumen.

Unten ist ein Beispiel für den Baum, der beschrieben wurde:

In dem Baumbild gibt es 7 Quadrate, das oberste Quadrat stellt die Gesamtzahl von 100 Frauen dar, dieses obere Quadrat ist mit zwei Quadraten darunter verbunden, die die Frauen nach ihrer Anzahl von 78 nicht schwangeren und 22 schwangeren teilen, und von den beiden vorherigen Quadraten gibt es vier Quadrate; zwei verbunden mit jedem Quadrat darüber, die die Frauen nach ihrer Gegend teilen, für die Nichtschwangeren leben 45 in einem städtischen Gebiet, 33 in einem ländlichen Gebiet und für die Schwangeren leben 14 in einem ländlichen Gebiet und 8 in einem städtischen Gebiet. Wenn man sich nur den Baum ansieht, ist es leicht, diese Unterteilungen zu verstehen und zu sehen, wie jede „Schicht“ von den vorherigen abgeleitet ist, diese Schichten sind der Baum Cholesterinspiegel , die Ebenen beschreiben die Tiefe des Baumes:

Beachten Sie im Bild oben, dass die erste Baumebene ist Level 0 wo es nur ein Quadrat gibt, gefolgt von Level 1 wo es zwei Quadrate gibt, und Level 2 wo es vier Quadrate gibt. Das ist ein Tiefe 2 Baum.

In Ebene 0 wird das Quadrat, aus dem der Baum stammt, das erste, genannt Wurzelknoten, diese Wurzel hat zwei untergeordnete Knoten in Stufe 1, das sind übergeordnete Knoten zu den vier Knoten in Ebene 2. Sehen Sie, dass die „Quadrate“, die wir bisher erwähnt haben, tatsächlich aufgerufen werden Fiber Node; und dass jeder vorherige Knoten ein Elternteil der folgenden Knoten ist, die seine Kinder sind. Die untergeordneten Knoten jeder Ebene, die denselben übergeordneten Knoten haben, werden aufgerufen Geschwister, wie im nächsten Bild zu sehen ist:

Im vorherigen Bild zeigen wir die Ebene 1 auch als die an innere Knoten, sobald sie sich zwischen der Wurzel und den letzten Knoten befinden, die die sind Blattknoten. Die Blattknoten sind der letzte Teil eines Baumes, wenn wir von den 100 anfänglichen Frauen sagen würden, wie viele schwanger sind und in ländlichen Gebieten leben, könnten wir dies tun, indem wir uns die Blätter ansehen. Die Zahl an den Blättern würde also die erste Forschungsfrage beantworten.

Wenn es neue Aufzeichnungen von Frauen gäbe und der Baum, der zuvor verwendet wurde, um sie zu kategorisieren, jetzt verwendet würde, um zu entscheiden, ob eine Frau Teil der Forschung sein könnte oder nicht, würde er dann noch funktionieren? Der Baum würde die gleichen Kriterien verwenden, und eine Frau wäre zur Teilnahme berechtigt, wenn sie schwanger ist und in einer ländlichen Gegend lebt.

Wenn wir uns das obige Bild ansehen, können wir sehen, dass die Antworten auf die Fragen jedes Baumknotens – „ist sie eine Teilnehmerin?“, „ist sie schwanger?“, „lebt sie in einer ländlichen Gegend?“ – ja sind, Ja, und ja, also scheint der Baum in diesem Fall durchaus zu einer Entscheidung führen zu können, dass die Frau an der Forschung teilnehmen könnte.

Dies ist die Essenz von Entscheidungsbäumen in manueller Weise. Mithilfe von maschinellem Lernen können wir ein Modell erstellen, das diesen Baum automatisch für uns erstellt, um die Genauigkeit der endgültigen Entscheidungen zu maximieren.

Beobachten Sie in den vorherigen Beispielen, wie der Baum beides könnte klassifizieren neue Daten als Teilnehmer oder Nichtteilnehmer, oder die Fragen könnten auch geändert werden in – „Wie viele sind Teilnehmer?“, „Wie viele sind schwanger?“, „Wie viele leben in einer ländlichen Gegend?“ – was uns dazu bringt, die zu finden Menge von schwangeren Teilnehmern, die in einem ländlichen Gebiet leben.

Wenn die Daten klassifiziert werden, bedeutet dies, dass der Baum a ausführt Einstufung Aufgabe, und wenn die Datenmenge gefunden ist, führt der Baum eine aus Regression Aufgabe. Das bedeutet, dass der Entscheidungsbaum für beide Aufgaben – Klassifikation und Regression – verwendet werden kann.

Nachdem wir nun verstanden haben, was ein Entscheidungsbaum ist, wie er verwendet werden kann und welche Nomenklatur verwendet wird, um ihn zu beschreiben, können wir uns über seine Grenzen Gedanken machen.

Random Forests verstehen

Was passiert mit der Entscheidung, wenn ein Teilnehmer an der Trennung zwischen Stadt und Land lebt? Würde der Baum diesen Rekord zu ländlichen oder städtischen hinzufügen? Es scheint schwierig, diese Daten in die Struktur einzufügen, die wir derzeit haben, da sie ziemlich eindeutig ist.

Und was wäre, wenn eine Frau, die auf einem Boot lebt, an der Forschung teilnimmt, würde es als ländlich oder städtisch betrachtet? Genauso wie im vorherigen Fall ist es ein herausfordernder Datenpunkt, den Datenpunkt unter Berücksichtigung der verfügbaren Optionen im Baum zu klassifizieren.

Wenn wir ein bisschen mehr über das Beispiel des Entscheidungsbaums nachdenken, können wir sehen, dass es neue Daten korrekt klassifizieren kann, wenn man bedenkt, dass sie bereits einem Muster folgen, das der Baum bereits hat – aber wenn es Datensätze gibt, die sich von den ursprünglichen Daten unterscheiden, die den Baum definiert haben, die Die Baumstruktur ist zu starr, wodurch die Datensätze nicht klassifizierbar sind.

Das bedeutet, dass der Entscheidungsbaum streng und in seinen Möglichkeiten begrenzt sein kann. Ein idealer Entscheidungsbaum wäre flexibler und in der Lage, nuanciertere, unsichtbare Daten aufzunehmen.

Was die Antwort auf die Eingangsfrage angeht, wissen wir bereits, dass sie in den Baumblättern kodiert sein wird – aber was ändert sich, wenn wir viele Bäume statt nur einen haben?

Wenn die Bäume für eine Klassifizierung kombiniert werden, wird das Ergebnis durch die Mehrheit der Antworten definiert, heißt dies Mehrheitsabstimmung; und im Fall einer Regression wird die Zahl, die von jedem Baum im Wald gegeben wird, sein gemittelt.

Ensemble-Lernen und Modell-Ensembles

Diese Methode ist bekannt als ensemble lernen. Wenn Sie Ensemble-Lernen verwenden, können Sie beliebige Algorithmen miteinander mischen, solange Sie sicherstellen können, dass die Ausgabe analysiert und mit anderen Ausgaben kombiniert werden kann (entweder manuell oder mithilfe vorhandener Bibliotheken). In der Regel fassen Sie mehrere Modelle desselben Typs zusammen, z. B. mehrere Entscheidungsbäume, aber Sie sind nicht darauf beschränkt, nur Ensembles desselben Modelltyps zusammenzuführen.

Ensembling ist ein praktisch garantierter Weg, um ein Problem besser zu verallgemeinern und einen leichten Leistungsschub herauszuholen. In einigen Fällen ergibt das Ensembling von Modellen a signifikant Erhöhung der Vorhersagekraft, und manchmal nur geringfügig. Dies hängt von dem Datensatz ab, mit dem Sie trainieren und evaluieren, sowie von den Modellen selbst.

Das Verbinden von Entscheidungsbäumen ergibt Ergebnisse signifikant Leistungssteigerungen im Vergleich zu einzelnen Bäumen. Dieser Ansatz wurde in den Gemeinschaften für Forschung und angewandtes maschinelles Lernen populär gemacht und war so verbreitet, dass das Ensemble von Entscheidungsbäumen umgangssprachlich a genannt wurde Wald, und die allgemeine Art von Gesamtstruktur, die erstellt wurde (eine Gesamtstruktur von Entscheidungsbäumen auf einer zufälligen Teilmenge von Merkmalen), machte den Namen populär zufällige Wälder.

Angesichts der weit verbreiteten Verwendung haben Bibliotheken wie Scikit-Learn Wrapper für implementiert RandomForestRegressors und RandomForestClassifiers, die auf ihren eigenen Entscheidungsbaumimplementierungen aufbauen, um es Forschern zu ermöglichen, den Aufbau ihrer eigenen Ensembles zu vermeiden.

Lass uns in zufällige Wälder eintauchen!

Wie funktioniert der Random-Forest-Algorithmus?

Im Folgenden sind die grundlegenden Schritte aufgeführt, die beim Ausführen des Random-Forest-Algorithmus erforderlich sind:

1. Wählen Sie eine Reihe zufälliger Datensätze aus, es kann eine beliebige Zahl sein, z. B. 4, 20, 76, 150 oder sogar 2.000 aus dem Datensatz (genannt N Aufzeichnungen). Die Anzahl hängt von der Breite des Datensatzes ab, je breiter, desto größer N kann sein. Hier ist die zufällig Teil des Namens des Algorithmus stammt!
2. Erstellen Sie auf dieser Grundlage einen Entscheidungsbaum N zufällige Aufzeichnungen;
3. Wiederholen Sie die Schritte 1 und 2 entsprechend der für den Algorithmus definierten Anzahl von Bäumen oder der Anzahl von Bäumen im Wald. Dies erzeugt weitere Bäume aus Sätzen von zufälligen Datensätzen;
4. Nach Schritt 3 kommt der letzte Schritt, der die Ergebnisse vorhersagt:
   • Im Falle einer Klassifizierung: Jeder Baum im Wald sagt die Kategorie voraus, zu der der neue Datensatz gehört. Danach wird der neue Rekord der Kategorie zugeordnet, die die Mehrheit gewinnt.
   • Im Falle einer Regression: Jeder Baum im Wald sagt einen Wert für den neuen Datensatz voraus, und der endgültige Vorhersagewert wird berechnet, indem ein Durchschnitt aller Werte genommen wird, die von allen Bäumen im Wald vorhergesagt wurden.

Jeder Baum, der an eine zufällige Teilmenge von Merkmalen angepasst ist, hat notwendigerweise keine Kenntnis von einigen anderen Merkmalen, was durch Zusammenstellung korrigiert wird, während die Rechenkosten niedriger gehalten werden.

Mit einer Intuition, wie Bäume funktionieren, und einem Verständnis von Random Forests – das Einzige, was übrig bleibt, ist das Üben, sie anhand von Daten zu bauen, zu trainieren und abzustimmen!

Erstellen und Trainieren von Random-Forest-Modellen mit Scikit-Learn

Es gab einen Grund dafür, dass die bisher verwendeten Beispiele Schwangerschaft, Wohnbereich und Frauen betreffen.

Im Jahr 2020 stellten Forscher aus Bangladesch fest, dass die Sterblichkeit unter schwangeren Frauen immer noch sehr hoch war, insbesondere wenn man bedenkt, dass sie in ländlichen Gebieten leben. Aus diesem Grund verwendeten sie ein IOT-Überwachungssystem Analysieren Sie das Risiko für die Gesundheit der Mutter. Das IOT-System sammelte Daten von verschiedenen Krankenhäusern, Gemeindekliniken und Müttergesundheitseinrichtungen aus den ländlichen Gebieten von Bangladesch.

Die gesammelten Daten wurden dann in einer Datei mit kommagetrennten Werten (csv) organisiert und hochgeladen UCIs Repository für maschinelles Lernen.

Dies sind die Daten, die wir verwenden werden, um zu üben und zu verstehen, ob eine schwangere Frau eine hat niedrig, mittlere or Highs Sterblichkeitsrisiko.

Verwenden von Random Forest für die Klassifizierung

Da wollen wir wissen, ob Frau einen hat niedrig, mittlere or Highs Sterblichkeitsrisiko, d. h. wir führen eine Einteilung mit drei Klassen durch. Wenn ein Problem mehr als zwei Klassen hat, wird es als a bezeichnet Multiklasse Problem, im Gegensatz zu a binär Problem (wo Sie normalerweise zwischen zwei Klassen wählen 0 und 1).

In diesem ersten Beispiel implementieren wir ein Mehrklassen-Klassifizierungsmodell mit einem Random Forest-Klassifikator und Scikit-Learn von Python.

Wir werden die üblichen Schritte des maschinellen Lernens befolgen, um dieses Problem zu lösen, nämlich das Laden von Bibliotheken, das Lesen der Daten, das Betrachten von zusammenfassenden Statistiken und das Erstellen von Datenvisualisierungen, um es besser zu verstehen. Anschließend erfolgt die Vorverarbeitung und Aufteilung der Daten, gefolgt von der Generierung, dem Training und der Bewertung eines Modells.

Bibliotheken importieren

Wir werden Pandas verwenden, um die Daten zu lesen, Seaborn und Matplotlib, um sie zu visualisieren, und NumPy für die großartigen Hilfsmethoden:

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

Importieren des Datensatzes

Der folgende Code importiert das Dataset und lädt es in eine Python DataFrame:

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

Um die ersten fünf Zeilen der Daten anzusehen, führen wir die aus head() Befehl:

dataset.head()

Dies gibt aus:

    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

Hier sehen wir alle Attribute, die während der Recherche gesammelt wurden.

• Alter: Alter in Jahren.
• Systolischer Blutdruck: oberer Wert des Blutdrucks in mmHg, ein wichtiges Attribut während der Schwangerschaft.
• Diastolischer Blutdruck: niedrigerer Blutdruckwert in mmHg, ein weiteres wichtiges Attribut während der Schwangerschaft.
• BS: Blutglukosespiegel als molare Konzentration, mmol/L.
• Herzfrequenz: Ruhepuls in Schlägen pro Minute.
• RiskLevel: Risikostufe während der Schwangerschaft.
• BodyTemp: die Körpertemperatur.

Jetzt, da wir mehr darüber wissen, was gemessen wird, können wir uns die Datentypen ansehen info():

dataset.info()

Das führt zu:

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

Vom Anschauen der RangeIndex Zeile können wir sehen, dass es 1014 Datensätze gibt, und die Spalte Non-Null Count informiert, dass die Daten keine fehlenden Werte aufweisen. Das bedeutet, dass wir keine Behandlung fehlender Daten vornehmen müssen!

Im Dtype Spalte können wir den Typ jeder Variablen sehen. Zur Zeit, float64 Spalten wie BS und BodyTemp haben numerische Werte, die in jedem Bereich variieren können, wie z. B. 15.0, 15.51, 15.76, 17.28, wodurch sie numerisch stetig (Sie können immer eine 0 zu einer Fließkommazahl addieren, ad infinitem). Andererseits sind Variablen wie z Age, SystolicBP, DiastolicBP und HeartRate sind vom Typ int64, das bedeutet, dass sich die Zahlen nur um die Einheit ändern, wie 11, 12, 13, 14 – wir haben keine Herzfrequenz von 77.78, es ist entweder 77 oder 78 – das sind numerisch diskret Werte. Und das haben wir auch RiskLevel mit object Typ, zeigt dies normalerweise an, dass die Variable ein Text ist, und wir müssen sie wahrscheinlich in eine Zahl umwandeln. Da das Risikoniveau von niedrig nach hoch anwächst, gibt es eine implizite Reihenfolge in den Kategorien, die darauf hinweist, dass es sich um a handelt kategorisch ordinal variabel.

Nachdem wir uns die Datentypen angesehen haben, können wir verwenden describe() um bei einigen deskriptiven Statistiken einen Höhepunkt zu erreichen, wie z. B. die Mittelwerte jeder Spalte, die Standardabweichung, Quantile, minimale und maximale Datenwerte:

dataset.describe().T 

Der obige Code zeigt:

            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

Beachten Sie, dass für die meisten Spalten die bedeuten Werte sind weit davon entfernt Standardabweichung (std) – dies weist darauf hin, dass die Daten nicht unbedingt einer gut erzogenen statistischen Verteilung folgen. Wenn ja, hätte es dem Modell bei der Vorhersage des Risikos geholfen. Was hier getan werden kann, ist, die Daten vorzuverarbeiten, um sie repräsentativer zu machen, als wären es Daten der gesamten Weltbevölkerung oder mehr normalisierte. Aber ein Vorteil bei der Verwendung von Random-Forest-Modellen für Einstufung, ist, dass die inhärente Baumstruktur gut mit Daten umgehen kann, die nicht normalisiert wurden, sobald sie sie durch den Wert in jeder Baumebene für jede Variable dividiert.

Da wir Bäume verwenden und die resultierende Klasse durch Abstimmung erhalten wird, vergleichen wir nicht grundsätzlich zwischen verschiedenen Werten, sondern nur zwischen denselben Arten von Werten. Daher ist es in diesem Fall nicht erforderlich, die Merkmale auf denselben Maßstab anzupassen . Dies bedeutet, dass das Random Forest-Klassifizierungsmodell ist skaleninvariant, und Sie müssen keine Feature-Skalierung durchführen.

In diesem Fall besteht der Schritt in der Datenvorverarbeitung, den wir unternehmen können, darin, das Kategoriale zu transformieren RiskLevel Spalte in eine numerische Spalte.

Visualisierung der Daten

Vor der Verwandlung RiskLevel, lassen Sie uns die Daten auch schnell visualisieren, indem wir uns die Kombinationen von Punkten für jedes Feature-Paar mit einem Scatterplot ansehen und wie die Punkte verteilt sind, indem wir die Histogrammkurve visualisieren. Dazu verwenden wir Seaborn's pairplot() die beide Grundstücke kombiniert. Es generiert beide Diagramme für jede Merkmalskombination und zeigt die Punkte farbcodiert gemäß ihrer Risikostufe an hue Eigentum:

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); 

Der obige Code generiert:

Beim Betrachten des Diagramms wäre die ideale Situation eine klare Trennung zwischen Kurven und Punkten. Wie wir sehen können, werden die drei Arten von Risikoklassen meistens verwechselt, da Bäume intern Linien ziehen, wenn sie die Abstände zwischen Punkten begrenzen, können wir die Hypothese aufstellen, dass mehr Bäume im Wald möglicherweise mehr Abstände begrenzen und die Punkte besser klassifizieren können.

Nachdem die grundlegende explorative Datenanalyse abgeschlossen ist, können wir die vorverarbeiten RiskLevel Spalte.

Datenvorverarbeitung für die Klassifizierung

Allerdings gibt es nur drei Klassen von RiskLevel in unseren Daten enthalten sind und keine anderen Werte fälschlicherweise hinzugefügt wurden, können wir verwenden unique() So zeigen Sie die eindeutigen Werte der Spalte an:

dataset['RiskLevel'].unique()

Dies gibt aus:

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

Die Klassen werden überprüft, jetzt ist der nächste Schritt, jeden Wert in eine Zahl umzuwandeln. Da es eine Ordnung zwischen den Klassifikationen gibt, können wir die Werte 0, 1 und 2 zur Kennzeichnung verwenden niedrig, mittlere und Highs Risiken. Es gibt viele Möglichkeiten, die Spaltenwerte zu ändern, nach Python einfach ist besser so komplex Motto, wir werden die verwenden .replace() -Methode und ersetzen Sie sie einfach durch ihre ganzzahligen Darstellungen:

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

Nachdem wir die Werte ersetzt haben, können wir die Daten in das unterteilen, was zum Trainieren des Modells verwendet wird, die Funktionen or X, und was wir vorhersagen wollen, die Etiketten or y:

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

Sobald die X und y Sätze fertig sind, können wir die von Scikit-Learn verwenden train_test_split() Methode, um sie weiter in die Trainings- und Testsätze zu unterteilen:

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)

Hier verwenden wir 20 % der Daten für Tests und 80 % für Schulungen.

Trainieren eines RandomForestClassifiers

Scikit-Learn implementierte Ensembles unter der sklearn.ensemble Modul. Als Klassifikation wird ein Ensemble von Entscheidungsbäumen implementiert, bei denen eine Mehrheitsentscheidung getroffen wird RandomForestClassifier.

Wenn wir die Zug- und Testsets haben, können wir die importieren RandomForestClassifier Klasse und erstellen Sie das Modell. Lassen Sie uns zunächst einen Wald mit drei Bäumen erstellen, indem Sie ihn festlegen n_estimators Parameter als 3, und mit jedem Baum mit drei Ebenen, durch Einstellung max_depthzu 2:

from sklearn.ensemble import RandomForestClassifier

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

Um das Modell an die Daten anzupassen – nennen wir die fit() Methode, Einfügen der Trainingsfeatures und Labels:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

Wir können jetzt die vorhergesagten Labels mit den tatsächlichen Labels vergleichen, um zu bewerten, wie gut das Modell abgeschnitten hat! Bevor wir das Modell bewerten, werfen wir einen Blick auf das Ensemble.

Um etwas tiefer in das Modell hineinzuschauen, können wir jeden der Bäume visualisieren und wie sie die Daten aufteilen. Dies kann durch die Verwendung von erfolgen tree Modul, das in Scikit-Learn integriert ist, und dann jeden der Schätzer im Ensemble durchlaufen:

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()

Der obige Code zeigt die Baumdiagramme an:

Beachten Sie, wie unterschiedlich die drei Bäume sind. Der erste beginnt mit der BS Funktion, die zweite mit DiastolicBP, und der dritte mit BS wieder. Obwohl der dritte eine andere Anzahl von Beispielen betrachtet. Auf dem rechten Ast entscheiden die ersten beiden Bäume ebenfalls über Verwendung Age auf Blattebene, während der dritte Baum mit endet BS Besonderheit. Mit nur drei Schätzern ist es klar, wie eine Skalierung eine reichhaltige, vielfältige Darstellung des Wissens ergibt, die erfolgreich in einem hochgenauen Modell zusammengefasst werden kann.

Je mehr Bäume im Wald, desto vielfältiger kann das Modell sein. Es gibt jedoch einen Punkt, an dem die Rendite abnimmt, da es bei vielen Bäumen, die auf eine zufällige Teilmenge von Merkmalen passen, eine ganze Reihe ähnlicher Bäume geben wird, die nicht viel Vielfalt im Ensemble bieten und die beginnen werden, zu haben zu viel Stimmrecht und verzerren Sie das Ensemble so, dass es auf dem Trainingsdatensatz überangepasst ist, was die Verallgemeinerung auf den Validierungssatz beeinträchtigt.

Es wurde früher eine Hypothese darüber aufgestellt, mehr Bäume zu haben und wie dies die Modellergebnisse verbessern könnte. Schauen wir uns die Ergebnisse an, generieren ein neues Modell und sehen, ob die Hypothese hält!

Auswertung des RandomForestClassifier

Scikit-Learn macht es einfach, Baselines zu erstellen, indem es a bereitstellt DummyClassifier, die Vorhersagen ausgibt ohne Verwendung der Eingabefunktionen (völlig zufällige Ausgaben). Wenn Ihr Modell besser ist als die DummyClassifier, einige Lernen findet statt! Um das Lernen zu maximieren, können Sie verschiedene Hyperparameter automatisch testen, indem Sie a verwenden RandomizedSearchCV or GridSearchCV. Neben einer Basislinie können Sie die Leistung Ihres Modells anhand mehrerer Metriken bewerten.

Einige traditionelle Klassifizierungsmetriken, die zur Bewertung des Algorithmus verwendet werden können, sind Genauigkeit, Erinnerung, f1-Wert, Genauigkeit und Konfusionsmatrix. Hier ist eine kurze Erklärung zu jedem von ihnen:

1. Präzision: Wenn es unser Ziel ist zu verstehen, welche korrekten Vorhersagewerte von unserem Klassifikator als richtig angesehen wurden. Precision dividiert diese wahren positiven Werte durch die Proben, die als positiv vorhergesagt wurden;

$$
Genauigkeit = frac{Text{wahre Positive}}{Text{wahre Positive} + Text{falsche Positive}}
$$

2. Erinnern: Wird üblicherweise zusammen mit der Genauigkeit berechnet, um zu verstehen, wie viele der wahren Positiven von unserem Klassifikator identifiziert wurden. Der Rückruf wird berechnet, indem die wahren Positiven durch alles dividiert werden, was als positiv hätte vorhergesagt werden sollen.

$$
Recall = frac{Text{echte Positive}}{Text{echte Positive} + Text{falsche Negative}}
$$

3. F1-Punktzahl: ist das ausgewogene oder harmonische Mittel von Präzision und Rückruf. Der niedrigste Wert ist 0 und der höchste 1. Wann f1-score gleich 1 ist, bedeutet dies, dass alle Klassen korrekt vorhergesagt wurden – dies ist mit echten Daten sehr schwer zu erreichen (Ausnahmen gibt es fast immer).

$$
text{f1-score} = 2* frac{text{precision} * text{recall}}{text{precision} + text{recall}}
$$

4. Verwirrung Matrix: Wenn wir wissen müssen, für wie viele Proben wir richtig oder falsch waren jede Klasse. Die Werte, die richtig waren und korrekt vorhergesagt wurden, werden aufgerufen wahre positive, diejenigen, die als positiv vorhergesagt wurden, aber keine positiven waren, werden aufgerufen Fehlalarm. Dieselbe Nomenklatur von wahre Negative und falsche Negative wird für negative Werte verwendet;

5. Genauigkeit: beschreibt, wie viele Vorhersagen unser Klassifikator richtig gemacht hat. Der niedrigste Genauigkeitswert ist 0 und der höchste 1. Dieser Wert wird normalerweise mit 100 multipliziert, um einen Prozentsatz zu erhalten:

$$
Genauigkeit = frac{Text{Anzahl richtiger Vorhersagen}}{Text{Gesamtzahl der Vorhersagen}}
$$

Sie können das folgende Skript ausführen, um die erforderlichen Bibliotheken zu importieren und die Ergebnisse anzuzeigen:

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))

Die Ausgabe sieht ungefähr so ​​aus:

                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

Beachten Sie im Klassifizierungsbericht, dass der Recall hoch ist, 0.89 für Klasse 0, sowohl die Präzision als auch der Recall hoch sind für Klasse 2, 0.74, 0.72 – und für Klasse 1 sind sie niedrig, insbesondere der Recall von 0.17 und eine Präzision von 0.57 . Die Beziehung zwischen Rückruf und Präzision für alle drei Klassen einzeln ist in erfasst F1 Score, der das harmonische Mittel zwischen Recall und Precision darstellt – das leistet das Model in Ordnung für Klasse 0, ziemlich schlecht für Klasse 1 und anständig für Klasse 2.

Das Modell tut sich sehr schwer bei der Identifizierung Fälle mit mittlerem Risiko.

Die Genauigkeit, die unser Random Forest Classifier mit nur 3 Bäumen erreicht, ist von 0.58 (58 %) – das bedeutet, dass es etwas mehr als die Hälfte der Ergebnisse richtig macht. Dies ist eine geringe Genauigkeit und könnte möglicherweise durch Hinzufügen weiterer Bäume verbessert werden.

Wenn wir uns die Verwirrungsmatrix ansehen, können wir sehen, dass die meisten Fehler bei der Klassifizierung von 52 Aufzeichnungen mit mittlerem Risiko als niedriges Risiko auftreten, was weitere Einblicke in die geringe Erinnerung an Klasse 1 gibt. Risikopatienten.

Eine andere Sache, die überprüft werden kann, um noch mehr Einblick zu gewinnen, ist, welche Merkmale vom Klassifikator bei der Vorhersage am meisten berücksichtigt werden. Dies ist ein wichtiger Schritt für Erklärbare maschinelle Lernsysteme, und hilft, Verzerrungen in Modellen zu erkennen und zu mindern.

Um das zu sehen, können wir auf die zugreifen feature_importances_ Eigenschaft des Klassifikators. Dadurch erhalten wir eine Liste mit Prozentsätzen, auf die wir auch zugreifen können feature_names_in_ -Eigenschaft, um den Namen jedes Features zu erhalten, sie in einem Datenrahmen zu organisieren, sie vom höchsten zum niedrigsten zu sortieren und das Ergebnis zu plotten:

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)

Beachten Sie, wie der Klassifikator hauptsächlich die berücksichtigt Blutzucker, dann ein wenig der diastolische Druck, die Körpertemperatur und nur ein wenig das Alter, um eine Entscheidung zu treffen, dies könnte auch mit der geringen Erinnerung an Klasse 1 zu tun haben, vielleicht haben die mittleren Risikodaten mit Merkmalen zu tun, die nicht vorhanden sind vom Modell stark berücksichtigt. Sie können versuchen, mehr mit Feature-Wichtigkeiten herumzuspielen, um dies zu untersuchen, und sehen, ob sich Änderungen am Modell auf die verwendeten Features auswirken, auch wenn es eine signifikante Beziehung zwischen einigen der Features und den vorhergesagten Klassen gibt.

Es ist endlich an der Zeit, ein neues Modell mit mehr Bäumen zu generieren, um zu sehen, wie sich dies auf die Ergebnisse auswirkt. Lassen Sie uns die erstellen rfc_ Wald mit 900 Bäumen, 8 Ebenen und dem gleichen Samen. Werden sich die Ergebnisse verbessern?

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

Berechnung und Anzeige der Metriken:

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))

Dies gibt aus:

                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

Dies zeigt, wie das Hinzufügen weiterer Bäume und spezialisierterer Bäume (höherer Ebenen) unsere Metriken verbessert hat. Wir haben immer noch einen niedrigen Recall für Klasse 1, aber die Genauigkeit liegt jetzt bei 74 %. Der F1-Score bei der Klassifizierung von Hochrisikofällen liegt bei 0.85, was bedeutet, dass Hochrisikofälle jetzt leichter identifiziert werden können als im vorherigen Modell mit 0.73!

In einem alltäglichen Projekt kann es wichtiger sein, Fälle mit hohem Risiko zu identifizieren, beispielsweise mit einer Metrik ähnlich der Präzision, die auch als Präzision bezeichnet wird Empfindlichkeit in der Statistik. Versuchen Sie, einige der Modellparameter zu optimieren, und beobachten Sie die Ergebnisse.

Bis jetzt haben wir ein allgemeines Verständnis dafür erlangt, wie Random Forest zum Klassifizieren von Daten verwendet werden kann – im nächsten Abschnitt können wir denselben Datensatz auf andere Weise verwenden, um zu sehen, wie dasselbe Modell Werte mit Regression vorhersagt.

Verwenden von Random Forests für die Regression

In diesem Abschnitt werden wir untersuchen, wie ein Random-Forest-Algorithmus verwendet werden kann, um Regressionsprobleme mit Scikit-Learn zu lösen. Die Schritte zur Implementierung dieses Algorithmus sind fast identisch mit den Schritten zur Klassifizierung, abgesehen von der Art des Modells und der Art der vorhergesagten Daten – die jetzt kontinuierliche Werte sein werden – gibt es nur einen Unterschied in der Datenaufbereitung.

Da ist die Regression erledigt Zahlenwerte – Lassen Sie uns einen numerischen Wert aus dem Datensatz auswählen. Wir haben gesehen, dass der Blutzucker bei der Klassifizierung wichtig war, also sollte er basierend auf anderen Merkmalen vorhersagbar sein (denn wenn er mit einem Merkmal korreliert, korreliert dieses Merkmal auch damit).

Nach dem, was wir für die Klassifizierung getan haben, importieren wir zunächst die Bibliotheken und denselben Datensatz. Wenn Sie dies bereits für das Klassifizierungsmodell getan haben, können Sie diesen Teil überspringen und direkt mit der Vorbereitung der Daten für das Training fortfahren.

Bibliotheken und Daten importieren

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")

Datenvorverarbeitung für die Regression

Dies ist eine Regressionsaufgabe, d. h. anstatt Klassen vorherzusagen, können wir eine der numerischen Spalten des Datensatzes vorhersagen. In diesem Beispiel ist die BS Spalte wird vorhergesagt. Dies bedeutet die y Daten enthalten Blutzuckerdaten und X Die Daten enthalten alle Funktionen außer dem Blutzucker. Nach dem Trennen der X und y Daten können wir die Zug- und Testsätze aufteilen:

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)

Trainieren eines RandomForestRegressors

Nachdem wir unseren Datensatz skaliert haben, ist es an der Zeit, unseren Algorithmus zu trainieren, um dieses Regressionsproblem zu lösen, um es ein wenig zu ändern – wir erstellen ein Modell mit 20 Bäumen im Wald und jedem mit 4 Ebenen. Dazu können Sie den folgenden Code ausführen:

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)

Details zu allen Parametern finden Sie unter RandomForestRegressor in der offiziellen Dokumentation.

Da das Zeichnen und Betrachten von 20 Bäumen einige Zeit und Hingabe erfordern würde, können wir nur den ersten zeichnen, um zu sehen, wie er sich vom Klassifizierungsbaum unterscheidet:

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);

Beachten Sie, dass der Regressionsbaum den Daten, die auf jeden Knoten fallen, bereits einen Wert zugewiesen hat. Das sind die Werte, die beim Kombinieren der 20 Bäume gemittelt werden. Nach dem, was wir mit der Klassifizierung gemacht haben, können Sie auch die Wichtigkeit von Merkmalen darstellen, um zu sehen, welche Variablen das Regressionsmodell bei der Berechnung von Werten stärker berücksichtigt.

Es ist an der Zeit, zum letzten und letzten Schritt bei der Lösung eines maschinellen Lernproblems überzugehen und die Leistung des Algorithmus zu bewerten!

Auswerten eines RandomForestRegressor

Bei Regressionsproblemen sind die zur Bewertung eines Algorithmus verwendeten Metriken der mittlere absolute Fehler (MAE), der mittlere quadratische Fehler (MSE) und der mittlere quadratische Fehler (RMSE).

1. Mittlerer absoluter Fehler (MAE): Wenn wir die vorhergesagten Werte von den tatsächlichen Werten subtrahieren, erhalten wir die Fehler, summieren die absoluten Werte dieser Fehler und erhalten ihren Mittelwert. Diese Metrik gibt eine Vorstellung vom Gesamtfehler für jede Vorhersage des Modells, je kleiner (näher an 0), desto besser.

$$
mae = (frac{1}{n})sum_{i=1}^{n}links | Ist – Richtig prognostiziert |
$$

2. Mittlerer quadratischer Fehler (MSE): Es ähnelt der MAE-Metrik, aber es quadriert die absoluten Werte der Fehler. Auch gilt, wie bei MAE, je kleiner oder näher an 0, desto besser. Der MSE-Wert wird quadriert, um große Fehler noch größer zu machen. Eine Sache, auf die Sie besonders achten sollten, ist, dass es aufgrund der Größe seiner Werte und der Tatsache, dass sie nicht im gleichen Maßstab wie die Daten liegen, normalerweise eine schwer zu interpretierende Metrik ist.

$$
mse = sum_{i=1}^{D}(Ist – Vorausgesagt)^2
$$

3. Mittlerer quadratischer Fehler (RMSE): versucht, das mit dem MSE aufgeworfene Interpretationsproblem zu lösen, indem die Quadratwurzel seines Endwerts ermittelt wird, um ihn auf dieselben Einheiten der Daten zurückzuskalieren. Es ist einfacher zu interpretieren und gut, wenn wir den tatsächlichen Wert der Daten mit dem Fehler anzeigen oder anzeigen müssen. Es zeigt, wie stark die Daten variieren können. Wenn wir also einen RMSE von 4.35 haben, kann unser Modell einen Fehler machen, entweder weil es 4.35 zum tatsächlichen Wert hinzugefügt hat oder 4.35 benötigte, um zum tatsächlichen Wert zu gelangen. Je näher an 0, desto besser.

$$
rmse = sqrt{ sum_{i=1}^{D}(tatsächlich – prognostiziert)^2}
$$

Wir können jede dieser drei Metriken verwenden vergleichen Modelle (falls wir eines auswählen müssen). Wir können dasselbe Regressionsmodell auch mit unterschiedlichen Argumentwerten oder mit unterschiedlichen Daten vergleichen und dann die Bewertungsmetriken betrachten. Dies ist bekannt als Hyperparameter-Tuning – Einstellen der Hyperparameter, die einen Lernalgorithmus beeinflussen, und Beobachten der Ergebnisse.

Bei der Auswahl zwischen Modellen schneiden die mit den kleinsten Fehlern in der Regel besser ab. Wenn beim Überwachen von Modellen die Metriken schlechter wurden, war eine frühere Version des Modells besser, oder es gab eine signifikante Änderung in den Daten, sodass das Modell schlechter abschneidet als es war.

Sie können den folgenden Code verwenden, um diese Werte zu finden:

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)))

Die Ausgabe sollte sein:

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

Bei 20 Bäumen beträgt der mittlere quadratische Fehler 1.75, was niedrig ist, aber trotzdem – durch Erhöhen der Anzahl der Bäume und Experimentieren mit den anderen Parametern könnte dieser Fehler wahrscheinlich noch kleiner werden.

Vorteile der Verwendung von Random Forest

Wie bei jedem Algorithmus gibt es Vor- und Nachteile bei der Verwendung. In den nächsten beiden Abschnitten sehen wir uns die Vor- und Nachteile der Verwendung von Random Forest für die Klassifizierung und Regression an.

1. Der Random-Forest-Algorithmus ist nicht voreingenommen, da es mehrere Bäume gibt und jeder Baum auf einer zufälligen Teilmenge von Daten trainiert wird. Grundsätzlich stützt sich der Random-Forest-Algorithmus auf die Macht der „Crowd“; daher wird der Gesamtgrad der Verzerrung des Algorithmus reduziert.
2. Dieser Algorithmus ist sehr stabil. Selbst wenn ein neuer Datenpunkt in den Datensatz eingeführt wird, wird der Gesamtalgorithmus nicht stark beeinflusst, da neue Daten einen Baum beeinflussen können, aber es ist sehr schwierig, alle Bäume zu beeinflussen.
3. Der Random-Forest-Algorithmus funktioniert gut, wenn Sie sowohl kategoriale als auch numerische Merkmale haben.
4. Der Random-Forest-Algorithmus funktioniert auch gut, wenn Daten fehlende Werte aufweisen oder nicht skaliert wurden.

Nachteile der Verwendung von Random Forest

1. Der Hauptnachteil von Random Forests liegt in ihrer Komplexität. Sie erfordern aufgrund der großen Anzahl von miteinander verbundenen Entscheidungsbäumen viel mehr Rechenressourcen, wenn große Ensembles trainiert werden. Allerdings – mit moderner Hardware nimmt das Training selbst eines großen zufälligen Waldes nicht viel Zeit in Anspruch.

Weiter gehen – Handgehaltenes End-to-End-Projekt

Ihre neugierige Natur macht Lust auf mehr? Wir empfehlen Ihnen, sich unsere anzuschauen Geführtes Projekt: „Hauspreisvorhersage zum Anfassen – Maschinelles Lernen in Python“.

In diesem geführten Projekt lernen Sie, wie Sie leistungsstarke traditionelle maschinelle Lernmodelle sowie Deep-Learning-Modelle erstellen, Ensemble Learning verwenden und Meta-Lernende schulen, um Immobilienpreise anhand einer Reihe von Scikit-Learn- und Keras-Modellen vorherzusagen.

Unter Verwendung von Keras, der Deep-Learning-API, die auf Tensorflow aufbaut, experimentieren wir mit Architekturen, bauen ein Ensemble aus gestapelten Modellen auf und trainieren a Meta-Lerner neuronales Netzwerk (Level-1-Modell), um den Preis eines Hauses zu ermitteln.

Deep Learning ist erstaunlich – aber bevor Sie darauf zurückgreifen, sollten Sie auch versuchen, das Problem mit einfacheren Techniken zu lösen, z. B. mit seichtes Lernen Algorithmen. Unsere Basisleistung basiert auf a Random-Forest-Regression Algorithmus. Darüber hinaus untersuchen wir die Erstellung von Ensembles von Modellen durch Scikit-Learn mithilfe von Techniken wie z Absacken und Abstimmung.

Dies ist ein End-to-End-Projekt, und wie alle Machine Learning-Projekte beginnen wir mit – mit Explorative Datenanalyse, Gefolgt von Datenvorverarbeitung und schlussendlich Flach bauen und Deep-Learning-Modelle um die Daten anzupassen, die wir zuvor untersucht und bereinigt haben.