rxLogisticRegression: Regressão Logística

Regressão Logística de Aprendizagem Automática

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

Argumentos

formula

A fórmula conforme descrita no rxFormula. Os termos de interação e F() não são atualmente suportados no MicrosoftML.

data

Um objeto fonte de dados ou uma cadeia de caracteres que especifica um ficheiro .xdf ou um objeto data frame.

type

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

l2Weight

O peso de regularização L2. O seu valor deve ser maior ou igual a 0 e o valor padrão é definido como 1.

l1Weight

O peso de regularização L1. O seu valor deve ser maior ou igual a 0 e o valor padrão é definido como 1.

optTol

Valor limiar para convergência de otimizadores. Se a melhoria entre iterações for inferior ao limiar, o algoritmo para e devolve o modelo atual. Valores mais pequenos são mais lentos, mas mais precisos. O valor predefinido é 1e-07.

memorySize

Tamanho de memória para L-BFGS, especificando o número de posições e gradientes passados a armazenar para o cálculo do passo seguinte. Este parâmetro de otimização limita a quantidade de memória utilizada para calcular a magnitude e a direção do passo seguinte. Quando especificas menos memória, o treino é mais rápido mas menos preciso. Deve ser maior ou igual a 1 e o valor padrão é 20.

initWtsScale

Define o diâmetro inicial dos pesos que especifica o intervalo a partir do qual os valores são retirados para os pesos iniciais. Estes pesos são inicializados aleatoriamente dentro deste intervalo. Por exemplo, se o diâmetro for especificado como d, então os pesos estão uniformemente distribuídos 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 este número de passos, o algoritmo para mesmo que não tenha cumprido os critérios de convergência.

showTrainingStats

Especifique TRUE para mostrar as estatísticas dos dados de treino e do modelo treinado; caso contrário, FALSE. O valor predefinido é FALSE. Para informações adicionais sobre estatísticas de modelos, consulte summary.mlModel.

sgdInitTol

Definir para um número superior a 0 para usar a Descida Estocástica do Gradiente (SGD) para encontrar os parâmetros iniciais. Um conjunto de valores não nulo especifica a tolerância que o SGD usa para determinar a convergência. O valor padrão especifica 0 que SGD não é utilizado.

trainThreads

O número de threads a usar no treino do modelo. Isto deve ser definido para o número de núcleos na máquina. Note que o multi-threading do L-BFGS tenta carregar o conjunto de dados na memória. Em caso de problemas de falta de memória, defina trainThreads para 1 desligar o multi-threading. Se NULL o número de threads a usar for determinado internamente. O valor predefinido é NULL.

denseOptimizer

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

normalize

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

• "auto": se for necessária normalização, ela é realizada automaticamente. Esta é a escolha padrão.
• "no": não é realizada qualquer normalização.
• "yes": a normalização é realizada.
• "warn": se for necessária normalização, é exibida uma mensagem de aviso, mas a normalização não é realizada.
  A normalização reescala intervalos de dados díspares para uma escala padrão. A escalabilidade de características assegura que as distâncias entre pontos de dados são proporcionais e permite que vários métodos de otimização, como a descida gradiente, convergam muito mais rapidamente. Se for realizada a normalização, é utilizado um MaxMin normalizador. Normaliza valores num intervalo [a, b] onde -1 <= a <= 0e 0 <= b <= 1 e b - a = 1. Este normalizador preserva a esparsidade ao mapear zero para zero.

mlTransforms

Especifica uma lista de transformações MicrosoftML a realizar nos dados antes do treino ou NULL se não forem realizadas transformações. Consulte featurizeText, categorical e categoricalHash, para transformações suportadas. Estas transformações são realizadas após quaisquer transformações R especificadas. O valor predefinido é NULL.

mlTransformVars

Especifica um vetor de caracteres com nomes de variáveis a serem usados em mlTransforms ou NULL , se não forem necessários. O valor predefinido é NULL.

rowSelection

Especifica as linhas (observações) do conjunto de dados que serão 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 do conjunto de dados. Por exemplo, rowSelection = "old" só usará observações em que o valor da variável old é TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) só utiliza observações em que o valor da age variável está entre 20 e 65 e o valor log da income variável é superior a 10. A seleção de linhas é realizada após o processamento de quaisquer transformações de dados (ver os argumentos transforms ou transformFunc). Como em todas as expressões, rowSelection pode ser definido fora da chamada de função usando a função de expressão.

transforms

Uma expressão da forma list(name = expression, ``...) que representa a primeira ronda de transformações de variáveis. Como em todas as expressões, transforms (ou rowSelection) pode ser definido 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áveis. Consulte rxTransform para mais detalhes.

transformVars

Um vetor de caracteres das variáveis do conjunto de dados de entrada necessárias para a função de transformação. Consulte rxTransform para mais detalhes.

transformPackages

Um vetor de caracteres que especifica pacotes adicionais R (para além dos especificados em rxGetOption("transformPackages")) a serem disponibilizados e pré-carregados para uso em funções de transformação de variáveis. Por exemplo, aquelas definidas explicitamente em funções do RevoScaleR através dos argumentos their transforms and transformFunc ou aquelas definidas implicitamente através dos argumentos their formula or rowSelection . O argumento transformPackages pode também ser NULL, indicando que nenhum pacote externo rxGetOption("transformPackages") está pré-carregado.

transformEnvir

Um ambiente definido pelo utilizador para servir como pai de todos os ambientes desenvolvidos internamente e usados para transformação de dados variáveis. Se transformEnvir = NULL, é utilizado em vez disso um novo ambiente "hash" com o pai baseenv() .

blocksPerRead

Especifica o número de blocos a ler para cada bloco de dados lido da fonte de dados.

reportProgress

Um valor inteiro que especifica o nível de reporte sobre o progresso do processamento da linha:

• 0: Não há progresso reportado.
• 1: o número de linhas processadas é impresso e atualizado.
• 2: as linhas processadas e os tempos são reportados.
• 3: linhas processadas e todos os tempos são reportados.

verbose

Um valor inteiro que especifica a quantidade de saída desejada. Se 0, não é impressa nenhuma saída detalhada durante os cálculos. Valores inteiros de 1 para 4 fornecer quantidades crescentes de informação.

computeContext

Define o contexto em que os cálculos são executados, especificado com um RxComputeContext válido. Atualmente, são suportados contextos de computação locais e RxInSqlServer.

ensemble

Parâmetros de controlo para a montagem.

...

Argumentos adicionais a serem transmitidos diretamente ao Microsoft Compute Engine.

Detalhes

Regressão Logística é um método de classificação utilizado para prever o valor de uma variável dependente categórica a partir da sua relação com uma ou mais variáveis independentes assumidas como tendo uma distribuição logística. Se a variável dependente tiver apenas dois valores possíveis (sucesso/fracasso), então a regressão logística é binária. Se a variável dependente tiver mais de dois valores possíveis (grupo sanguíneo dado os resultados dos testes diagnósticos), então a regressão logística é multinomial.

A técnica de otimização utilizada para rxLogisticRegression é a memória limitada Broyden-Fletcher-Goldfarb-Shanno (L-BFGS). Tanto os algoritmos L-BFGS como os BFGS regulares utilizam métodos quase-newtonianos para estimar a matriz de Hessiana, que é computacionalmente intensiva, na equação usada pelo método de Newton para calcular os passos. Mas a aproximação L-BFGS usa apenas uma quantidade limitada de memória para calcular a direção do passo seguinte, sendo especialmente adequada para problemas com um grande número de variáveis. O memorySize parâmetro especifica o número de posições e gradientes passados a armazenar para uso no cálculo do passo seguinte.

Este aprendiz pode usar regularização elástica em rede: uma combinação linear de regularizações L1 (laço) e L2 (crista). A regularização é um método que pode tornar um problema mal colocado mais fácil ao impor restrições que fornecem informação para complementar os dados e que previne o sobreajuste penalizando modelos com valores extremos de coeficientes. Isto pode melhorar a generalização do modelo aprendido ao selecionar a complexidade ótima no compromisso viés-variância. A regularização funciona adicionando a penalização associada aos valores dos coeficientes ao erro da hipótese. Um modelo preciso com valores extremos de coeficientes seria mais penalizado, mas um modelo menos preciso com valores mais conservativos seria menos penalizado. A regularização L1 e L2 têm efeitos e usos diferentes que são complementares em certos aspetos.

l1Weight: pode ser aplicado a modelos esparsos, quando se trabalha com dados de alta dimensão. Puxa pequenos pesos e características associadas que são relativamente pouco importantes para 0.

l2Weight: é preferível para dados que não são esparsos. Puxa grandes pesos para o zero.

Adicionar a penalização da crista à regularização compensa algumas das falhas do laço
limitações. Pode melhorar a sua precisão preditiva, por exemplo, quando o número de preditores é superior ao tamanho da amostra. Se x = l1Weight e y = l2Weight, ax + by = c define o escuro linear dos termos de regularização. Os valores padrão de x e y são ambos 1. Uma regularização agressiva pode prejudicar a capacidade preditiva ao excluir variáveis importantes do modelo. Por isso, escolher os valores ótimos para os parâmetros de regularização é importante para o desempenho do modelo de regressão logística.

Value

rxLogisticRegression: Um rxLogisticRegression objeto com o modelo treinado.

LogisticReg: Um objeto de classe maml de especificação de aprendiz para o formador de Registo Logístico.

Notes

Este algoritmo tentará carregar todo o conjunto de dados na memória quando trainThreads > 1 (multi-threading).

Autor(es)

Microsoft CorporationMicrosoft Technical Support

References

Wikipedia: L-BFGS

regression

Training of L1-Regularized Log-Linear Models

and L2 Regularization for Machine Learning

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