rxLogisticRegression: regressão logística

Regressão logística de machine learning

Uso

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

Argumentos

formula

A fórmula como descrita em 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

Uma cadeia de caracteres que especifica o tipo de regressão logística: "binary" para a regressão logística de classificação binária padrão ou "multi" para a regressão logística multinomial.

l2Weight

O peso da regularização L2. O valor precisa igual ou superior a 0. O valor padrão é definido como 1.

l1Weight

O peso da regularização L1. O valor precisa igual ou superior a 0. O valor padrão é definido como 1.

optTol

Valor limite para convergência do otimizador. Se a melhoria entre as iterações for menor que o limite, o algoritmo para e retorna o modelo atual. Valores menores são mais lentos, mas mais precisos. O valor padrão é 1e-07.

memorySize

Tamanho da memória de L-BFGS, especificando o número de posições e de gradientes anteriores a serem armazenados para a computação da próxima etapa. Esse parâmetro de otimização limita a quantidade de memória usada para computar a magnitude e a direção da próxima etapa. Quando você especifica menos memória, o treinamento é mais rápido, mas menos preciso. Precisa ser igual ou superior a 1. O valor padrão é 20.

initWtsScale

Define o diâmetro de pesos iniciais que especifica o intervalo do qual os valores dos pesos iniciais são extraídos. Esses pesos são inicializados aleatoriamente de dentro deste intervalo. Por exemplo, se o diâmetro for especificado como d, os pesos serão distribuídos uniformemente entre -d/2 e d/2. O valor padrão é 0, que especifica que todos os pesos são inicializados para 0.

maxIterations

Define o número máximo de iterações. Após esse número de etapas, o algoritmo é interrompido mesmo que não tenha atendido aos critérios de convergência.

showTrainingStats

Especifique TRUE para mostrar as estatísticas dos dados de treinamento e do modelo treinado. Caso contrário, especifique FALSE. O valor padrão é FALSE. Para saber mais sobre estatísticas de modelo, confira summary.mlModel.

sgdInitTol

Defina-o como um número maior que 0 para usar o SGD (descendente de gradiente estocástico) a fim de localizar os parâmetros iniciais. Um conjunto de valores diferentes de zero especifica a tolerância que o SGD usa para determinar a convergência. O valor padrão é 0, especificando que o SGD não é usado.

trainThreads

O número de threads a serem usados no treinamento do modelo. Deve ser definido como o número de núcleos no computador. Observe que o L-BFGS multithreading tenta carregar o conjunto de dados na memória. Em caso de problemas de memória insuficiente, defina trainThreads como 1 para desativar o multithreading. Se definido como NULL, o número de threads a serem usados é determinado internamente. O valor padrão é NULL.

denseOptimizer

Se definido como TRUE, força a densificação dos vetores de otimização internos. Se definido como FALSE, permite que o otimizador de regressão logística use estados internos esparsos ou densos conforme determinar apropriado. A definição de denseOptimizer como TRUE exige que o otimizador interno use um estado interno denso, o que pode ajudar a aliviar a carga no coletor de lixo em algumas variedades de problemas maiores.

normalize

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

• "auto": se a normalização for necessária, ela será executada automaticamente. Essa é a opção 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.

Detalhes

A regressão logística é um método de classificação usado para prever o valor de uma variável dependente categórica por meio da respectiva relação com uma ou mais variáveis independentes que se considera que tenham uma distribuição logística. Se a variável dependente tiver apenas dois valores possíveis (êxito/falha), a regressão logística será binária. Se a variável dependente tiver mais de dois valores possíveis (tipo sanguíneo dados os resultados do teste de diagnóstico), a regressão logística será multinomial.

A técnica de otimização usada para rxLogisticRegression é a memória limitada L-BFGS (Broyden-Fletcher-Goldfarb-Shanno). Os algoritmos L-BFGS e BFGS regular usam métodos quase newtonianos para estimar a matriz hessiana de computação intensiva na equação usada pelo método de Newton para calcular as etapas. Mas a aproximação de L-BFGS usa apenas uma quantidade limitada de memória para computar a direção da próxima etapa, para que ela seja adequada principalmente a problemas com um grande número de variáveis. O parâmetro memorySize especifica o número de posições e de gradientes anteriores a serem armazenados para que sejam usados na computação da próxima etapa.

Esse aprendiz pode usar a regularização de rede elástica: uma combinação linear das regularizações L1 (lasso) e L2 (ridge). A regularização é um método que pode renderizar um problema bem-posto mais resolvível por meio da imposição de restrições que fornecem informações para complementar os dados e que evitam o sobreajuste por meio da penalização de modelos com valores de coeficiente extremos. Esse processo pode aprimorar a generalização do modelo aprendido por meio da seleção da complexidade ideal na compensação de viés-variância. A regularização funciona adicionando a penalidade associada aos valores de coeficiente ao erro da hipótese. Um modelo preciso com valores de coeficiente extremo seria mais penalizado, mas um modelo menos preciso com valores mais conservadores seria menos penalizado. As regularizações L1 e L2 têm efeitos e usos diferentes que são complementares em determinados aspectos.

l1Weight: pode ser aplicado a modelos esparsos, ao trabalhar usando dados altamente dimensionais. Ele obtém os pesos pequenos associados aos recursos que não são tão importantes em direção a 0.

l2Weight: é preferível para dados que não são esparsos. Ele recebe pesos grandes em direção a zero.

A adição da penalidade de cume à regularização supera algumas das limitações
de laço. Assim, é possível aprimorar a precisão preditiva, por exemplo, quando o número de previsões é maior que o tamanho da amostra. Se x = l1Weight e y = l2Weight, ax + by = c define a abrangência linear dos termos de regularização. O valor padrão de x e de y é 1. Uma regularização agressiva pode prejudicar a capacidade preditiva excluindo variáveis importantes do modelo. Portanto, a escolha dos valores ideais para os parâmetros de regularização é importante para o desempenho do modelo de regressão logística.

Valor

rxLogisticRegression: um objeto rxLogisticRegression com o modelo treinado.

LogisticReg: um objeto de especificação de aluno da classe maml para o treinador Reg de Logística.

Observações

Esse algoritmo tentará carregar o conjunto de dados inteiro na memória quando trainThreads > 1 (multithreading).

Autor(es)

Microsoft Corporation Microsoft Technical Support

Referências

Wikipedia: L-BFGS

regression

Training of L1-Regularized Log-Linear Models

and L2 Regularization for Machine Learning

Confira também

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

Exemplos

 # 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,]