rxFastTrees: Fast Tree

Machine Learning: Fast Tree

Verwendung

  rxFastTrees(formula = NULL, data, type = c("binary", "regression"),
    numTrees = 100, numLeaves = 20, learningRate = 0.2, minSplit = 10,
    exampleFraction = 0.7, featureFraction = 1, splitFraction = 1,
    numBins = 255, firstUsePenalty = 0, gainConfLevel = 0,
    unbalancedSets = FALSE, trainThreads = 8, randomSeed = NULL,
    mlTransforms = NULL, mlTransformVars = NULL, rowSelection = NULL,
    transforms = NULL, transformObjects = NULL, transformFunc = NULL,
    transformVars = NULL, transformPackages = NULL, transformEnvir = NULL,
    blocksPerRead = rxGetOption("blocksPerRead"),
    reportProgress = rxGetOption("reportProgress"), verbose = 2,
    computeContext = rxGetOption("computeContext"),
    ensemble = ensembleControl(), ...)

Argumente

formula

Die Formel, wie in rxFormula 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.

type

Eine Zeichenfolge, die den Fast Tree-Typ angibt: "binary" für die standardmäßige binäre Fast Tree-Klassifizierung oder "regression" für Fast Tree-Regression.

numTrees

Gibt die Gesamtanzahl von Entscheidungsstrukturen an, die im Ensemble erstellt werden sollen. Mit einer höheren Anzahl von Entscheidungsstrukturen erzielen Sie u. U. eine bessere Abdeckung, allerdings verlängert sich dadurch auch die Trainingsdauer. Der Standardwert ist 100.

numLeaves

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.

learningRate

Bestimmt die Größe des Schritts in Richtung des Gradienten in jedem Schritt des Lernprozesses. Dieser Wert bestimmt, wie schnell oder langsam das Lernmodul zur optimalen Lösung konvergiert. Ist die Schrittgröße zu groß, wird die optimale Lösung u. U. verfehlt. Wenn die Schrittweite zu klein ist, dauert es länger, bis das Training zur besten Lösung konvergiert.

minSplit

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. Nur die Anzahl der Instanzen wird gezählt, auch wenn Instanzen gewichtet sind.

exampleFraction

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

featureFraction

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

splitFraction

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

numBins

Maximale Anzahl unterschiedlicher Werte (Bins) pro Feature. Wenn das Feature weniger Werte als die angegebene Anzahl hat, wird jeder Wert in einem eigenen Bin abgelegt. Wenn weitere Werte vorhanden sind, erstellt der Algorithmus numBins Bins.

firstUsePenalty

Das Feature verwendet zuerst den Strafkoeffizienten. Dabei handelt es sich um eine Form der Regularisierung, bei der die Verwendung eines neuen Features bei der Erstellung des Baums mit einem Strafterm versehen wird. Erhöhen Sie diesen Wert, um Bäume zu erstellen, die nicht viele Features verwenden. Der Standardwert ist 0.

gainConfLevel

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

unbalancedSets

Falls TRUE, werden für unausgewogene Datasets optimierte Ableitungen verwendet. Gilt nur, wenn type gleich "binary" ist. Der Standardwert ist FALSE.

trainThreads

Die Anzahl der Threads zum Trainieren des Modells. Der Standardwert ist 8.

randomSeed

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

mlTransforms

Gibt eine Liste von MicrosoftML-Transformationen an, die vor dem Training für die Daten erfolgen sollen, oder NULL, wenn keine Transformationen erfolgen sollen. Für unterstützte Transformationen siehe featurizeText, categorical und categoricalHash. Diese Transformationen werden nach allen angegebenen R-Transformationen ausgeführt. Der Standardwert ist NULL.

mlTransformVars

Gibt einen Zeichenvektor von Variablennamen an, die in mlTransforms verwendet werden sollen, oder NULL, wenn keine verwendet werden sollen. Standardwert: NULL.

rowSelection

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. rowSelection = "old" verwendet z. B. nur Beobachtungen, bei denen TRUE der Wert der Variablen old ist. rowSelection = (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 transformFunc). Wie bei allen Ausdrücken kann rowSelection außerhalb des Funktionsaufrufs mit der expression-Funktion definiert werden.

transforms

Ein Ausdruck der Form list(name = expression, ``...), der die erste Runde der Variablentransformationen darstellt. Wie bei allen Ausdrücken kann transforms (oder rowSelection) außerhalb des Funktionsaufrufs mit der expression-Funktion definiert werden.

transformObjects

Eine benannte Liste, die Objekte enthält, auf die mit transforms, transformsFunc und rowSelection verwiesen werden kann.

transformFunc

Die Variablentransformationsfunktionen. Weitere Informationen finden Sie unter „rxTransform“.

transformVars

Ein Zeichenvektor von Eingabedatasetvariablen, die für die Transformationsfunktion erforderlich sind. Weitere Informationen finden Sie unter „rxTransform“.

transformPackages

Ein Zeichenvektor, der zusätzliche R-Pakete (außerhalb der in rxGetOption("transformPackages") angegebenen) angibt, die für die Verwendung in Variablentransformationsfunktionen verfügbar gemacht und im Voraus geladen werden sollen. Zum Beispiel solche, die explizit in RevoScaleR-Funktionen über ihre Argumente transforms und transformFunc definiert sind oder solche, die implizit über ihre Argumente formula oder rowSelection definiert sind. Das Argument transformPackages kann auch NULL lauten, was angibt, dass keine Pakete außerhalb von rxGetOption("transformPackages") im Voraus geladen werden.

transformEnvir

Eine benutzerdefinierte Umgebung, die als übergeordnete Umgebung für alle intern entwickelten Umgebungen dient und für die Transformation von Variablendaten verwendet wird. Falls transformEnvir = NULL, wird stattdessen eine neue „hash“-Umgebung mit der übergeordneten baseenv() verwendet.

blocksPerRead

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

reportProgress

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.

verbose

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.

computeContext

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.

...

Zusätzliche Argumente, die direkt an die Microsoft-Compute-Engine übergeben werden sollen.

Details

rxFastTrees ist eine Implementierung von FastRank. FastRank ist eine effiziente Implementierung des Gradient Boosting-Algorithmus MART. Gradient Boosting ist ein Machine Learning-Verfahren für Regressionsprobleme. Dabei wird jeder Regressionsbaum schrittweise aufgebaut, wobei eine vordefinierte Verlustfunktion verwendet wird, um den Fehler für jeden Schritt zu messen und ihn im nächsten Schritt zu korrigieren. Daher ist dieses Vorhersagemodell tatsächlich ein Ensemble schwächerer Vorhersagemodelle. Bei Regressionsproblemen dient Verstärkung dazu, eine Reihe solcher Bäume schrittweise zu erstellen. Anschließend wird der optimale Baum mithilfe einer beliebig differenzierbaren Verlustfunktion ausgewählt.

MART lernt ein Ensemble von Regressionsbäumen, d. h. einen Entscheidungsbaum mit skalaren Werten in seinen Blättern. Ein Entscheidungs- (bzw. Regressionsbaum) ist ein binäres baumartiges Flussdiagramm, bei dem an jedem inneren Knoten auf Grundlage eines der Featurewerte aus der Eingabe entschieden wird, mit welchem der beiden untergeordneten Knoten es weitergeht. Bei jedem Blattknoten wird ein Wert zurückgegeben. Bei den inneren Knoten basiert die Entscheidung auf dem Test "x <= v", wobei x der Wert des Merkmals in der Eingabestichprobe und v einer der möglichen Werte dieses Merkmals ist. Die Funktionen, die mit einer Regressionsstruktur erstellt werden können, sind alle stückweise Konstantenfunktionen.

Ein Ensemble von Bäumen wird erstellt, indem bei jedem Schritt ein Regressionsbaum berechnet wird, der eine Annäherung des Gradienten der Verlustfunktion erzeugt. Anschließend wird er zusammen mit Koeffizienten, die den Verlust des neuen Baums minimieren, dem vorherigen Baum hinzugefügt. Die von MART für eine bestimmte Instanz erzeugte Ausgabe des Ensembles ist die Summe der Ausgaben aller Bäume.

Bei einem binären Klassifizierungsproblem wird die Ausgabe mithilfe einer Art Kalibrierung in Wahrscheinlichkeit konvertiert.

Bei einem Regressionsproblem entspricht die Ausgabe dem vorhergesagten Wert der Funktion.

Bei einem Rangfolgeproblem sind die Instanzen nach dem Ausgabewert des Ensembles geordnet.

Wenn type auf "regression" festgelegt ist, wird eine Regressionsversion von FastTree verwendet. Bei Festlegung auf "ranking" wird eine Rangfolgeversion von FastTree verwendet. Im Rangfolgefall müssen die Instanzen nach der Ausgabe des Strukturensembles sortiert werden. Der einzige Unterschied bei diesen Versionen sind die Kalibrierungseinstellungen, die nur zur Klassifizierung benötigt werden.

Wert

rxFastTrees: Ein rxFastTrees-Objekt mit dem trainierten Modell.

FastTree: Ein Learnerspezifikationsobjekt der Klasse maml für den Fast Tree-Trainer.

Notizen

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

Autor(en)

Microsoft Corporation Microsoft Technical Support

References

Wikipedia: Gradient boosting (Gradient tree boosting)

Greedy function approximation: A gradient boosting machine.

Weitere Informationen

rxFastForest, rxFastLinear, rxLogisticRegression, rxNeuralNet, rxOneClassSvm, featurizeText, categorical, categoricalHash, rxPredict.mlModel.

Beispiele

 # Estimate a binary classification tree
 infert1 <- infert
 infert1$isCase = (infert1$case == 1)
 treeModel <- rxFastTrees(formula = isCase ~ age + parity + education + spontaneous + induced,
         data = infert1)

 # Create xdf file with per-instance results using rxPredict
 xdfOut <- tempfile(pattern = "scoreOut", fileext = ".xdf")
 scoreDS <- rxPredict(treeModel, data = infert1,
    extraVarsToWrite = c("isCase", "Score"), 
    outData = xdfOut)

 rxDataStep(scoreDS, numRows = 10)

 # Clean-up
 file.remove(xdfOut)

 ######################################################################
 # Estimate a regression fast tree

 # Use the built-in data set 'airquality' to create test and train data
 DF <- airquality[!is.na(airquality$Ozone), ]  
 DF$Ozone <- as.numeric(DF$Ozone)
 randomSplit <- rnorm(nrow(DF))
 trainAir <- DF[randomSplit >= 0,]
 testAir <- DF[randomSplit < 0,]
 airFormula <- Ozone ~ Solar.R + Wind + Temp

 # Regression Fast Tree for train data
 fastTreeReg <- rxFastTrees(airFormula, type = "regression", 
     data = trainAir)  

 # Put score and model variables in data frame
 fastTreeScoreDF <- rxPredict(fastTreeReg, data = testAir, 
     writeModelVars = TRUE)

 # Plot actual versus predicted values with smoothed line
 rxLinePlot(Score ~ Ozone, type = c("p", "smooth"), data = fastTreeScoreDF)