rxLogisticRegression: logistische Regression

Machine Learning: logistische Regression

Verwendung

  rxLogisticRegression(formula = NULL, data, type = c("binary", "multiClass"),
    l2Weight = 1, l1Weight = 1, optTol = 1e-07, memorySize = 20,
    initWtsScale = 0, maxIterations = 2147483647, showTrainingStats = FALSE,
    sgdInitTol = 0, trainThreads = NULL, denseOptimizer = FALSE,
    normalize = "auto", 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 = 1,
    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 Typ der logistischen Regression angibt: "binary" für die standardmäßige binäre logistische Regression zur Klassifizierung oder "multi" für die multinomiale logistische Regression.

l2Weight

Die L2-Regularisierungsgewichtung. Ihr Wert muss größer oder gleich 0 sein, der Standardwert ist auf 1 festgelegt.

l1Weight

Die L1-Regularisierungsgewichtung. Ihr Wert muss größer oder gleich 0 sein, der Standardwert ist auf 1 festgelegt.

optTol

Schwellenwert für Optimiererkonvergenz. Wenn die Verbesserung zwischen Iterationen kleiner als der Schwellenwert ist, wird der Algorithmus beendet und das aktuelle Modell zurückgegeben. Kleinere Werte sind langsamer, aber genauer. Der Standardwert ist 1e-07.

memorySize

Die Arbeitsspeichergröße für L-BFGS, die die Anzahl der bisherigen Positionen und Gradienten angibt, die für die Berechnung des nächsten Schritts gespeichert werden sollen. Dieser Optimierungsparameter begrenzt die Arbeitsspeichermenge, die zur Berechnung der Größe und Richtung des nächsten Schritts verwendet wird. Wenn Sie weniger Speicher angeben, ist das Training zwar schneller, aber ungenauer. Muss größer oder gleich 1 sein, der Standardwert ist20.

initWtsScale

Legt den Durchmesser der anfänglichen Gewichtungen fest, der den Bereich angibt, aus dem die Werte für die anfänglichen Gewichtungen stammen. Diese Gewichtungen werden innerhalb dieses Bereichs nach dem Zufallsprinzip initialisiert. Wenn beispielsweise der Durchmesser mit d angegeben wird, werden die Gewichtungen gleichmäßig zwischen -d/2 und d/2 verteilt. Der Standardwert ist 0, der angibt, dass alle Gewichtungen mit 0 initialisiert werden.

maxIterations

Legt die maximale Anzahl von Iterationen fest. Nach dieser Anzahl von Schritten wird der Algorithmus beendet, auch wenn er die Konvergenzkriterien nicht erfüllt hat.

showTrainingStats

Geben Sie TRUE an, um die Statistik der Trainingsdaten und des trainierten Modells anzuzeigen; andernfalls FALSE. Der Standardwert ist FALSE. Weitere Informationen zu Modellstatistiken finden Sie unter summary.mlModel.

sgdInitTol

Legen Sie diesen Wert auf eine Zahl größer als 0 fest, um stochastische Gradientenabstiege (SGD) zum Ermitteln der Anfangsparameter zu verwenden. Ein Wert ungleich 0 legt die Toleranz fest, die SGD zur Bestimmung der Konvergenz verwendet. Der Standardwert ist 0, was bedeutet, dass SGD nicht verwendet wird.

trainThreads

Die Anzahl der Threads zum Trainieren des Modells. Diese sollte auf die Anzahl der Kerne des Computers festgelegt werden. Beachten Sie, dass bei L-BFGS-Multithreading versucht wird, das Dataset in den Arbeitsspeicher zu laden. Bei Arbeitsspeicherproblemen legen Sie trainThreads auf 1 fest, um Multithreading zu deaktivieren. Falls NULL, wird die Anzahl der zu verwendenden Threads intern bestimmt. Der Standardwert ist NULL.

denseOptimizer

Falls TRUE, wird die Verdichtung der internen Optimierungsvektoren erzwungen. Falls FALSE, kann der Optimierer der logistischen Regression spärliche oder dichte interne Zustände nach eigenem Ermessen verwenden. Bei Festlegen von denseOptimizer auf TRUE muss der interne Optimierer einen dichten internen Zustand verwenden, was die Beanspruchung des Garbage Collectors bei einigen Varianten größerer Probleme verringern kann.

normalize

Gibt den Typ der verwendeten automatischen Normalisierung an:

• "auto": Wenn eine Normalisierung erforderlich ist, erfolgt sie automatisch. Dies ist die Standardoption.
• "no": Es erfolgt keine Normalisierung.
• "yes": Es erfolgt eine Normalisierung.
• "warn": Wenn eine Normalisierung erforderlich ist, wird eine Warnmeldung angezeigt, ohne dass die Normalisierung erfolgt.
  Bei der Normalisierung werden unterschiedliche Datenbereiche anhand einer Standardskala neu skaliert. Die Featureskalierung stellt sicher, dass die Abstände zwischen den Datenpunkten proportional sind und ermöglicht verschiedene Optimierungsmethoden wie den Gradientenabstieg, um wesentlich schneller zu konvergieren. Wenn eine Normalisierung erfolgt, wird die Normalisierungsfunktion MaxMin verwendet. Sie normalisiert Werte im Intervall [a, b], wobei gilt: -1 <= a <= 0 und 0 <= b <= 1 und b - a = 1. Diese Normalisierungsfunktion behält geringe Datendichte bei, indem 0 zu 0 zugeordnet wird.

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

Logistische Regression ist eine Methode zur Klassifizierung, die dazu dient, den Wert einer kategorischen abhängigen Variable anhand ihrer Beziehung zu einer oder mehreren unabhängigen Variablen vorherzusagen, für die eine logistische Verteilung angenommen wird. Wenn die abhängige Variable nur zwei mögliche Werte hat (Erfolg/Fehler), ist die logistische Regression binär. Wenn es für die abhängige Variable mehr als zwei mögliche Werte gibt (Blutgruppe bei Diagnosetestergebnissen), ist die logistische Regression multinomial.

Das für rxLogisticRegression verwendete Optimierungsverfahren ist L-BFGS (Limited Memory Broyden-Fletcher-Goldfarb-Shanno) mit begrenztem Arbeitsspeicher. Sowohl der L-BFGS- als auch der herkömmliche BFGS-Algorithmus verwenden quasi-Newtonsche Methoden, um die rechenintensive Hessian-Matrix in der Gleichung zu schätzen, die von der Newton-Methode zur Berechnung der Schritte verwendet wird. Die L-BFGS-Näherung verwendet jedoch nur eine begrenzte Menge an Arbeitsspeicher, um die Richtung des nächsten Schritts zu berechnen, sodass sie besonders für Probleme mit einer großen Anzahl von Variablen geeignet ist. Der Parameter memorySize gibt die Anzahl der bisherigen Positionen und Gradienten an, die für die Berechnung des nächsten Schritts gespeichert werden sollen.

Dieses Lernmodul kann die elastische Netzregularisierung verwenden: eine lineare Kombination von L1-Regularisierung (Lasso) und L2-Regularisierung (Ridge). Regularisierung ist eine Methode, die ein schlecht gestelltes Problem durch die Auferlegung von Einschränkungen, die Informationen zur Ergänzung der Daten liefern, überschaubarer macht und eine Überanpassung verhindert, indem Modelle mit extremen Koeffizientenwerten mit Straftermen versehen werden. Dadurch kann die Generalisierung des erlernten Modells verbessert werden, indem die optimale Komplexität im Kompromiss zwischen Voreingenommenheit und Varianz ausgewählt wird. Regularisierung funktioniert, indem die Strafterme, die mit Koeffizientenwerten verbunden sind, zum Fehler der Hypothese hinzufügt werden. Ein genaues Modell mit extremen Koeffizientenwerten würde stärker mit Straftermen belegt, während ein weniger genaues Modell mit konservativeren Werten weniger mit Straftermen belegt würde. L1- und L2-Regularisierung haben unterschiedliche Wirkungen und Zwecke, die sich in gewisser Hinsicht ergänzen.

l1Weight kann bei der Arbeit mit hochdimensionalen Daten auf spärliche Modelle angewendet werden. Dabei werden Features mit geringer Gewichtung, die relativ unwichtig sind, gegen 0 gezogen.

l2Weight ist für nicht spärliche Daten vorzuziehen. Hohe Gewichtungen werden gegen 0 gezogen.

Durch Hinzufügen von Ridge-Straftermen zur Regularisierung werden einige der
Einschränkungen von Lasso überwunden. Die Genauigkeit der Prognose kann beispielsweise verbessert werden, wenn die Zahl der Prädiktoren größer ist als der Umfang der Stichprobe. Bei x = l1Weight und y = l2Weight definiert ax + by = c die lineare Spanne der Regularisierungsterme. Der Standardwert von x und y ist 1. Eine aggressive Regularisierung kann die Prognosefähigkeit beeinträchtigen, da wichtige Variablen aus dem Modell ausgeschlossen werden. Daher ist die Auswahl der optimalen Werte für die Regularisierungsparameter wichtig für die Leistung des logistischen Regressionsmodells.

Wert

rxLogisticRegression: Ein rxLogisticRegression-Objekt mit dem trainierten Modell.

LogisticReg: Ein Learnerspezifikationsobjekt der Klasse maml für den Logistic Reg-Trainer.

Notizen

Dieser Algorithmus versucht, das gesamte Dataset in den Arbeitsspeicher zu laden, wenn trainThreads > 1 (Multithreading) festgelegt ist.

Autor(en)

Microsoft Corporation Microsoft Technical Support

References

Wikipedia: L-BFGS

regression

Training of L1-Regularized Log-Linear Models

and L2 Regularization for Machine Learning

Siehe auch

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

Beispiele

 # Estimate a logistic regression model
 logitModel <- rxLogisticRegression(isCase ~ age + parity + education + spontaneous + induced,
                   transforms = list(isCase = case == 1),
                   data = infert)
 # Print a summary of the model
 summary(logitModel)

 # Score to a data frame
 scoreDF <- rxPredict(logitModel, data = infert, 
     extraVarsToWrite = "isCase")

 # Compute and plot the Radio Operator Curve and AUC
 roc1 <- rxRoc(actualVarName = "isCase", predVarNames = "Probability", data = scoreDF) 
 plot(roc1)
 rxAuc(roc1)

 #######################################################################################
 # Multi-class logistic regression  
 testObs <- rnorm(nrow(iris)) > 0
 testIris <- iris[testObs,]
 trainIris <- iris[!testObs,]
 multiLogit <- rxLogisticRegression(
     formula = Species~Sepal.Length + Sepal.Width + Petal.Length + Petal.Width,
     type = "multiClass", data = trainIris)

 # Score the model
 scoreMultiDF <- rxPredict(multiLogit, data = testIris, 
     extraVarsToWrite = "Species")    
 # Print the first rows of the data frame with scores
 head(scoreMultiDF)
 # Look at confusion matrix
 table(scoreMultiDF$Species, scoreMultiDF$PredictedLabel)

 # Look at the observations with incorrect predictions
 badPrediction = scoreMultiDF$Species != scoreMultiDF$PredictedLabel
 scoreMultiDF[badPrediction,]