microsoftml.rx_logistic_regression: Regressão Logística

Usage

microsoftml.rx_logistic_regression(formula: str,
    data: [revoscalepy.datasource.RxDataSource.RxDataSource,
    pandas.core.frame.DataFrame], method: ['binary',
    'multiClass'] = 'binary', l2_weight: float = 1,
    l1_weight: float = 1, opt_tol: float = 1e-07,
    memory_size: int = 20, init_wts_diameter: float = 0,
    max_iterations: int = 2147483647,
    show_training_stats: bool = False, sgd_init_tol: float = 0,
    train_threads: int = None, dense_optimizer: bool = False,
    normalize: ['No', 'Warn', 'Auto', 'Yes'] = 'Auto',
    ml_transforms: list = None, ml_transform_vars: list = None,
    row_selection: str = None, transforms: dict = None,
    transform_objects: dict = None, transform_function: str = None,
    transform_variables: list = None,
    transform_packages: list = None,
    transform_environment: dict = None, blocks_per_read: int = None,
    report_progress: int = None, verbose: int = 1,
    ensemble: microsoftml.modules.ensemble.EnsembleControl = None,
    compute_context: revoscalepy.computecontext.RxComputeContext.RxComputeContext = None)

Description

Regressão Logística de Aprendizagem Automática

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 rx_logistic_regression é 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 memory_size 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.

l1_weight: 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.
l2_weight: é preferível para dados que não são esparsos. Puxa grandes pesos para o zero.

Adicionar a penalização de crista à regularização ultrapassa algumas das limitações do laço. Pode melhorar a sua precisão preditiva, por exemplo, quando o número de preditores é superior ao tamanho da amostra. Se x = l1_weight e y = l2_weight, 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.

Arguments

fórmula

A fórmula, conforme descrita em termos revoscalepy.rx_formula Interação, não F() é atualmente suportada no microsoftml.

dados

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

método

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

l2_weight

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

l1_weight

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

opt_tol

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.

memory_size

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.

max_iterations

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.

show_training_stats

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

sgd_init_tol

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.

init_wts_diameter

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.

train_threads

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 train_threads para 1 desligar o multi-threading. Se Nenhum , o número de threads a usar é determinado internamente. O valor predefinido é None.

dense_optimizer

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.

normalizar

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 <= 0 e 0 <= b <= 1 e b - a = 1. Este normalizador preserva a esparsidade ao mapear zero para zero.

ml_transforms

Especifica uma lista de transformações MicrosoftML a realizar nos dados antes do treino ou Nenhuma se não forem realizadas transformações. Veja featurize_text, categorical, e categorical_hash, para transformações que são suportadas. Estas transformações são realizadas após quaisquer transformações em Python especificadas. O valor predefinido é None.

ml_transform_vars

Especifica um vetor de caracteres com nomes de variáveis a serem usados em ml_transforms ou Nenhum se não for necessário usar nenhum. O valor predefinido é None.

row_selection

NÃO SUPORTADO. 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:

row_selection = "old" só usará observações em que o valor da variável old é True.
row_selection = (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 transform_function). Como em todas as expressões, row_selection pode ser definido fora da chamada de função usando a expression função.

transforma

NÃO SUPORTADO. Uma expressão da forma que representa a primeira ronda de transformações de variáveis. Como em todas as expressões, transforms (ou row_selection) pode ser definido fora da chamada de função usando a expression função.

transform_objects

NÃO SUPORTADO. Uma lista nomeada que contém objetos que podem ser referenciados por transforms, transform_function, e row_selection.

transform_function

A função de transformação de variáveis.

transform_variables

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

transform_packages

NÃO SUPORTADO. Um vetor de caracteres que especifica pacotes Python adicionais (para além dos especificados em RxOptions.get_option("transform_packages")) 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 revoscalepy através dos argumentos e transformstransform_function ou aquelas definidas implicitamente através dos argumentos ou formularow_selection . O transform_packages argumento pode também ser Nenhum, indicando que nenhum pacote externo RxOptions.get_option("transform_packages") está pré-carregado.

transform_environment

NÃO SUPORTADO. 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 transform_environment = None, é utilizado um novo ambiente "hash" com o pai revoscalepy.baseenv.

blocks_per_read

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

report_progress

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.

compute_context

Define o contexto em que os cálculos são executados, especificado com uma revoscalpy válida. RxComputeContext. Atualmente local e revoscalepy. São suportados contextos de computação RxInSqlServer .

Ensemble

Parâmetros de controlo para a montagem.

Devoluções

Um LogisticRegression objeto com o modelo treinado.

Observação

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

Consulte também

rx_predict

Referências

Wikipédia: L-BFGS

Wikipédia: Regressão logística

Treino Escalável de Modelos L1-Regularized Log-Linear

Test Run - Regularização L1 e L2 para Aprendizagem Automática

Exemplo de classificação binária

'''
Binary Classification.
'''
import numpy
import pandas
from microsoftml import rx_logistic_regression, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

infert = get_dataset("infert")


import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

infertdf = infert.as_df()
infertdf["isCase"] = infertdf.case == 1
data_train, data_test, y_train, y_test = train_test_split(infertdf, infertdf.isCase)

model = rx_logistic_regression(
    formula=" isCase ~ age + parity + education + spontaneous + induced ",
    data=data_train)

print(model.coef_)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(model, data=data_test,
                     extra_vars_to_write=["isCase", "Score"])
                     
# Print the first five rows
print(rx_data_step(score_ds, number_rows_read=5))

Output:

Automatically adding a MinMax normalization transform, use 'norm=Warn' or 'norm=No' to turn this behavior off.
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 186, Read Time: 0.001, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
LBFGS multi-threading will attempt to load dataset into memory. In case of out-of-memory issues, turn off multi-threading by setting trainThreads to 1.
Beginning optimization
num vars: 6
improvement criterion: Mean Improvement
L1 regularization selected 5 of 6 weights.
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.0646405
Elapsed time: 00:00:00.0083991
OrderedDict([('(Bias)', -1.2366217374801636), ('spontaneous', 1.9391206502914429), ('induced', 0.7497404217720032), ('parity', -0.31517016887664795), ('age', -3.162723260174971e-06)])
Beginning processing data.
Rows Read: 62, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0287290
Finished writing 62 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: 0.001 seconds 
  isCase PredictedLabel     Score  Probability
0  False          False -1.341681     0.207234
1   True           True  0.597440     0.645070
2  False           True  0.544912     0.632954
3  False          False -1.289152     0.215996
4  False          False -1.019339     0.265156

Exemplo de classificação MultiClass

'''
MultiClass Classification
'''
import numpy
import pandas
from microsoftml import rx_logistic_regression, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

iris = get_dataset("iris")

import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

irisdf = iris.as_df()
irisdf["Species"] = irisdf["Species"].astype("category")
data_train, data_test, y_train, y_test = train_test_split(irisdf, irisdf.Species)

model = rx_logistic_regression(
    formula="  Species ~ Sepal_Length + Sepal_Width + Petal_Length + Petal_Width ",
    method="multiClass",
    data=data_train)

print(model.coef_)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(model, data=data_test,
                     extra_vars_to_write=["Species", "Score"])
                     
# Print the first five rows
print(rx_data_step(score_ds, number_rows_read=5))