microsoftml.rx_fast_trees: Angekurbelte Bäume

Usage

microsoftml.rx_fast_trees(formula: str,
    data: [revoscalepy.datasource.RxDataSource.RxDataSource,
    pandas.core.frame.DataFrame], method: ['binary',
    'regression'] = 'binary', num_trees: int = 100,
    num_leaves: int = 20, learning_rate: float = 0.2,
    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, unbalanced_sets: bool = False,
    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)

Description

Schnelle Struktur für maschinelles Lernen

Einzelheiten

rx_fast_trees ist eine Implementierung von FastRank. FastRank ist eine effiziente Implementierung des MART-Farbverlaufsalgorithmus. Die Farbverlaufsverhebung ist eine Maschinelle Lerntechnik für Regressionsprobleme. Sie erstellt jede Regressionsstruktur schrittweise, indem sie eine vordefinierte Verlustfunktion verwendet, um den Fehler für jeden Schritt zu messen und im nächsten Schritt zu korrigieren. Dieses Vorhersagemodell ist also tatsächlich ein Ensemble schwächerer Vorhersagemodelle. Bei Regressionsproblemen baut die Verstärkung eine Reihe solcher Bäume in einer schrittweisen Weise auf und wählt dann den optimalen Baum unter Verwendung einer beliebigen unterscheidungsfähigen Verlustfunktion aus.

MART lernt ein Ensemble von Regressionsbäumen, bei dem es sich um einen Entscheidungsbaum mit skalaren Werten in seinen Blättern handelt. Eine Entscheidungsstruktur (oder Regressionsstruktur) ist ein binäres strukturähnliches Flussdiagramm, bei dem bei jedem inneren Knoten eines der beiden untergeordneten Knoten basierend auf einem der Featurewerte aus der Eingabe entschieden wird. Bei jedem Blattknoten wird ein Wert zurückgegeben. In den Innenknoten basiert die Entscheidung auf dem Test "x <= v", wobei x der Wert des Features im Eingabebeispiel und v einer der möglichen Werte dieses Features ist. Die Funktionen, die von einer Regressionsstruktur erzeugt werden können, sind alle stückweise konstanten Funktionen.

Das Ensemble von Bäumen wird durch berechnen, in jedem Schritt, eine Regressionsstruktur, die den Farbverlauf der Verlustfunktion annähert, und fügt es der vorherigen Struktur mit Koeffizienten hinzu, die den Verlust der neuen Struktur minimieren. Die Ausgabe des Ensembles, das von MART in einer bestimmten Instanz erzeugt wird, ist die Summe der Baumausgaben.

Bei einem Binärklassifizierungsproblem wird die Ausgabe mithilfe einer Form der Kalibrierung in eine Wahrscheinlichkeit konvertiert.
Bei einem Regressionsproblem ist die Ausgabe der vorhergesagten Wert der Funktion.
Bei einem Rangfolgeproblem werden die Instanzen vom Ausgabewert des Ensembles sortiert.

Wenn diese Option auf <a0/> festgelegt ist, wird eine Regressionsversion von FastTree verwendet. Bei Festlegung auf "ranking", wird eine Bewertungsversion von FastTree verwendet. Im Rangfolgenfall sollten die Instanzen durch die Ausgabe des Strukturensembles sortiert werden. Der einzige Unterschied bei den Einstellungen dieser Versionen liegt in den Kalibrierungseinstellungen, die nur für die Klassifizierung erforderlich sind.

Arguments

Formel

Die Formel, wie in revoscalepy.rx_formula beschrieben. Interaktionsausdrücke und F() werden derzeit in Microsoftml nicht unterstützt.

Daten

Ein Datenquellenobjekt oder eine Zeichenfolge, die eine XDF-Datei oder ein Datenframeobjekt angibt.

method

Eine Zeichenfolge, die den Typ der fasten Struktur angibt: "binary" für die standardmäßige binäre Klassifizierung der fasten Struktur oder "regression" für die schnelle Strukturregression.

num_trees

Gibt die Gesamtanzahl der Entscheidungsstrukturen an, die im Ensemble erstellt werden sollen. Durch die Erstellung weiterer Entscheidungsstrukturen können Sie möglicherweise eine bessere Abdeckung erhalten, aber die Schulungszeit erhöht sich. Der Standardwert ist 100.

num_leaves

Die maximale Anzahl von Blättern (Terminalknoten), die in einer beliebigen Struktur erstellt werden können. Höhere Werte erhöhen möglicherweise die Größe des Baumes und erhalten eine bessere Präzision, aber riskieren, dass sie überfällig sind und längere Trainingszeiten erfordern. Der Standardwert lautet 20.

Lernrate

Bestimmt die Größe des Schritts in Richtung des Farbverlaufs in jedem Schritt des Lernprozesses. Dadurch wird bestimmt, wie schnell oder langsam der Lernenden auf die optimale Lösung konvergiert. Wenn die Schrittgröße zu groß ist, können Sie die optimale Lösung überschießen. Wenn die Schrittgröße zu klein ist, dauert die Schulung länger, um zur besten Lösung zu gelangen.

min_split

Mindestanzahl an Schulungsinstanzen, die zum Bilden eines Blatts erforderlich sind. Das heißt, die minimale Anzahl von Dokumenten, die in einem Blatt einer Regressionsstruktur zulässig sind, aus den untersampulierten Daten. Eine "Aufteilung" bedeutet, dass Features auf jeder Ebene der Struktur (Knoten) zufällig geteilt werden. Der Standardwert ist 10. Nur die Anzahl der Instanzen wird gezählt, auch wenn Instanzen gewichtet sind.

example_fraction

Der Anteil der zufällig ausgewählten Instanzen, die für jede Struktur verwendet werden sollen. Der Standardwert ist 0,7.

feature_fraction

Der Anteil der zufällig ausgewählten Features, die für jede Struktur verwendet werden sollen. Der Standardwert ist 1.

split_fraction

Der Anteil der zufällig ausgewählten Features, die für jede Aufteilung verwendet werden sollen. Der Standardwert ist 1.

num_bins

Maximale Anzahl unterschiedlicher Werte (Bins) pro Feature. Wenn das Feature weniger Werte aufweist als die angegebene Zahl, wird jeder Wert in einem eigenen Container platziert. Wenn mehr Werte vorhanden sind, erstellt numBins der Algorithmus Bins.

first_use_penalty

Das Feature verwendet zuerst den Strafkoeffizient. Dies ist eine Form der Regularisierung, die beim Erstellen der Struktur eine Strafe für die Verwendung eines neuen Features verursacht. Erhöhen Sie diesen Wert, um Bäume zu erstellen, die nicht viele Features verwenden. Der Standardwert ist 0.

gain_conf_level

Anforderung der Strukturanpassung an Konfidenz (sollte im Bereich [0,1)) liegen. Der Standardwert ist 0.

unbalanced_sets

Wenn True, Derivate, die für unausgewogene Mengen optimiert sind, verwendet werden. Gilt nur, wenn type gleich "binary". Der Standardwert ist False.

train_threads

Die Anzahl der Threads, die in der Schulung verwendet werden sollen. Der Standardwert ist 8.

random_seed

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

ml_transforms

Gibt eine Liste der MicrosoftML-Transformationen an, die vor dem Training oder none für die Daten ausgeführt werden sollen, wenn keine Transformationen ausgeführt werden sollen. Siehe featurize_text, categoricalund categorical_hash, für Transformationen, die unterstützt werden. Diese Transformationen werden nach allen angegebenen Python-Transformationen ausgeführt. Der Standardwert ist None.

ml_transform_vars

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

row_selection

NICHT UNTERSTÜTZT. Gibt die Zeilen (Beobachtungen) aus dem Dataset an, die vom Modell mit dem Namen einer logischen Variablen aus dem Dataset (in Anführungszeichen) oder mit einem logischen Ausdruck mithilfe von Variablen im Dataset verwendet werden sollen. Beispiel:

row_selection = "old" verwendet nur Beobachtungen, in denen der Wert der Variablen old lautet True.
row_selection = (age > 20) & (age < 65) & (log(income) > 10) verwendet nur Beobachtungen, in denen der Wert der age Variablen zwischen 20 und 65 liegt und der Wert der logincome Variablen 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 außerhalb des Funktionsaufrufs row_selection mithilfe der expression Funktion definiert werden.

Verwandelt

NICHT UNTERSTÜTZT. Ein Ausdruck des Formulars, das die erste Runde von Variablentransformationen darstellt. Wie bei allen Ausdrücken kann (oder row_selection) außerhalb des Funktionsaufrufs transforms mithilfe der expression Funktion definiert werden.

transform_objects

NICHT UNTERSTÜTZT. Eine benannte Liste, die Objekte enthält, auf die von transforms, und transform_function.row_selection

transform_function

Die Variable Transformationsfunktion.

transform_variables

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

transform_packages

NICHT UNTERSTÜTZT. Ein Zeichenvektor, der zusätzliche Python-Pakete angibt (außerhalb der in ) RxOptions.get_option("transform_packages")zur Verfügung gestellt und für die Verwendung in Variablentransformationsfunktionen vorab geladen werden soll. Beispielsweise werden diejenigen, die explizit in Revoscalepy-Funktionen über ihre transforms und transform_function Argumente oder implizit über ihre formula Argumente row_selection definiert wurden, definiert. Das transform_packages Argument kann auch "None" sein, das angibt, dass keine Pakete vorgeladen RxOptions.get_option("transform_packages") werden.

transform_environment

NICHT UNTERSTÜTZT. Eine benutzerdefinierte Umgebung, die als übergeordnetes Element für alle Umgebungen dient, die intern entwickelt und für die Variable Datentransformation verwendet werden. Wenn transform_environment = Nonestattdessen eine neue "Hash"-Umgebung mit übergeordnetem revoscalepy.baseenv verwendet wird.

blocks_per_read

Gibt die Anzahl der zu lesenden Blöcke für jeden Datenabschnitt an, der aus der Datenquelle gelesen werden soll.

report_progress

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

0: Es wird kein Fortschritt gemeldet.
1: Die Anzahl der verarbeiteten Zeilen wird gedruckt und aktualisiert.
2: Verarbeitete Zeilen und Anzeigedauern werden gemeldet.
3: Verarbeitete Zeilen und alle Anzeigedauern werden gemeldet.

verbose

Ein ganzzahliger Wert, der die gewünschte Ausgabemenge angibt. Wird 0bei Berechnungen keine ausführliche Ausgabe gedruckt. Ganzzahlige Werte von 1 bis hin zu 4 steigenden Informationsmengen.

compute_context

Legt den Kontext fest, in dem Berechnungen ausgeführt werden, die mit einem gültigen Revoscalepy angegeben werden. RxComputeContext. Derzeit lokal und revoscalepy. RxInSqlServer-Computekontexte werden unterstützt.

Ensemble

Steuerungsparameter für die Ensembling.

Rückkehr

Ein FastTrees Objekt mit dem trainierten Modell.

Hinweis

Dieser Algorithmus ist multithreaded und versucht immer, das gesamte Dataset in den Arbeitsspeicher zu laden.

Siehe auch

rx_fast_forest, rx_predict

References

Wikipedia: Farbverlaufsverstufung (Farbverlaufsbaum-Verstärkung)

Gierfunktion Näherung: Eine Farbverlaufssteigerungsmaschine.

Beispiel für binäre Klassifizierung

'''
Binary Classification.
'''
import numpy
import pandas
from microsoftml import rx_fast_trees, 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)

trees_model = rx_fast_trees(
    formula=" isCase ~ age + parity + education + spontaneous + induced ",
    data=data_train)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(trees_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: 7020 bytes
Starting to train ...
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.0949161
Elapsed time: 00:00:00.0112103
Beginning processing data.
Rows Read: 62, Read Time: 0.001, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0230457
Finished writing 62 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: 0.001 seconds 
  isCase PredictedLabel      Score  Probability
0  False          False  -4.722279     0.131369
1  False          False -11.550012     0.009757
2  False          False  -7.312314     0.050935
3   True           True   3.889991     0.825778
4  False          False  -6.361800     0.072782

Regressionsbeispiel

'''
Regression.
'''
import numpy
import pandas
from microsoftml import rx_fast_trees, 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_trees(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)