microsoftml.rx_fast_forest: Random Forest

Artikel
05/23/2023

Verwendung

microsoftml.rx_fast_forest(formula: str,
    data: [revoscalepy.datasource.RxDataSource.RxDataSource,
    pandas.core.frame.DataFrame], method: ['binary',
    'regression'] = 'binary', num_trees: int = 100,
    num_leaves: int = 20, min_split: int = 10,
    example_fraction: float = 0.7, feature_fraction: float = 1,
    split_fraction: float = 1, num_bins: int = 255,
    first_use_penalty: float = 0, gain_conf_level: float = 0,
    train_threads: int = 8, random_seed: int = None,
    ml_transforms: list = None, ml_transform_vars: list = None,
    row_selection: str = None, transforms: dict = None,
    transform_objects: dict = None, transform_function: str = None,
    transform_variables: list = None,
    transform_packages: list = None,
    transform_environment: dict = None, blocks_per_read: int = None,
    report_progress: int = None, verbose: int = 1,
    ensemble: microsoftml.modules.ensemble.EnsembleControl = None,
    compute_context: revoscalepy.computecontext.RxComputeContext.RxComputeContext = None)

BESCHREIBUNG

Machine Learning: Fast Forest

Details

Entscheidungsbäume sind nicht-parametrische Modelle, die eine Reihe von einfachen Tests auf Eingaben anwenden. Dieses Entscheidungsverfahren ordnet sie Ausgaben aus dem Trainingsdataset zu, deren Eingaben der zu verarbeitenden Instanz ähnlich waren. Bei jedem Knoten der binären Baumstruktur wird eine Entscheidung auf Grundlage des Maßes der Ähnlichkeit getroffen, das jede Instanz rekursiv durch die Zweige des Baums zuordnet, bis der entsprechende Blattknoten erreicht und die Ausgabeentscheidung zurückgegeben wird.

Entscheidungsbäume haben mehrere Vorteile:

Sie sind während des Trainings und der Vorhersage effizient sowohl bei der Berechnung als auch bei der Arbeitsspeicherauslastung.
Sie können nicht lineare Entscheidungsgrenzen darstellen.
Sie führen eine integrierte Featureauswahl und -klassifizierung durch.
Sie sind resilient gegen störende Features.

Die Fast Forest-Regression ist eine Implementierung von Random Forest und Quantile Regression Forest unter Verwendung des Regressionsbaum-Lernmodus in rx_fast_trees. Dieses Modell besteht aus einem Ensemble von Entscheidungsbäumen. Jeder Baum in einem Entscheidungswald gibt mittels Prognose eine Gauß-Verteilung aus. Es erfolgt eine Aggregation über das Baumensemble, um eine Gauß-Verteilung zu finden, die der kombinierten Verteilung für alle Bäume im Modell am nächsten kommt.

Dieser Entscheidungswaldklassifizierer besteht aus einem Ensemble von Entscheidungsbäumen. Im Allgemeinen bieten Ensemblemodelle eine bessere Abdeckung und Genauigkeit als einzelne Entscheidungsbäume. Jeder Baum in einem Entscheidungswald gibt eine Gauß-Verteilung aus.

Argumente

Formel

Die Formel, wie in „revoscalepy.rx_formula“ beschrieben. Interaktionsterme und F() werden derzeit in microsoftml nicht unterstützt.

data

Ein Datenquellenobjekt oder eine Zeichenfolge, die eine .xdf-Datei oder ein Datenrahmenobjekt angibt.

Methode

Eine Zeichenfolge, die den Typ „Fast Tree“ bezeichnet

"binary" für die standardmäßige binäre Fast Tree-Klassifizierung oder
"regression" für Fast Tree-Regression.

num_trees

Gibt die Gesamtzahl der Entscheidungsbäume an, die im Ensemble erstellt werden sollen. Wenn Sie mehr Entscheidungsbäume erstellen, erhalten Sie möglicherweise eine bessere Abdeckung, wobei sich die Trainingszeit jedoch verlängert. Der Standardwert ist 100.

num_leaves

Die maximale Anzahl von Blättern (Endknoten) an, die in einem Baum erstellt werden können. Höhere Werte können zwar den Baum vergrößern und die Genauigkeit verbessern, bergen aber das Risiko einer Überanpassung und erfordern längere Trainingszeiten. Der Standardwert lautet 20.

min_split

Mindestanzahl von Trainingsinstanzen an, die für die Erstellung eines Blatts erforderlich sind. Das heißt, die minimale Anzahl von Dokumenten, die in einem Blatt eines Regressionsbaums aus den Daten mit untergeordneten Stichproben zulässig sind. Eine „Aufteilung“ bedeutet, dass Features auf jeder Ebene des Baums (Knotens) zufällig aufgeteilt werden. Der Standardwert ist 10.

example_fraction

Der Anteil zufällig gewählter Instanzen, die für jeden Baum verwendet werden sollen. Der Standardwert ist 0,7.

feature_fraction

Der Anteil zufällig gewählter Features, die für jeden Baum verwendet werden sollen. Der Standardwert ist 0,7.

split_fraction

Der Anteil zufällig gewählter Features, die für jede Aufteilung verwendet werden sollen. Der Standardwert ist 0,7.

num_bins

Maximale Anzahl unterschiedlicher Werte (Bins) pro Feature. Der Standardwert ist 255.

first_use_penalty

Das Feature verwendet zuerst den Strafkoeffizienten. Der Standardwert ist 0.

gain_conf_level

Konfidenzanforderung für die Baumanpassung (muss im Bereich [0,1] liegen) Der Standardwert ist 0.

train_threads

Die Anzahl der Threads zum Trainieren des Modells. Falls None, wird die Anzahl der zu verwendenden Threads intern bestimmt. Der Standardwert ist None.

random_seed

Gibt den zufälligen Ausgangswert an. Der Standardwert ist None.

ml_transforms

Gibt eine Liste von MicrosoftML-Transformationen an, die vor dem Training für die Daten erfolgen sollen, oder None, wenn keine Transformationen erfolgen sollen. Unter featurize_text, categorical und categorical_hash finden Sie unterstützte Transformationen. Diese Transformationen werden nach allen angegebenen Python-Transformationen ausgeführt. Der Standardwert ist None.

ml_transform_vars

Gibt einen Zeichenvektor von Variablennamen an, die in ml_transforms verwendet werden sollen, oder None, wenn keine verwendet werden sollen. Der Standardwert ist None.

row_selection

Nicht unterstützt. Gibt die Zeilen (Beobachtungen) aus dem Dataset an, die vom Modell verwendet werden sollen, mit dem Namen einer logischen Variablen aus dem Dataset (in Anführungszeichen) oder mit einem logischen Ausdruck unter Verwendung von Variablen im Dataset. Beispiel:

row_selection = "old" verwendet nur Beobachtungen, bei denen True der Wert der Variablen old ist.
row_selection = (age > 20) & (age < 65) & (log(income) > 10) verwendet nur Beobachtungen, bei denen der Wert der Variablen age zwischen 20 und 65 liegt und der Wert von log der Variablen income größer als 10 ist.

Die Zeilenauswahl erfolgt nach der Verarbeitung von Datentransformationen (siehe die Argumente transforms oder transform_function). Wie bei allen Ausdrücken kann row_selection außerhalb des Funktionsaufrufs mit der Funktion expression definiert werden.

Transformationen

Nicht unterstützt. Ein Ausdruck der Form, die die erste Runde der Variablentransformationen darstellt. Wie bei allen Ausdrücken kann transforms (oder row_selection) außerhalb des Funktionsaufrufs mit der Funktion expression definiert werden.

transform_objects

Nicht unterstützt. Eine benannte Liste, die Objekte enthält, auf die mit transforms, transform_function und row_selection verwiesen werden kann.

transform_function

Die Variablentransformationsfunktionen.

transform_variables

Ein Zeichenvektor von Eingabedatasetvariablen, die für die Transformationsfunktion erforderlich sind.

transform_packages

Nicht unterstützt. Ein Zeichenvektor, der zusätzliche Python-Pakete (außerhalb der in RxOptions.get_option("transform_packages") angegebenen) angibt, die für die Verwendung in Variablentransformationsfunktionen verfügbar gemacht und im Voraus geladen werden sollen. Zum Beispiel solche, die explizit in revoscalepy-Funktionen über ihre Argumente transforms und transform_function definiert sind oder solche, die implizit über ihre Argumente formula oder row_selection definiert sind. Das Argument transform_packages kann auch None lauten, was angibt, dass keine Pakete außerhalb von RxOptions.get_option("transform_packages") im Voraus geladen werden.

transform_environment

Nicht unterstützt. Eine benutzerdefinierte Umgebung, die als übergeordnete Umgebung für alle intern entwickelten Umgebungen dient und für die Transformation von Variablendaten verwendet wird. Falls transform_environment = None, wird stattdessen eine neue „hash“-Umgebung mit der übergeordneten „revoscalepy.baseenv“ verwendet.

blocks_per_read

Gibt die Anzahl der Blöcke an, die für jeden Datenblock gelesen werden, der aus der Datenquelle gelesen wird.

report_progress

Ein ganzzahliger Wert, der die Berichtsebene für den Status der Zeilenverarbeitung angibt:

0: Es wird kein Status gemeldet.
1: Die Anzahl der verarbeiteten Zeilen wird ausgegeben und aktualisiert.
2: Verarbeitete Zeilen und Zeitsteuerungen werden gemeldet.
3: Verarbeitete Zeilen und alle Zeitsteuerungen werden gemeldet.

Ausführlich

Ein ganzzahliger Wert, der die gewünschte Ausgabemenge angibt. Falls 0, erfolgt während der Berechnungen keine ausführliche Ausgabe. Ganzzahlige Werte von 1 bis 4 liefern zunehmend mehr Informationen.

compute_context

Legt den Kontext fest, in dem Berechnungen erfolgen, angegeben mit einer gültigen Angabe für RxComputeContext. Derzeit werden lokale und RxInSqlServer-Computekontexte unterstützt.

ensemble

Steuerungsparameter für die Bildung von Ensembles.

Gibt zurück

Ein FastForest-Objekt mit dem trainierten Modell.

Hinweis

Dieser Algorithmus ist ein Multithread-Algorithmus, der immer versucht, das gesamte Dataset in den Arbeitsspeicher zu laden.

Siehe auch

rx_fast_trees, rx_predict

Referenzen

Wikipedia: Random Forest

Quantile Regression Forest

From Stumps to Trees to Forests

Beispiel für binäre Klassifizierung

'''
Binary Classification.
'''
import numpy
import pandas
from microsoftml import rx_fast_forest, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

infert = get_dataset("infert")

import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

infertdf = infert.as_df()
infertdf["isCase"] = infertdf.case == 1
data_train, data_test, y_train, y_test = train_test_split(infertdf, infertdf.isCase)

forest_model = rx_fast_forest(
    formula=" isCase ~ age + parity + education + spontaneous + induced ",
    data=data_train)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(forest_model, data=data_test,
                     extra_vars_to_write=["isCase", "Score"])
                     
# Print the first five rows
print(rx_data_step(score_ds, number_rows_read=5))

Ausgabe:

Not adding a normalizer.
Making per-feature arrays
Changing data from row-wise to column-wise
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
Processed 186 instances
Binning and forming Feature objects
Reserved memory for tree learner: 7176 bytes
Starting to train ...
Not training a calibrator because a valid calibrator trainer was not provided.
Elapsed time: 00:00:00.2704185
Elapsed time: 00:00:00.0443884
Beginning processing data.
Rows Read: 62, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0253862
Finished writing 62 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: Less than .001 seconds 
  isCase PredictedLabel      Score
0  False          False -36.205067
1   True          False -40.396084
2  False          False -33.242531
3  False          False -87.212494
4   True          False -13.100666

Regressionsbeispiel

'''
Regression.
'''
import numpy
import pandas
from microsoftml import rx_fast_forest, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

airquality = get_dataset("airquality")

import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

airquality = airquality.as_df()


######################################################################
# Estimate a regression fast forest
# Use the built-in data set 'airquality' to create test and train data

df = airquality[airquality.Ozone.notnull()]
df["Ozone"] = df.Ozone.astype(float)

data_train, data_test, y_train, y_test = train_test_split(df, df.Ozone)

airFormula = " Ozone ~ Solar_R + Wind + Temp "

# Regression Fast Forest for train data
ff_reg = rx_fast_forest(airFormula, method="regression", data=data_train)

# Put score and model variables in data frame
score_df = rx_predict(ff_reg, data=data_test, write_model_vars=True)
print(score_df.head())

# Plot actual versus predicted values with smoothed line
# Supported in the next version.
# rx_line_plot(" Score ~ Ozone ", type=["p", "smooth"], data=score_df)