rxFastLinear: modelo linear rápido – Ascendente estocástico de coordenada dupla

Artigo
05/23/2023

Um treinador de otimização de SDCA (ascendente estocástico de coordenada dupla) para classificação e regressão binárias lineares.

rxFastLinear é um treinador baseado no método SDCA (ascendente estocástico de coordenada dupla), uma técnica de otimização de ponta para funções de objetivo convexa. O algoritmo pode ser dimensionado para ser usado em grandes conjuntos de dados de memória insuficiente devido a uma implementação semiassíncrona que dá suporte a multithreading. Atualizações primárias e duplas em um segmento separado. Também são fornecidas várias opções de funções de perda. O método SDCA combina várias das melhores propriedades e funcionalidades dos algoritmos de regressão logística e de SVM. Para obter mais informações sobre SDCA, confira as citações na seção de referência.

Os algoritmos de otimização tradicionais, como o SGD (descendente de gradiente estocástico), otimizam a função de perda empírica diretamente. O SDCA escolhe uma abordagem diferente que otimiza o problema de dupla. A função de perda dupla é parametrizada por pesos para cada exemplo. Em cada iteração, quando um exemplo de treinamento do conjunto de dados de treinamento é lido, o peso do exemplo correspondente é ajustado para que a função de perda dupla seja otimizada em relação ao exemplo atual. O SDCA não exige nenhuma taxa de aprendizado para determinar o tamanho da etapa, o que é exigido por vários métodos de descendente de gradiente.

rxFastLinear dá suporte à classificação binária com três tipos de funções de perda no momento: perda de log, perda de dobradiça e perda de dobradiça suavizada. A regressão linear também dá suporte à função de perda ao quadrado. A regularização de rede elástica pode ser especificada pelos parâmetros l2Weight e l1Weight. Observe que o l2Weight tem um efeito sobre a taxa de convergência. Em geral, quanto maior o l2Weight, mais rápida é a convergência do SDCA.

Observe que o rxFastLinear é um algoritmo estocástico de otimização de streaming. O resultado depende da ordem dos dados de treinamento. Para obter resultados reproduzíveis, é recomendado definir shuffle como FALSE e trainThreads como 1.

Uso

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

Argumentos

`formula`

A fórmula é descrita no rxFormula. No momento, não há suporte para termos de interação nem para F() no MicrosoftML.

`data`

Um objeto de fonte de dados ou uma cadeia de caracteres que especifica um arquivo .xdf ou um objeto de dataframe.

`type`

Especifica o tipo de modelo com uma cadeia de caracteres: "binary" para a classificação binária padrão ou "regression" para a regressão linear.

`lossFunction`

Especifica a função de perda empírica a ser otimizada. Para classificação binária, as seguintes opções estão disponíveis:

logLoss: a perda de log. Esse é o padrão.
hingeLoss: a perda de dobradiça do SVM. O respectivo parâmetro representa o tamanho da margem.
smoothHingeLoss: a perda de dobradiça suavizada. O respectivo parâmetro representa a constante de suavização.
Para a regressão linear, no momento há suporte para a perda quadrática squaredLoss. Quando esse parâmetro é definido como NULL, o valor padrão depende do tipo de aprendizado:
logLoss para classificação binária.
squaredLoss para regressão linear.

`l2Weight`

Especifica o peso de regularização de L2. O valor precisa ser não negativo ou NULL. Se NULL for especificado, o valor real será computado automaticamente com base no conjunto de dados. NULL é o valor padrão.

`l1Weight`

Especifica o peso de regularização de L1. O valor precisa ser não negativo ou NULL. Se NULL for especificado, o valor real será computado automaticamente com base no conjunto de dados. NULL é o valor padrão.

`trainThreads`

Especifica quantos threads simultâneos podem ser usados para executar o algoritmo. Quando esse parâmetro é definido como NULL, o número de threads usados é determinado com base no número de processadores lógicos disponíveis para o processo, bem como pela dispersão de dados. Defina-o como 1 para executar o algoritmo em um só thread.

`convergenceTolerance`

Especifica o limite de tolerância usado como um critério de convergência. Ele precisa estar entre 0 e 1. O valor padrão é 0.1. O algoritmo é considerado convergido quando a lacuna de dualidade relativa, que é a proporção entre a lacuna de dualidade e a perda primária, cai abaixo da tolerância de convergência especificada.

`maxIterations`

Especifica um limite superior no número de iterações de treinamento. Esse parâmetro precisa ser positivo ou NULL. Se NULL for especificado, o valor real será computado automaticamente com base no conjunto de dados. Cada iteração exige uma passagem completa nos dados de treinamento. O treinamento é encerrado depois que ocorre uma das duas opções: o número total de iterações atinge o limite superior especificado ou a função de perda é convergida.

`shuffle`

Especifica se os dados de treinamento devem ser embaralhados. Defina TRUE para embaralhar os dados e FALSE para não os embaralhar. O valor padrão é TRUE. O SDCA é um algoritmo estocástico de otimização. Quando o embaralhamento está ativado, os dados de treinamento são embaralhados em cada iteração.

`checkFrequency`

O número de iterações após o qual a função de perda é computada e verificada para determinar se ela foi convergida. O valor especificado precisa ser um inteiro positivo ou NULL. Se for NULL, o valor real será computado automaticamente com base no conjunto de dados. Caso contrário, por exemplo, se checkFrequency = 5 for especificado, a função de perda será computada e a convergência será verificada a cada cinco iterações. A computação da função de perda exige uma passagem completa separada nos dados de treinamento.

`normalize`

Especifica o tipo de normalização automática usado:

"auto": se a normalização for necessária, ela será executada automaticamente. Esse é o valor padrão.
"no": não é executada nenhuma normalização.
"yes": a normalização é executada.
"warn": se a normalização for necessária, uma mensagem de aviso será exibida, mas a normalização não será executada.
A normalização redimensiona intervalos de dados diferentes para uma escala padrão. O dimensionamento de recursos garante que as distâncias entre os pontos de dados sejam proporcionais e permite que vários métodos de otimização, como o descendente de gradiente, sejam convergidos com uma rapidez muito maior. Quando a normalização é executada, um normalizador MaxMin é usado. Ele normaliza os valores em um intervalo [a, b] em que -1 <= a <= 0 e 0 <= b <= 1 e b - a = 1. Esse normalizador preserva a dispersão mapeando zero para zero.

`mlTransforms`

Especifica uma lista de transformações do MicrosoftML a serem executadas nos dados antes do treinamento ou NULL para que nenhuma transformação seja executada. Confira featurizeText, categorical e categoricalHash, para ver as transformações com suporte. Essas transformações são executadas após as transformações R especificadas. O valor padrão é NULL.

`mlTransformVars`

Especifica um vetor de caracteres de nomes de variáveis a serem usados em mlTransforms ou NULL quando não é usado nenhum nome. O valor padrão é NULL.

`rowSelection`

Especifica as linhas (observações) do conjunto de dados que devem ser usadas pelo modelo com o nome de uma variável lógica do conjunto de dados (entre aspas) ou com uma expressão lógica usando variáveis no conjunto de dados. Por exemplo, rowSelection = "old" usará apenas observações nas quais o valor da variável old seja TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) apenas usa observações nas quais o valor da variável age está entre 20 e 65 e o valor de log da variável income é maior que 10. A seleção de linha é executada após o processamento de todas as transformações de dados (confira os argumentos transforms ou transformFunc). Assim como acontece com todas as expressões, é possível definir rowSelection fora da chamada de função usando a função de expressão.

`transforms`

Uma expressão do formato list(name = expression, ``...) que representa a primeira rodada de transformações de variável. Assim como acontece com todas as expressões, é possível definir transforms (ou rowSelection) fora da chamada de função usando a função de expressão.

`transformObjects`

Uma lista nomeada que contém objetos que podem ser referenciados por transforms, transformsFunc e rowSelection.

`transformFunc`

A função de transformação de variável. Confira rxTransform para obter detalhes.

`transformVars`

Um vetor de caracteres de variáveis do conjunto de dados de entrada necessário para a função de transformação. Confira rxTransform para obter detalhes.

`transformPackages`

Um vetor de caracteres que especifica pacotes R adicionais (fora aqueles especificados em rxGetOption("transformPackages")) a serem disponibilizados e pré-carregados para uso em funções de transformação de variável. Por exemplo, os definidos explicitamente nas funções RevoScaleR por meio dos respectivos argumentos transforms e transformFunc ou os definidos implicitamente por meio dos respectivos argumentos formula ou rowSelection. O argumento transformPackages também pode ser NULL, indicando que nenhum pacote fora de rxGetOption("transformPackages") é pré-carregado.

`transformEnvir`

Um ambiente definido pelo usuário para funcionar como um pai de todos os ambientes desenvolvidos internamente e usados para transformação de dados de variável. Se transformEnvir = NULL, um novo ambiente de “hash” com baseenv() pai é usado.

`blocksPerRead`

Especifica o número de blocos a serem lidos em cada parte dos dados lidos da fonte de dados.

`reportProgress`

Um valor inteiro que especifica o nível de relatório sobre o progresso do processamento de linha:

0: não é relatado nenhum progresso.
1: o número de linhas processadas é impresso e atualizado.
2: as linhas processadas e os tempos são relatados.
3: as linhas processadas e todos os tempos são relatados.

`verbose`

Um valor inteiro que especifica a quantidade de saída desejada. Se definido como 0, não será impressa nenhuma saída detalhada durante os cálculos. Valores inteiros de 1 a 4 fornecem quantidades crescentes de informações.

`computeContext`

Define o contexto no qual as computações são executadas, especificado com um RxComputeContext válido. No momento, há suporte para os contextos de computação local e RxInSqlServer.

`ensemble`

Parâmetros de controle para conjuntos.

`...`

Argumentos adicionais a serem passados diretamente para o Microsoft Compute Engine.

Valor

rxFastLinear: um objeto rxFastLinear com o modelo treinado.

FastLinear: um objeto de especificação de aluno da classe maml para o treinador Fast Linear.

Observações

Esse algoritmo é multithreading e não tentará carregar o conjunto de dados inteiro na memória.

Autor(es)

Microsoft Corporation Microsoft Technical Support

Referências

Scaling Up Stochastic Dual Coordinate Ascent

Stochastic Dual Coordinate Ascent Methods for Regularized Loss Minimization

Confira também

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

Exemplos


 # Train a binary classiication 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)