rxLogisticRegression: Logistisk regression

Logistisk regression för maskininlärning

Usage

  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(), ...)

Arguments

formula

Formeln som beskrivs i rxFormula. Interaktionstermer och F() stöds för närvarande inte i MicrosoftML.

data

Ett datakällobjekt eller en teckensträng som specificerar en .xdf-fil eller ett dataramsobjekt.

type

En teckensträng som anger typen av logistisk regression: "binary" för standardlogikregression för binär klassificering eller "multi" för multinom logistisk regression.

l2Weight

L2-regulariseringsvikten. Dess värde måste vara större än eller lika med 0 och standardvärdet är inställt på 1.

l1Weight

L1-regulariseringsvikten. Dess värde måste vara större än eller lika med 0 och standardvärdet är inställt på 1.

optTol

Tröskelvärde för optimerarkonvergens. Om förbättringen mellan iterationer är mindre än tröskelvärdet stoppas algoritmen och returnerar den aktuella modellen. Mindre värden är långsammare, men mer exakta. Standardvärdet är 1e-07.

memorySize

Minnesstorlek för L-BFGS, som anger antalet tidigare positioner och toningar som ska lagras för beräkningen av nästa steg. Den här optimeringsparametern begränsar mängden minne som används för att beräkna omfattningen och riktningen för nästa steg. När du anger mindre minne är träningen snabbare men mindre exakt. Måste vara större än eller lika med 1 och standardvärdet är 20.

initWtsScale

Anger den inledande viktdiametern som anger det intervall från vilket värden ritas för de initiala vikterna. Dessa vikter initieras slumpmässigt från det här intervallet. Om diametern till exempel anges som d, fördelas vikterna jämnt mellan -d/2 och d/2. Standardvärdet är 0, som anger att alla vikter initieras till 0.

maxIterations

Anger det maximala antalet iterationer. Efter det här antalet steg stoppas algoritmen även om den inte uppfyller konvergenskriterierna.

showTrainingStats

Ange TRUE för att visa statistik för träningsdata och den tränade modellen, FALSEannars . Standardvärdet är FALSE. För ytterligare information om modellstatistik, se summary.mlModel.

sgdInitTol

Ange till ett tal större än 0 för att använda SGD (Stochastic Gradient Descent) för att hitta de inledande parametrarna. En värdeuppsättning som inte är noll anger den tolerans som SGD använder för att fastställa konvergens. Standardvärdet anger 0 att SGD inte används.

trainThreads

Antalet trådar som ska användas för att träna modellen. Detta bör anges till antalet kärnor på datorn. Observera att L-BFGS försöker läsa in datamängden i minnet. Om det uppstår problem med att minnet är slut ställer du in trainThreads1 på att inaktivera multitrådning. Om NULL antalet trådar som ska användas bestäms internt. Standardvärdet är NULL.

denseOptimizer

Om TRUEtvingar fram förtätning av de interna optimeringsvektorerna. Om FALSEaktiverar aktiverar den logistiska regressionsoptimeraren använder glesa eller täta interna tillstånd som det finner lämpligt. Inställningen denseOptimizer kräver att TRUE den interna optimeraren använder ett tätt internt tillstånd, vilket kan hjälpa till att minska belastningen på skräpinsamlaren för vissa sorter av större problem.

normalize

Anger vilken typ av automatisk normalisering som används:

  • "auto": Om normalisering behövs utförs den automatiskt. Det här är standardalternativet.
  • "no": ingen normalisering utförs.
  • "yes": normalisering utförs.
  • "warn": Om normalisering behövs visas ett varningsmeddelande, men normaliseringen utförs inte.
    Normaliseringen skalar om olika dataintervall till en standardskala. Funktionsskalning försäkrar att avstånden mellan datapunkter är proportionella och gör det möjligt för olika optimeringsmetoder som gradient descent att konvergera mycket snabbare. Om normalisering utförs används en MaxMin normaliserare. Den normaliserar värden i ett intervall [a, b] där -1 <= a <= 0och 0 <= b <= 1 och b - a = 1. Den här normaliseraren bevarar gleshet genom att mappa noll till noll.

mlTransforms

Specificerar en lista över MicrosoftML-transformationer som ska utföras på datan före träning eller NULL om inga transformationer ska utföras. Se featurizeText, categorical och categoricalHash för transformationer som stöds. Dessa transformationer utförs efter alla specificerade R-transformationer. Standardvärdet är NULL.

mlTransformVars

Specificerar en teckenvektor med variabelnamn som ska användas i mlTransforms eller NULL om inga ska användas. Standardvärdet är NULL.

rowSelection

Anger raderna (observationer) från datauppsättningen som ska användas av modellen med namnet på en logisk variabel från datauppsättningen (inom citattecken) eller med ett logiskt uttryck med variabler i datauppsättningen. Till exempel använder endast rowSelection = "old" observationer där variabelns värde old är TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) använder endast observationer där variabelns age värde är mellan 20 och 65 och värdet för variabeln logincome är större än 10. Radmarkeringen utförs efter bearbetning av datatransformeringar (se argumenten transforms eller transformFunc). Som med alla uttryck kan definieras rowSelection utanför funktionsanropet med uttrycksfunktionen.

transforms

Ett uttryck av formen list(name = expression, ``...) som representerar den första omgången av variabeltransformationer. Som med alla uttryck transforms kan (eller rowSelection) definieras utanför funktionsanropet med uttrycksfunktionen.

transformObjects

En namngiven lista som innehåller objekt som kan refereras till av transforms, transformsFuncoch rowSelection.

transformFunc

Funktionen för variabeltransformeringen. Se rxTransform för detaljer.

transformVars

En teckenvektor för indatauppsättningsvariabler som behövs för transformeringsfunktionen. Se rxTransform för detaljer.

transformPackages

En teckenvektor som specificerar ytterligare R-paket (utöver de som anges i rxGetOption("transformPackages")) som ska göras tillgängliga och förladdas för användning i variabeltransformationsfunktioner. Till exempel fungerar de som explicit definieras i RevoScaleR via deras transforms och-argument transformFunc eller de som definieras implicit via deras formula eller rowSelection argument. Argumentet transformPackages kan också vara NULL, vilket indikerar att inga paket utanför rxGetOption("transformPackages") är förladdade.

transformEnvir

En användardefinierad miljö som fungerar som överordnad till alla miljöer som utvecklats internt och används för variabel datatransformering. Om transformEnvir = NULL, används istället en ny "hash"-miljö med förälder.baseenv()

blocksPerRead

Anger antalet block som ska läsas för varje segment av data som läss från datakällan.

reportProgress

Ett heltalsvärde som anger rapporteringsnivån för radbearbetningsförloppet:

  • 0: Inga förlopp rapporteras.
  • 1: Antalet bearbetade rader skrivs ut och uppdateras.
  • 2: Rader som bearbetas och tidsinställningar rapporteras.
  • 3: bearbetade rader och alla tidsinställningar rapporteras.

verbose

Ett heltalsvärde som anger önskad mängd utdata. Om 0skrivs inga utförliga utdata ut under beräkningar. Heltalsvärden från 1 för att 4 ge ökande mängder information.

computeContext

Sätter kontexten där beräkningar utförs, specificerad med en giltig RxComputeContext. För närvarande stöds lokala och RxInSqlServer-beräkningskontexter.

ensemble

Kontrollparametrar för montering.

...

Ytterligare argument ska skickas direkt till Microsoft Compute Engine.

Detaljer

Logistisk regression är en klassificeringsmetod som används för att förutsäga värdet för en kategorisk beroende variabel från relationen till en eller flera oberoende variabler som antas ha en logistisk distribution. Om den beroende variabeln bara har två möjliga värden (lyckade/misslyckade) är den logistiska regressionen binär. Om den beroende variabeln har fler än två möjliga värden (blodtyp givet diagnostiska testresultat) är den logistiska regressionen multinomiell.

Optimeringstekniken som används för rxLogisticRegression är det begränsade minnet Broyden-Fletcher-Goldfarb-Shanno (L-BFGS). Både L-BFGS- och vanliga BFGS-algoritmer använder kvasi-newtonska metoder för att uppskatta den beräkningsintensiva hessiska matrisen i den ekvation som används av Newtons metod för att beräkna steg. Men L-BFGS-uppskattningen använder bara en begränsad mängd minne för att beräkna nästa stegriktning, så att den är särskilt lämplig för problem med ett stort antal variabler. Parametern memorySize anger antalet tidigare positioner och toningar som ska lagras för användning i beräkningen av nästa steg.

Den här eleven kan använda elastisk net regularisering: en linjär kombination av L1-regulariseringar (lasso) och L2 (ås). Regularisering är en metod som kan göra ett illa ställt problem mer lätthanterligt genom att införa begränsningar som ger information för att komplettera data och som förhindrar överanpassning genom att straffa modeller med extrema koefficientvärden. Detta kan förbättra generaliseringen av modellen som lärts genom att välja den optimala komplexiteten i kompromissen mellan bias och varians. Regularisering fungerar genom att lägga till straffvärdet som är associerat med koefficientvärden i hypotesens fel. En korrekt modell med extrema koefficientvärden skulle straffas mer, men en mindre exakt modell med mer konservativa värden skulle straffas mindre. L1- och L2-regularisering har olika effekter och användningsområden som kompletterar varandra i vissa avseenden.

l1Weight: kan tillämpas på glesa modeller när du arbetar med högdimensionella data. Den drar små vikter av tillhörande egenskaper som är relativt oviktiga mot 0.

l2Weight: är att föredra för data som inte är glesa. Den drar stora vikter mot noll.

Att lägga till åsstraffet till regulariseringen övervinner vissa av lassons
begränsningar. Det kan förbättra dess förutsägelsenoggrannhet, till exempel när antalet prediktorer är större än urvalsstorleken. If x = l1Weight och y = l2Weight, ax + by = c definierar det linjära intervallet för regulariseringstermerna. Standardvärdena för x och y är båda 1. En aggressiv regularisering kan skada förutsägelsekapaciteten genom att undanta viktiga variabler från modellen. Därför är det viktigt att välja de optimala värdena för regulariseringsparametrarna för prestanda för den logistiska regressionsmodellen.

Värde

rxLogisticRegression: Ett rxLogisticRegression objekt med den tränade modellen.

LogisticReg: Ett lärarspecifikationsobjekt för klassen maml för Logistic Reg-tränaren.

Notes

Den här algoritmen försöker läsa in hela datamängden i minnet när trainThreads > 1 (flera trådar).

Författare(r)

Microsoft CorporationMicrosoft Technical Support

References

Wikipedia: L-BFGS

regression

Training of L1-Regularized Log-Linear Models

and L2 Regularization for Machine Learning

Se även

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

Exempel


 # 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,]
  • Last updated on