rxLogisticRegression: Regressão Logística

Regressão logística do 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 conforme descrita no rxFormula. Termos de interação e F() não são atualmente suportados no MicrosoftML.

data

Um objeto fonte de dados ou uma string de caracteres especificando um arquivo .xdf ou um objeto data frame.

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 regressão logística multinomial.

l2Weight

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

l1Weight

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

optTol

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

memorySize

Tamanho da memória para L-BFGS, especificando o número de posições e 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 calcular a magnitude e a direção da próxima etapa. Quando você especifica menos memória, o treinamento é mais rápido, mas menos preciso. Deve ser maior ou igual a 1 e o valor padrão é 20.

initWtsScale

Define o diâmetro dos pesos iniciais que especifica o intervalo do qual os valores são desenhados para os pesos iniciais. Esses pesos são inicializados aleatoriamente dentro desse intervalo. Por exemplo, se o diâmetro for especificado como sendo 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 será 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, FALSE. O valor padrão é FALSE. Para informações adicionais sobre estatísticas de modelos, veja summary.mlModel.

sgdInitTol

Defina como um número maior que 0 para usar SGD (Descendente de Gradiente Estocástico) para localizar os parâmetros iniciais. Um conjunto de valores não zero especifica o SGD de tolerância usado para determinar a convergência. O valor padrão é 0 especificar que o SGD não é usado.

trainThreads

O número de threads a serem usados no treinamento do modelo. Isso deve ser definido como o número de núcleos no computador. Observe que o L-BFGS multi-threading tenta carregar o conjunto de dados na memória. No caso de problemas de memória insuficiente, defina trainThreads para 1 desativar vários threadings. Se NULL o número de threads a usar é determinado internamente. O valor padrão é NULL.

denseOptimizer

Se TRUE, força a densificação dos vetores de otimização interna. Se FALSEo otimizador de regressão logística habilitar o uso de estados internos esparsos ou densos conforme apropriado. A configuração denseOptimizer para TRUE exigir que o otimizador interno use um estado interno denso, o que pode ajudar a aliviar a carga no coletor de lixo para 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": nenhuma normalização é executada.
  • "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 descendente de gradiente, convergam muito mais rapidamente. Se a normalização for executada, um MaxMin normalizador será usado. Normaliza valores em um intervalo [a, b] onde -1 <= a <= 0e 0 <= b <= 1 e b - a = 1. Esse normalizador preserva a moderação mapeando zero a zero.

mlTransforms

Especifica uma lista de transformações MicrosoftML a serem realizadas nos dados antes do treinamento ou NULL se nenhuma transformação for realizada. Veja featurizeText, categorical e categoricalHash, para transformações que são suportadas. Essas transformações são realizadas após quaisquer transformações R especificadas. O valor padrão é NULL.

mlTransformVars

Especifica um vetor de caracteres com nomes de variáveis a serem usados em mlTransforms ou NULL , caso nenhum seja necessário. 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" só usará observações em que o valor da variável old é TRUE. rowSelection = (age > 20) & (age < 65) & (log(income) > 10) usa apenas observações nas quais o valor da age variável está entre 20 e 65 e o valor da logincome variável é maior que 10. A seleção de linha é executada após o processamento de transformações de dados (consulte 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 rodada 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, transformsFunce rowSelection.

transformFunc

A função de transformação variável. Veja rxTransform para mais detalhes.

transformVars

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

transformPackages

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

transformEnvir

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

blocksPerRead

Especifica o número de blocos a serem lidos para 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 linhas:

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

verbose

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

computeContext

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

ensemble

Controlar parâmetros para ensembling.

...

Argumentos adicionais serão repassados diretamente para o Microsoft Compute Engine.

Detalhes

Regressão Logística é um método de classificação usado para prever o valor de uma variável dependente categórica de sua relação com uma ou mais variáveis independentes consideradas com 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 dado os resultados do teste de diagnóstico), a regressão logística será multinomial.

A técnica de otimização usada rxLogisticRegression é a memória limitada Broyden-Fletcher-Goldfarb-Shanno (L-BFGS). Os algoritmos L-BFGS e BFGS regulares usam métodos quase newtonianos para estimar a matriz hessiana computacionalmente intensiva na equação usada pelo método de Newton para calcular etapas. Mas a aproximação L-BFGS usa apenas uma quantidade limitada de memória para calcular a direção da próxima etapa, de modo que ela seja 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 anteriores a serem armazenados para uso na computação da próxima etapa.

Esse aprendiz pode usar a regularização de rede elástica: uma combinação linear de regularizações L1 (laço) e L2 (ridge). A regularização é um método que pode tornar um problema mal representado mais tratável impondo restrições que fornecem informações para complementar os dados e que impede a sobreajuste penalizando modelos com valores de coeficiente extremos. Isso pode melhorar a generalização do modelo aprendido selecionando a complexidade ideal na compensação de variação de viés. A regularização funciona adicionando a penalidade associada a valores de coeficiente ao erro da hipótese. Um modelo preciso com valores de coeficiente extremos seria mais penalizado, mas um modelo menos preciso com valores mais conservadores seria menos penalizado. A regularização L1 e L2 tem efeitos e usos diferentes complementares em determinados aspectos.

l1Weight: pode ser aplicado a modelos esparsos ao trabalhar com dados de alta dimensão. Ele puxa pequenos pesos de características associadas que são relativamente irrelevantes para 0.

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

Adicionar a penalidade de crista à regularização compensa algumas das penalidades do laço
limitações. Ele pode melhorar sua precisão preditiva, por exemplo, quando o número de preditores é maior que o tamanho da amostra. Se x = l1Weight e y = l2Weight, ax + by = c define o intervalo 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 excluindo variáveis importantes do modelo. Portanto, escolher os valores ideais 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 especificação para aprendizes da classe maml para o instrutor de Registro Logístico.

Observações

Esse algoritmo tentará carregar todo o conjunto de dados na memória quando trainThreads > 1 (vários threadings).

Autor(es)

Microsoft CorporationMicrosoft Technical Support

References

Wikipedia: L-BFGS

regression

Training of L1-Regularized Log-Linear Models

and L2 Regularization for Machine Learning

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