rxFastLinear: modello di regressione lineare veloce - SDCA (Stochastic Dual Coordinate Ascent)

Articolo
05/23/2023

Programma di training per l'ottimizzazione SDCA (Stochastic Dual Coordinate Ascent) per la regressione e la classificazione binaria lineari.

rxFastLinear è un programma di training basato sul metodo SDCA (Stochastic Dual Coordinate Ascent), una tecnica di ottimizzazione all'avanguardia per le funzioni obiettivo convesse. L'algoritmo può essere ridimensionato per l'uso in set di dati di grandi dimensioni con memoria insufficiente a causa di un'implementazione semi asincronizzata che supporta il multithreading. aggiornamenti primali e duali in un thread separato. Sono inoltre disponibili diverse opzioni di funzioni di perdita. Il metodo SDCA combina diverse delle migliori proprietà e funzionalità degli algoritmi di regressione logistica e SVM. Per altre informazioni su SDCA, vedere le citazioni nella sezione dei riferimenti.

Gli algoritmi di ottimizzazione tradizionali, ad esempio la discesa stocastica del gradiente (SGD, Stochastic Gradient Descent), ottimizzano direttamente la funzione di perdita empirica. SDCA sceglie invece un approccio diverso che ottimizza il problema duale. La funzione di perdita duale è parametrizzata da pesi per campione. In ogni iterazione, quando viene letto un esempio di training del set di dati di training, il peso di esempio corrispondente viene regolato in modo che la funzione di perdita duale sia ottimizzata rispetto all'esempio corrente. SDCA non necessita di alcuna velocità di apprendimento per determinare le dimensioni dei passaggi richiesti da vari metodi di discesa del gradiente.

rxFastLinear supporta attualmente la classificazione binaria con tre tipi di funzioni di perdita: perdita logaritmica, perdita di cerniera e perdita di cerniera graduata. La regressione lineare supporta anche con la funzione di perdita al quadrato. La regolarizzazione della rete elastica può essere specificata dai parametri l2Weight e l1Weight. Si noti che l2Weight ha un effetto sul tasso di convergenza. In generale, più grande è l2Weight, più veloce sarà la convergenza di SDCA.

Si noti che rxFastLinear è un algoritmo di ottimizzazione stocastico e di streaming. Il risultato dipende dall'ordine dei dati di training. Per i risultati riproducibili, è consigliabile impostare shuffle su FALSE e trainThreads su 1.

Utilizzo

  rxFastLinear(formula = NULL, data, type = c("binary", "regression"),
    lossFunction = NULL, l2Weight = NULL, l1Weight = NULL,
    trainThreads = NULL, convergenceTolerance = 0.1, maxIterations = NULL,
    shuffle = TRUE, checkFrequency = NULL, 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`

Formula descritta in rxFormula. I termini di interazione e F() non sono attualmente supportati in MicrosoftML.

`data`

Oggetto origine dati o stringa di caratteri che specifica un file con estensione xdf o un oggetto frame di dati.

`type`

Specifica il tipo di modello con una stringa di caratteri "binary" per la classificazione binaria predefinita o "regression" per la regressione lineare.

`lossFunction`

Specifica la funzione di perdita empirica da ottimizzare. Per la classificazione binaria, sono disponibili le opzioni seguenti:

logLoss: perdita logaritmica. Questo è il valore predefinito.
hingeLoss: perdita di cerniera SVM. Il rispettivo parametro rappresenta le dimensioni del margine.
smoothHingeLoss: perdita di cerniera graduata. Il relativo parametro rappresenta la costante di graduazione.
Per la regressione è attualmente supportata la perdita al quadrato squaredLoss. Quando questo parametro è impostato su NULL, il rispettivo valore predefinito dipende dal tipo di apprendimento:
logLoss per la classificazione binaria.
squaredLoss per la regressione lineare.

`l2Weight`

Specifica il peso di regolarizzazione L2. Il valore deve essere non negativo o NULL. Se viene specificato NULL, il valore effettivo verrà calcolato automaticamente in base al set di dati. NULL è il valore predefinito.

`l1Weight`

Specifica il peso di regolarizzazione L1. Il valore deve essere non negativo o NULL. Se viene specificato NULL, il valore effettivo verrà calcolato automaticamente in base al set di dati. NULL è il valore predefinito.

`trainThreads`

Specifica il numero di thread simultanei che è possibile usare per eseguire l'algoritmo. Quando questo parametro è impostato su NULL, il numero di thread usati viene determinato in base al numero di processori logici disponibili per il processo, nonché alla densità dei dati. Impostarlo su 1 per eseguire l'algoritmo in un singolo thread.

`convergenceTolerance`

Specifica la soglia di tolleranza usata come criterio di convergenza. Deve essere un valore compreso tra 0 e 1. Il valore predefinito è 0.1. L'algoritmo viene considerato convergente se il divario di dualità relativo, ovvero il rapporto tra il divario di dualità e la perdita primaria, scende al di sotto della tolleranza di convergenza specificata.

`maxIterations`

Specifica un limite superiore per il numero di iterazioni di training. Questo parametro deve essere positivo o NULL. Se viene specificato NULL, il valore effettivo verrà calcolato automaticamente in base al set di dati. Ogni iterazione richiede un passaggio completo sui dati di training. Il training termina dopo che il numero totale di iterazioni raggiunge il limite superiore specificato o quando la funzione di perdita converge, a seconda di quale evento si verifichi per primo.

`shuffle`

Specifica se mischiare i dati di training. Impostare TRUE per mischiare i dati, FALSE per non mischiarli. Il valore predefinito è TRUE. SDCA è un algoritmo di ottimizzazione stocastica. Se l'opzione per mischiare i dati è attivata, i dati di training vengono mischiati per ogni iterazione.

`checkFrequency`

Numero di iterazioni dopo le quali viene calcolata e verificata la funzione di perdita per determinare se è convergente. Il valore specificato deve essere un numero intero positivo o NULL. Se è NULL, il valore effettivo verrà calcolato automaticamente in base al set di dati. In caso contrario, se viene specificato checkFrequency = 5, la funzione di perdita verrà calcolata e la convergenza verrà controllata ogni 5 iterazioni. Il calcolo della funzione di perdita richiede un passaggio completo separato sui dati di training.

`normalize`

Specifica il tipo di normalizzazione automatica usata:

"auto": se la normalizzazione è necessaria, viene eseguita automaticamente. Si tratta del valore predefinito.
"no": non viene eseguita alcuna normalizzazione.
"yes": la normalizzazione viene eseguita.
"warn": se la normalizzazione è necessaria, viene visualizzato un avviso ma la normalizzazione non viene eseguita.
La normalizzazione ridimensiona diversi intervalli di dati in base a una scala standard. Il ridimensionamento delle funzioni assicura che le distanze tra i punti dati siano proporzionali e consente di accelerare significativamente la convergenza di diversi metodi di ottimizzazione, tra cui la discesa di gradiente. Se la normalizzazione viene eseguita, viene usato un normalizzatore MaxMin. I valori vengono normalizzati in un intervallo [a, b], dove -1 <= a <= 0 e 0 <= b <= 1 e b - a = 1. Questo normalizzatore mantiene la sparsità eseguendo il mapping di zero a zero.

`mlTransforms`

Specifica un elenco di trasformazioni di MicrosoftML da eseguire sui dati prima del training o NULL se non devono essere eseguite trasformazioni. Per informazioni sulle trasformazioni supportate, vedere featurizeText, categorical e categoricalHash. Queste trasformazioni vengono eseguite dopo eventuali trasformazioni R specificate. Il valore predefinito è NULL.

`mlTransformVars`

Specifica un vettore di caratteri di nomi di variabili da usare in mlTransforms o NULL se non è necessario usarne alcuno. Il valore predefinito è NULL.

`rowSelection`

Specifica le righe (osservazioni) dal set di dati che devono essere usate dal modello con il nome di una variabile logica dal set di dati (tra virgolette) o con un'espressione logica tramite variabili nel set di dati. Ad esempio, rowSelection = "old" userà solo osservazioni in cui il valore della variabile old è TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) usa solo osservazioni in cui il valore della variabile age è compreso tra 20 e 65 e il valore di log della variabile income è maggiore di 10. La selezione delle righe viene eseguita dopo l'elaborazione di eventuali trasformazioni dei dati. Vedere gli argomenti transforms o transformFunc. Analogamente a tutte le espressioni, è possibile definire rowSelection all'esterno della chiamata alla funzione usando la funzione di espressione.

`transforms`

Espressione con formato list(name = expression, ``...) che rappresenta il primo ciclo di trasformazioni delle variabili. Analogamente a tutte le espressioni, è possibile definire transforms o rowSelection all'esterno della chiamata alla funzione usando la funzione di espressione.

`transformObjects`

Elenco denominato che contiene oggetti a cui transforms, transformsFunce rowSelection possono fare riferimento.

`transformFunc`

Funzione di trasformazione della variabile. Per informazioni dettagliate, vedere rxTransform.

`transformVars`

Vettore di caratteri delle variabili del set di dati di input necessario per la funzione di trasformazione. Per informazioni dettagliate, vedere rxTransform.

`transformPackages`

Vettore di caratteri che specifica altri pacchetti R, oltre a quelli specificati in rxGetOption("transformPackages"), da rendere disponibili e precaricati per l'uso nelle funzioni di trasformazione delle variabili. Ad esempio, quelli definiti in modo esplicito nelle funzioni RevoScaleR tramite i relativi argomenti transforms e transformFunc o quelli definiti in modo implicito tramite i relativi argomenti formula o rowSelection. L'argomento transformPackages può anche essere NULL, che indica che non vengono precaricati pacchetti esterni a rxGetOption("transformPackages").

`transformEnvir`

Ambiente definito dall'utente da usare come elemento padre di tutti gli ambienti sviluppati internamente e usati per la trasformazione dei dati delle variabili. Se transformEnvir = NULL, viene invece usato un nuovo ambiente "hash" con padre baseenv().

`blocksPerRead`

Specifica il numero di blocchi da leggere per ogni blocco di dati letto dall'origine dati.

`reportProgress`

Valore intero che specifica il livello di creazione di report sullo stato di elaborazione delle righe:

0: non viene segnalato alcun avanzamento.
1: il numero di righe elaborate viene stampato e aggiornato.
2: vengono segnalate le righe elaborate e le tempistiche.
3: vengono segnalate le righe elaborate e tutte le tempistiche.

`verbose`

Valore intero che specifica la quantità di output desiderata. Se 0, non viene stampato alcun output dettagliato durante i calcoli. Valori interi da 1 a 4 per fornire quantità crescenti di informazioni.

`computeContext`

Imposta il contesto in cui vengono eseguiti i calcoli, specificato con un RxComputeContext valido. Sono attualmente supportati contesti di calcolo locali e RxInSqlServer.

`ensemble`

Parametri di controllo per l'ensembling.

`...`

Argomenti aggiuntivi da passare direttamente al motore di calcolo Microsoft.

Valore

rxFastLinear: oggetto rxFastLinear con il modello sottoposto a training.

FastLinear: oggetto di specifica dello strumento di apprendimento con classe maml per il programma di training lineare veloce.

Note

Questo algoritmo è multithreading e non proverà a caricare l'intero set di dati in memoria.

Autore/i

Microsoft Corporation Microsoft Technical Support

Riferimenti

Scaling Up Stochastic Dual Coordinate Ascent

Stochastic Dual Coordinate Ascent Methods for Regularized Loss Minimization

Vedi anche

logLoss, hingeLoss, smoothHingeLoss, squaredLoss, rxFastTrees, rxFastForest, rxLogisticRegression, rxNeuralNet, rxOneClassSvm, featurizeText, categorical, categoricalHash, rxPredict.mlModel.

Esempi


 # Train a binary classification model with rxFastLinear
 res1 <- rxFastLinear(isCase ~ age + parity + education + spontaneous + induced,
                   transforms = list(isCase = case == 1),
                   data = infert,
                   type = "binary")
 # Print a summary of the model
 summary(res1)

 # Score to a data frame
 scoreDF <- rxPredict(res1, 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)

 #########################################################################
 # rxFastLinear Regression

 # Create an xdf file with the attitude data
 myXdf <- tempfile(pattern = "tempAttitude", fileext = ".xdf")
 rxDataStep(attitude, myXdf, rowsPerRead = 50, overwrite = TRUE)
 myXdfDS <- RxXdfData(file = myXdf)

 attitudeForm <- rating ~ complaints + privileges + learning + 
     raises + critical + advance

 # Estimate a regression model with rxFastLinear 
 res2 <- rxFastLinear(formula = attitudeForm,  data = myXdfDS, 
     type = "regression")

 # Score to data frame
 scoreOut2 <- rxPredict(res2, data = myXdfDS, 
     extraVarsToWrite = "rating")

 # Plot the rating versus the score with a regression line
 rxLinePlot(rating~Score, type = c("p","r"), data = scoreOut2)

 # Clean up   
 file.remove(myXdf)

Condividi tramite