Was sind zufällige Effekte und feste Effekte?

Bei der Gestaltung einer Studie möchten wir häufig unabhängige Variablen von denen isolieren, die kein Interesse haben, ihre wahren Auswirkungen auf die abhängigen Variablen zu beobachten. Angenommen, wir möchten beispielsweise die Auswirkungen der Verwendung von Github Copilot untersuchen (unabhängige Variable) zur Produktivität der Entwickler (abhängige Variable). Ein Ansatz besteht darin, zu messen, wie viel Zeit die Entwickler mit Copilot verbringen und wie schnell sie Codierungsaufgaben erledigen. Auf den ersten Blick können wir eine starke constructive Korrelation beobachten: mehr Kopilotenverbrauch, schnellere Aufgabenabschluss.

Andere Faktoren können jedoch auch beeinflussen, wie schnell Entwickler ihre Arbeit beenden. Zum Beispiel kann Unternehmen A möglicherweise schnellere CI/CD-Pipelines haben oder mit kleineren und einfacheren Aufgaben umgehen, während Unternehmen B möglicherweise lange Codeüberprüfungen benötigen oder komplexere und zeitaufwändigere Aufgaben erledigen. Wenn wir diese organisatorischen Unterschiede nicht berücksichtigen, können wir fälschlicherweise zu dem Schluss kommen, dass Copilot für Entwickler in Unternehmen B weniger effektiv ist, obwohl es die Umgebung ist, nicht die Umgebung, die sie wirklich verlangsamt.

Diese Artwork von Variationen auf Gruppenebene-Unterschiede zwischen Groups, Unternehmen oder Projekten-sind in der Regel als bekannt als “Zufällige Effekte“ oder “Feste Effekte“.

Fixe Effekte sind von interessierende Variablen, wobei jede Gruppe unter Verwendung einer HOT-Codierung separat behandelt wird. Da die Variabilität innerhalb der Gruppen innerhalb jeder Dummy-Variable ordentlich erfasst wird, gehen wir davon aus, dass die Varianz jeder Gruppe ähnlich oder homoskedastisch ist.

.

wo d_1iD_2i,… Sind jeweils Dummy -Variablen, die Gruppe D darstellen_1iD_2i,… Und γ₁, γ₂,… sind für jede entsprechende Gruppe feste Effektkoeffizienten.

Zufällige Effekte hingegen sind typischerweise keine Variablen von Interesse. Wir gehen davon aus, dass jede Gruppe Teil einer breiteren Bevölkerung ist und jeder Gruppeneffekt liegt irgendwo innerhalb einer breiteren Wahrscheinlichkeitsverteilung dieser Bevölkerung. Daher ist die Varianz jeder Gruppe heterogen.

(y_ {ij} = beta_0 + beta_1 x_ {ij} + u_j + varepsilon_ {ij} )

wo du_J ist ein zufälliger Effekt der Gruppe J von Probe I, die aus einer Verteilung entnommen wird, typischerweise eine Normalverteilung 𝒩 (0, σ²ᵤ).

Überdenken sorgfältig feste und zufällige Effekte

Es kann jedoch Ihre Analyse irreführen, wenn Sie diese Effekte zufällig in Ihr Modell einfügen, ohne sorgfältig darüber nachzudenken, welche Arten von Variationen sie tatsächlich erfassen.

Ich habe kürzlich an einer Projektanalyse gearbeitet Umweltauswirkungen von KI -Modellenwas ich untersuchte, wie bestimmte architektonische Funktionen (Anzahl der Parameter, Anzahl der Laptop, Datensatzgröße und Trainingszeit) und Hardwareauswahl ({Hardware} -Typ, Anzahl der {Hardware}) von KI -Modellen den Energieverbrauch während des Trainings beeinflussen. Ich fand das Training_timeAnwesend Hardware_quantityUnd Hardware_type den Energieverbrauch erheblich beeinflusst. Die Beziehung kann grob modelliert werden als:

( textual content {energie} = textual content {training_time} + textual content {hardware_quantity} + textual content {{Hardware}} )

Da ich dachte, es könnte Unterschiede zwischen Organisationen geben, beispielsweise in Bezug Group Da zufällige Effekte dazu beitragen würden, all diese nicht beobachteten potenziellen Unterschiede zu erklären. Um meine Annahme zu testen, habe ich die Ergebnisse von zwei Modellen verglichen: mit und ohne Groupum zu sehen, welches besser passt. In den beiden Modellen die abhängige Variable Power battle extrem rechtsgerichtet, additionally habe ich eine logarithmische Transformation angewendet, um seine Varianz zu stabilisieren. Hier habe ich generalisierte lineare Modelle (GLM) verwendet, da die Verteilung meiner Daten nicht regular battle.

glm <- glm(
  log_Energy ~ Training_time_hour + 
               Hardware_quantity + 
               Training_hardware,
               information = df)
abstract(glm)

glm_random_effects <- glmer(
  log_Energy ~ Training_time_hour + 
               Hardware_quantity + 
               Training_hardware + 
               (1 | Group), // Random results
               information = df)
abstract(glm_random_effects)
AIC(glm_random_effects)

Das GLM -Modell ohne Group produzierte eine AIC von 312,55 mit Training_timeAnwesend Hardware_quantityund bestimmte Arten von {Hardware} waren statistisch signifikant.

> abstract(glm)

Name:
glm(components = log_Energy ~ Training_time_hour + Hardware_quantity + 
    Training_hardware, information = df)

Coefficients:
                                                 Estimate Std. Error t worth Pr(>|t|)    
(Intercept)                                     7.134e+00  1.393e+00   5.123 5.07e-06 ***
Training_time_hour                              1.509e-03  2.548e-04   5.922 3.08e-07 ***
Hardware_quantity                               3.674e-04  9.957e-05   3.690 0.000563 ***
Training_hardwareGoogle TPU v3                  1.887e+00  1.508e+00   1.251 0.216956    
Training_hardwareGoogle TPU v4                  3.270e+00  1.591e+00   2.055 0.045247 *  
Training_hardwareHuawei Ascend 910              2.702e+00  2.485e+00   1.087 0.282287    
Training_hardwareNVIDIA A100                    2.528e+00  1.511e+00   1.674 0.100562    
Training_hardwareNVIDIA A100 SXM4 40 GB         3.103e+00  1.750e+00   1.773 0.082409 .  
Training_hardwareNVIDIA A100 SXM4 80 GB         3.866e+00  1.745e+00   2.216 0.031366 *  
Training_hardwareNVIDIA GeForce GTX 285        -4.077e+00  2.412e+00  -1.690 0.097336 .  
Training_hardwareNVIDIA GeForce GTX TITAN X    -9.706e-01  1.969e+00  -0.493 0.624318    
Training_hardwareNVIDIA GTX Titan Black        -8.423e-01  2.415e+00  -0.349 0.728781    
Training_hardwareNVIDIA H100 SXM5 80GB          3.600e+00  1.864e+00   1.931 0.059248 .  
Training_hardwareNVIDIA P100                   -1.663e+00  1.899e+00  -0.876 0.385436    
Training_hardwareNVIDIA Quadro P600            -1.970e+00  2.419e+00  -0.814 0.419398    
Training_hardwareNVIDIA Quadro RTX 4000        -1.367e+00  2.424e+00  -0.564 0.575293    
Training_hardwareNVIDIA Quadro RTX 5000        -2.309e+00  2.418e+00  -0.955 0.344354    
Training_hardwareNVIDIA Tesla K80               1.761e+00  1.988e+00   0.886 0.380116    
Training_hardwareNVIDIA Tesla V100 DGXS 32 GB   3.415e+00  1.833e+00   1.863 0.068501 .  
Training_hardwareNVIDIA Tesla V100S PCIe 32 GB  3.698e+00  2.413e+00   1.532 0.131852    
Training_hardwareNVIDIA V100                   -3.638e-01  1.582e+00  -0.230 0.819087    
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

(Dispersion parameter for gaussian household taken to be 3.877685)

    Null deviance: 901.45  on 69  levels of freedom
Residual deviance: 190.01  on 49  levels of freedom
AIC: 312.55

Variety of Fisher Scoring iterations: 2

Andererseits das GLM -Modell mit Group produzierte eine AIC von 300,38, viel niedriger als das Vorgängermodell, was auf eine bessere Modellanpassung hinweist. Als ich jedoch genauer hinschaute, bemerkte ich ein bedeutendes Drawback: Die statistische Bedeutung anderer Variablen ist verschwunden, als ob Group nahm die Bedeutung von ihnen weg!

> abstract(glm_random_effects)
Linear blended mannequin match by REML ('lmerMod')
Formulation: log_Energy ~ Training_time_hour + Hardware_quantity + Training_hardware +  
    (1 | Group)
   Knowledge: df

REML criterion at convergence: 254.4

Scaled residuals: 
     Min       1Q   Median       3Q      Max 
-1.65549 -0.24100  0.01125  0.26555  1.51828 

Random results:
 Teams       Identify        Variance Std.Dev.
 Group (Intercept) 3.775    1.943   
 Residual                 1.118    1.057   
Variety of obs: 70, teams:  Group, 44

Fastened results:
                                                 Estimate Std. Error t worth
(Intercept)                                     6.132e+00  1.170e+00   5.243
Training_time_hour                              1.354e-03  2.111e-04   6.411
Hardware_quantity                               3.477e-04  7.035e-05   4.942
Training_hardwareGoogle TPU v3                  2.949e+00  1.069e+00   2.758
Training_hardwareGoogle TPU v4                  2.863e+00  1.081e+00   2.648
Training_hardwareHuawei Ascend 910              4.086e+00  2.534e+00   1.613
Training_hardwareNVIDIA A100                    3.959e+00  1.299e+00   3.047
Training_hardwareNVIDIA A100 SXM4 40 GB         3.728e+00  1.551e+00   2.404
Training_hardwareNVIDIA A100 SXM4 80 GB         4.950e+00  1.478e+00   3.349
Training_hardwareNVIDIA GeForce GTX 285        -3.068e+00  2.502e+00  -1.226
Training_hardwareNVIDIA GeForce GTX TITAN X     4.503e-02  1.952e+00   0.023
Training_hardwareNVIDIA GTX Titan Black         2.375e-01  2.500e+00   0.095
Training_hardwareNVIDIA H100 SXM5 80GB          4.197e+00  1.552e+00   2.704
Training_hardwareNVIDIA P100                   -1.132e+00  1.512e+00  -0.749
Training_hardwareNVIDIA Quadro P600            -1.351e+00  1.904e+00  -0.710
Training_hardwareNVIDIA Quadro RTX 4000        -2.167e-01  2.503e+00  -0.087
Training_hardwareNVIDIA Quadro RTX 5000        -1.203e+00  2.501e+00  -0.481
Training_hardwareNVIDIA Tesla K80               1.559e+00  1.445e+00   1.079
Training_hardwareNVIDIA Tesla V100 DGXS 32 GB   3.751e+00  1.536e+00   2.443
Training_hardwareNVIDIA Tesla V100S PCIe 32 GB  3.487e+00  1.761e+00   1.980
Training_hardwareNVIDIA V100                    7.019e-01  1.434e+00   0.489

Correlation matrix not proven by default, as p = 21 > 12.
Use print(x, correlation=TRUE)  or
    vcov(x)        for those who want it

match warnings:
Some predictor variables are on very totally different scales: contemplate rescaling
> AIC(glm_random_effects)
(1) 300.3767

Nachdem es sorgfältig darüber nachdachte, machte es viel Sinn. Bestimmte Organisationen bevorzugen konsequent bestimmte {Hardware} -Arten oder größere Unternehmen können sich möglicherweise teurere {Hardware} und Ressourcen leisten, um größere KI -Modelle zu schulen. Mit anderen Worten, die zufälligen Effekte hier überlappten und erklärten die Variationen unserer verfügbaren unabhängigen Variablen wahrscheinlich und haben daher einen großen Teil dessen absorbiert, was wir untersuchen wollten.

Dies zeigt einen wichtigen Punkt: Während zufällige oder feste Effekte nützliche Instrumente sind, um unerwünschte Unterschiede auf Gruppenebene zu kontrollieren, können sie auch die zugrunde liegenden Variationen unserer unabhängigen Variablen ungewollt erfassen. Wir sollten sorgfältig überlegen, was diese Effekte wirklich darstellen, bevor wir sie nur blind in unsere Modelle einführen, in der Hoffnung, dass sie das ganze Geräusch glücklich aufnehmen würden.

---

Referenzen: Steve Halfway, Datenanalyse in R,, https://bookdown.org/steve_midway/dar/random-effects.html

Bäume sind ein beliebter beaufsichtigter Lernalgorithmus mit Vorteilen, darunter auch für Regression und Klassifizierung verwendet werden und leicht zu interpretieren sind. Entscheidungsbäume sind jedoch nicht der leistungsstärkste Algorithmus und sind aufgrund kleiner Unterschiede in den Trainingsdaten zu Überanpassung anfällig. Dies kann zu einem völlig anderen Baum führen. Aus diesem Grund wenden sich Menschen oft an Ensemble -Modelle wie gepackte Bäume und zufällige Wälder. Diese bestehen aus mehreren Entscheidungsbäumen, die auf Bootstrap -Daten geschult und aggregiert sind, um eine bessere prädiktive Leistung zu erzielen, als jeder einzelne Baum bieten könnte. Dieses Tutorial enthält Folgendes:

• Was ist einsackt
• Was macht zufällige Wälder unterschiedlich
• Coaching und Stimmen eines zufälligen Waldes mit Scikit-Study
• Berechnung und Interpretation der Merkmals Bedeutung
• Visualisieren individueller Entscheidungsbäume in einem zufälligen Wald

Wie immer ist der in diesem Tutorial verwendete Code in meinem verfügbar Github. A Videoversion Von diesem Tutorial ist auch auf meinem YouTube -Kanal für diejenigen verfügbar, die es vorziehen, visuell mitzugehen. Bemerken wir damit!

Was ist ein Sacking (Bootstrap -Aggregation)

Zufällige Wälder können als Bagging -Algorithmen eingestuft werden (BOotstrap AggRegating). Das Sacken besteht aus zwei Schritten:

1.) Bootstrap -Sampling: Erstellen Sie mehrere Trainingssätze, indem Sie Stichproben mit Ersatz aus dem ursprünglichen Datensatz zufällig zeichnen. Diese neuen Trainingseinsätze, die als Bootstrapt -Datensätze bezeichnet werden, enthalten normalerweise die gleiche Anzahl von Zeilen wie der ursprüngliche Datensatz, aber einzelne Zeilen können mehrmals oder gar nicht angezeigt werden. Im Durchschnitt enthält jeder Bootstrap -Datensatz etwa 63,2% der eindeutigen Zeilen aus den Originaldaten. Die verbleibenden ~ 36,8% der Zeilen werden ausgelassen und können für die Auswertung außerhalb des Baggage (OOB) verwendet werden. Weitere Informationen zu diesem Konzept finden Sie in meinem Probenahme mit und ohne Ersatz -Weblog -Beitrag.

2.) Aggregation Vorhersagen: Jeder Bootstrap -Datensatz wird verwendet, um ein anderes Entscheidungsbaummodell zu trainieren. Die endgültige Vorhersage erfolgt durch die Kombination der Ausgaben aller einzelnen Bäume. Für die Klassifizierung erfolgt dies normalerweise durch Mehrheitsabstimmung. Für die Regression werden Vorhersagen gemittelt.

Das Coaching jedes Baumes auf einer anderen Stiefelprobe führt zu Variationen über Bäume. Während dies die Korrelation nicht vollständig beseitigt – insbesondere wenn bestimmte Merkmale dominieren, hilft es, die Überanpassung in Kombination mit der Aggregation zu verringern. Durchschnitt der Vorhersagen vieler solcher Bäume reduziert den Gesamt Varianz des Ensembles, Verbesserung der Verallgemeinerung.

Was macht zufällige Wälder unterschiedlich

Angenommen, es gibt eine einzige starke Funktion in Ihrem Datensatz. In SackbäumeJeder Baum kann dieses Merkmal wiederholt teilen, was zu korrelierten Bäumen führt und weniger von der Aggregation profitiert. Zufällige Wälder reduzieren dieses Downside, indem sie weitere Zufälligkeit einführen. Insbesondere verändern sie, wie Spaltungen während des Trainings ausgewählt werden:

1). Erstellen Sie N -Bootstrap -Datensätze. Beachten Sie, dass das Bootstrapping in zufälligen Wäldern üblicherweise verwendet wird, es ist jedoch nicht streng erforderlich, da Schritt 2 (Auswahl der zufälligen Merkmale) eine ausreichende Vielfalt der Bäume einführt.

2). Für jeden Baum wird bei jedem Knoten eine zufällige Untergruppe von Merkmalen als Kandidaten ausgewählt, und die beste Spaltung wird aus dieser Teilmenge ausgewählt. In Scikit-Study wird dies von der gesteuert max_features Parameter, der standardmäßig angeht 'sqrt' für Klassifikatoren und 1 für Regressoren (gleichwertig mit abgesackten Bäumen).

3). Aggregation Vorhersagen: Stimmen Sie für Klassifizierung und Durchschnitt für die Regression.

Hinweis: Zufällige Wälder verwenden Probenahme mit Ersatz für Bootstrap -Datensätze und Abtastung ohne Ersatz Zur Auswahl einer Untergruppe von Funktionen.

OB-of-Bag (OOB) Rating

Da ~ 36,8% der Schulungsdaten von einem bestimmten Baum ausgeschlossen sind, können Sie diesen Holdout -Teil verwenden, um die Vorhersagen dieses Baumes zu bewerten. Scikit-Study ermöglicht dies über den Parameter OOB_SCORE = True, und bietet einen effizienten Weg, um die Verallgemeinerungsfehler abzuschätzen. Sie werden diesen Parameter im Trainingsbeispiel später im Tutorial sehen.

Coaching und Stimmen eines zufälligen Waldes in Scikit-Study

Zufällige Wälder bleiben dank ihrer Einfachheit, Interpretierbarkeit und Fähigkeit zu einer starken Grundlinie für tabellarische Daten parallelisieren Da wird jeder Baum unabhängig trainiert. Dieser Abschnitt zeigt, wie Daten geladen werden. Führen Sie einen Zugtest geteilt durchtrainieren Sie ein Basismodell, stimmen Sie Hyperparameter mit der Gittersuche ab und bewerten Sie das endgültige Modell im Testsatz.

Schritt 1: Trainieren Sie ein Basismodell

Vor dem Einstellen ist es eine gute Praxis, ein Basismodell mit angemessenen Standardeinstellungen zu trainieren. Dies gibt Ihnen ein anfängliches Leistungsgefühl und ermöglicht es Ihnen, die Generalisierung mithilfe des OB-Bag-Scores (OB-BAG) zu validieren, der in magebasierte Modelle wie zufällige Wälder integriert ist. In diesem Beispiel werden die Hausverkäufe in King County Dataset (CCO 1.0 Common Lizenz) verwendet, die zwischen Mai 2014 und Mai 2015 den Verkauf von Immobilien aus dem Gebiet von Seattle enthält. Mit diesem Ansatz können wir den Testsatz für die endgültige Bewertung nach dem Tuning reservieren.

Python"># Import libraries

# Some imports are solely used later within the tutorial
import matplotlib.pyplot as plt

import numpy as np

import pandas as pd

# Dataset: Breast Most cancers Wisconsin (Diagnostic)
# Supply: UCI Machine Studying Repository
# License: CC BY 4.0
from sklearn.datasets import load_breast_cancer

from sklearn.ensemble import RandomForestClassifier

from sklearn.ensemble import RandomForestRegressor

from sklearn.inspection import permutation_importance

from sklearn.model_selection import GridSearchCV, train_test_split

from sklearn import tree

# Load dataset
# Dataset: Home Gross sales in King County (Might 2014–Might 2015)
# License CC0 1.0 Common
url = 'https://uncooked.githubusercontent.com/mGalarnyk/Tutorial_Data/grasp/King_County/kingCountyHouseData.csv'

df = pd.read_csv(url)

columns = ('bedrooms',

            'loos',

            'sqft_living',

            'sqft_lot',

             'flooring',

             'waterfront',

             'view',

             'situation',

             'grade',

             'sqft_above',

             'sqft_basement',

             'yr_built',

             'yr_renovated',

             'lat',

             'lengthy',

             'sqft_living15',

             'sqft_lot15',

             'value')

df = df(columns)

# Outline options and goal

X = df.drop(columns='value')

y = df('value')

# Prepare/take a look at break up

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

# Prepare baseline Random Forest

reg = RandomForestRegressor(

    n_estimators=100,        # variety of timber

    max_features=1/3,        # fraction of options thought of at every break up

    oob_score=True,          # permits out-of-bag analysis

    random_state=0

)

reg.match(X_train, y_train)

# Consider baseline efficiency utilizing OOB rating

print(f"Baseline OOB rating: {reg.oob_score_:.3f}")

Schritt 2: Schalten Sie Hyperparameter mit der Gittersuche ab

Während das Basismodell einen starken Ausgangspunkt liefert, kann die Leistung häufig durch Tuning von Schlüsselhyperparametern verbessert werden. Grid-Suche Kreuzvalidierung, wie durch implementiert von GridSearchCVsystematisch untersucht Kombinationen von Hyperparametern und verwendet eine Kreuzvalidierung, um die einzelnen zu bewerten, wobei die Konfiguration mit der höchsten Validierungsleistung ausgewählt wird. Zu den am häufigsten abgestimmten Hyperparametern gehören:

• n_estimators: Die Anzahl der Entscheidungsbäume im Wald. Mehr Bäume können die Genauigkeit verbessern, aber die Trainingszeit erhöhen.
• max_features: Die Anzahl der Funktionen zu berücksichtigen, wenn Sie nach dem besten Cut up suchen. Niedrigere Werte verringern die Korrelation zwischen Bäumen.
• max_depth: Die maximale Tiefe jedes Baumes. Flachere Bäume sind schneller, können aber unterbinden.
• min_samples_split: Die minimale Anzahl von Proben, die zum Aufteilen eines internen Knotens erforderlich sind. Höhere Werte können die Überanpassung verringern.
• min_samples_leaf: Die minimale Anzahl von Proben, die erforderlich sind, um sich an einem Blattknoten zu befinden. Hilft bei der Kontrolle der Baumgröße.
• bootstrap: Ob Bootstrap -Proben beim Bau von Bäumen verwendet werden. Wenn falsch, wird der gesamte Datensatz verwendet.

param_grid = {

    'n_estimators': (100),

    'max_features': ('sqrt', 'log2', None),

    'max_depth': (None, 5, 10, 20),

    'min_samples_split': (2, 5),

    'min_samples_leaf': (1, 2)

}

# Initialize mannequin

rf = RandomForestRegressor(random_state=0, oob_score=True)

grid_search = GridSearchCV(

    estimator=rf,

    param_grid=param_grid,

    cv=5,             # 5-fold cross-validation

    scoring='r2',     # analysis metric

    n_jobs=-1         # use all obtainable CPU cores

)

grid_search.match(X_train, y_train)

print(f"Finest parameters: {grid_search.best_params_}")

print(f"Finest R^2 rating: {grid_search.best_score_:.3f}")

Schritt 3: Bewerten Sie das endgültige Modell im Testsatz

Nachdem wir nun das auf Foundation von Quervalidierung basierende Modell ausgewählt haben, können wir es am Maintain-Out-Take a look at-Set bewerten, um seine Generalisierungsleistung abzuschätzen.

# Consider ultimate mannequin on take a look at set

best_model = grid_search.best_estimator_

print(f"Take a look at R^2 rating (ultimate mannequin): {best_model.rating(X_test, y_test):.3f}")

Berechnung der Wichtigkeit des zufälligen Waldmerkmals

Einer der Hauptvorteile zufälliger Wälder ist ihre Interpretierbarkeit – etwas, das große Sprachmodelle (LLMs) häufig fehlen. Während LLMs leistungsfähig sind, fungieren sie normalerweise als schwarze Kisten und können Zeigen Sie Verzerrungen auf, die schwer zu identifizieren sind. Im Gegensatz dazu unterstützt Scikit-Study zwei Hauptmethoden zur Messung der Merkmals Bedeutung in zufälligen Wäldern: mittlere Abnahme von Verunreinigungen und Permutation.

1). Durch die mittlere Verringerung der Verunreinigung (MDI): Diese Methode auch als Gini -Bedeutung bezeichnet. Diese Methode berechnet die Gesamtreduktion der Verunreinigung, die jedes Merkmal über alle Bäume übertragen wird. Dies ist schnell und in das Modell integriert über through reg.feature_importances_. Unreinheitsbasierte Merkmalsimporte können jedoch irreführend sein, insbesondere für Funktionen mit hoher Kardinalität (viele einzigartige Werte), da diese Funktionen eher ausgewählt werden, nur weil sie mehr potenzielle Cut up-Punkte liefern.

importances = reg.feature_importances_

feature_names = X.columns

sorted_idx = np.argsort(importances)(::-1)

for i in sorted_idx:

    print(f"{feature_names(i)}: {importances(i):.3f}")

2). Permutation Bedeutung: Diese Methode bewertet die Abnahme der Modellleistung, wenn die Werte eines einzelnen Merkmals zufällig gemischt werden. Im Gegensatz zu MDI berücksichtigt es Function -Interaktionen und Korrelation. Es ist zuverlässiger, aber auch rechenintensiver.

# Carry out permutation significance on the take a look at set

perm_importance = permutation_importance(reg, X_test, y_test, n_repeats=10, random_state=0)

sorted_idx = perm_importance.importances_mean.argsort()(::-1)

for i in sorted_idx:

    print(f"{X.columns(i)}: {perm_importance.importances_mean(i):.3f}")

Es ist wichtig zu beachten, dass unsere geografischen Merkmale Lat und Lengthy auch für die Visualisierung nützlich sind, wie das folgende Diagramm zeigt. Es ist wahrscheinlich, dass Unternehmen wie Zillow die Standortinformationen in ihren Bewertungsmodellen ausgiebig einsetzen.

Visualisieren individueller Entscheidungsbäume in einem zufälligen Wald

Ein zufälliger Wald besteht aus mehreren Entscheidungsbäumen – einer für jeden über die angegebenen Schätzer n_estimators Parameter. Nach dem Coaching des Modells können Sie diese einzelnen Bäume über das Attribut .Sestimators_ zugreifen. Das Visualisieren einiger dieser Bäume kann helfen, zu veranschaulichen, wie unterschiedlich jeder die Daten aufgrund von Bootstrap -Trainingsproben und zufälligen Merkmalsauswahl bei jedem Cut up spaltet. Während das frühere Beispiel einen zufälligen ForestRegressor verwendete, zeigen wir hier diese Visualisierung anhand eines auf dem Breast Most cancers Wisconsin -Datensatzes (CC nach 4.0 -Lizenz) ausgebildeten RandomforestClassifiers, um die Vielseitigkeit von zufälligen Wäldern für Regressions- und Klassifizierungsaufgaben hervorzuheben. Dieses kurze Video zeigt, wie 100 geschulte Schätzer aus diesem Datensatz aussehen.

Passen Sie ein zufälliges Waldmodell mit Scikit-Study an

# Load the Breast Most cancers (Diagnostic) Dataset

knowledge = load_breast_cancer()

df = pd.DataFrame(knowledge.knowledge, columns=knowledge.feature_names)

df('goal') = knowledge.goal

# Organize Knowledge into Options Matrix and Goal Vector

X = df.loc(:, df.columns != 'goal')

y = df.loc(:, 'goal').values

# Cut up the information into coaching and testing units

X_train, X_test, Y_train, Y_test = train_test_split(X, y, random_state=0)

# Random Forests in `scikit-learn` (with N = 100)

rf = RandomForestClassifier(n_estimators=100,

                            random_state=0)

rf.match(X_train, Y_train)

Zeichnen einzelner Schätzer (Entscheidungsbäume) aus einem zufälligen Wald unter Verwendung von Matplotlib

Sie können jetzt alle einzelnen Bäume aus dem montierten Modell anzeigen.

rf.estimators_

Sie können jetzt einzelne Bäume visualisieren. Der folgende Code visualisiert den ersten Entscheidungsbaum.

fn=knowledge.feature_names

cn=knowledge.target_names

fig, axes = plt.subplots(nrows = 1,ncols = 1,figsize = (4,4), dpi=800)

tree.plot_tree(rf.estimators_(0),

               feature_names = fn, 

               class_names=cn,

               stuffed = True);

fig.savefig('rf_individualtree.png')

Obwohl es schwierig zu interpretieren ist, viele Bäume zu planen, möchten Sie möglicherweise die Vielfalt zwischen den Schätzern untersuchen. Das folgende Beispiel zeigt, wie die ersten fünf Entscheidungsbäume im Wald visualisieren:

# This will likely not one of the best ways to view every estimator as it's small

fig, axes = plt.subplots(nrows=1, ncols=5, figsize=(10, 2), dpi=3000)

for index in vary(5):

    tree.plot_tree(rf.estimators_(index),

                   feature_names=fn,

                   class_names=cn,

                   stuffed=True,

                   ax=axes(index))

    axes(index).set_title(f'Estimator: {index}', fontsize=11)

fig.savefig('rf_5trees.png')

Abschluss

Zufällige Wälder bestehen aus mehreren Entscheidungsbäumen, die auf Bootstrap -Daten ausgebildet sind, um eine bessere prädiktive Leistung zu erzielen, als aus einer der einzelnen Entscheidungsbäume erhalten werden könnten. Wenn Sie Fragen oder Gedanken zum Tutorial haben, können Sie sich gerne durchgehen YouTube oder X.