Partilhar via


microsoftml.rx_logistic_regression: regressão logística

Uso

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)

Descrição

Regressão logística de machine learning

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

  • l1_weight: 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.

  • l2_weight: é 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 ridge à regularização supera algumas das limitações de lasso. 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 = l1_weight e y = l2_weight, 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.

Argumentos

formula

No momento, não há suporte para a fórmula, conforme a descrição nos termos de interação de revoscalepy.rx_formula e 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.

method

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

l2_weight

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

l1_weight

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

opt_tol

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.

memory_size

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.

max_iterations

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.

show_training_stats

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 obter mais informações sobre estatísticas de modelo, confira summary.ml_model().

sgd_init_tol

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.

init_wts_diameter

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 em 0.

train_threads

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 train_threads como 1 para desativar o multithreading. Se definido como None, o número de threads a serem usados é determinado internamente. O valor padrão é None.

dense_optimizer

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.

ml_transforms

Especifica uma lista de transformações do MicrosoftML a serem executadas nos dados antes do treinamento ou None para que nenhuma transformação seja executada. Confira featurize_text, categorical e categorical_hash, para saber quais são as transformações com suporte. Essas transformações são executadas após qualquer transformação do Python especificada. O valor padrão é None.

ml_transform_vars

Especifica um vetor de caracteres de nomes de variáveis a ser usado em ml_transforms ou None para que nenhum vetor seja usado. O valor padrão é None.

row_selection

SEM SUPORTE. 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:

  • row_selection = "old" usará apenas observações nas quais o valor da variável old seja True.

  • row_selection = (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 transform_function). Assim como acontece com todas as expressões, é possível definir row_selection fora da chamada de função usando a função expression.

transformações

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

transform_objects

SEM SUPORTE. 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ável.

transform_variables

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

transform_packages

SEM SUPORTE. Um vetor de caracteres que especifica pacotes Python adicionais (fora aqueles especificados em RxOptions.get_option("transform_packages")) 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 revoscalepy por meio dos respectivos argumentos transforms e transform_function ou os definidos implicitamente por meio dos respectivos argumentos formula ou row_selection. O argumento transform_packages também pode ser None, indicando que nenhum pacote fora de RxOptions.get_option("transform_packages") é pré-carregado.

transform_environment

SEM SUPORTE. 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 transform_environment = None, um novo ambiente de "hash" com revoscalepy.baseenv pai é usado.

blocks_per_read

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

report_progress

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.

compute_context

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

ensemble

Parâmetros de controle para conjuntos.

Retornos

Um objeto LogisticRegression com o modelo treinado.

Observação

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

Confira também

rx_predict

Referências

Wikipédia: L-BFGS

Wikipédia: regressão logística

Treinamento escalonável de modelos lineares de log regularizados L1

Execução de teste – Regularização de L1 e L2 para machine learning

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))

Saída:

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 da classificação multiclasse

'''
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))

Saída:

Automatically adding a MinMax normalization transform, use 'norm=Warn' or 'norm=No' to turn this behavior off.
Beginning processing data.
Rows Read: 112, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 112, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 112, 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: 15
improvement criterion: Mean Improvement
L1 regularization selected 9 of 15 weights.
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.0493224
Elapsed time: 00:00:00.0080558
OrderedDict([('setosa+(Bias)', 2.074636697769165), ('versicolor+(Bias)', 0.4899507164955139), ('virginica+(Bias)', -2.564580202102661), ('setosa+Petal_Width', -2.8389241695404053), ('setosa+Petal_Length', -2.4824044704437256), ('setosa+Sepal_Width', 0.274869441986084), ('versicolor+Sepal_Width', -0.2645561397075653), ('virginica+Petal_Width', 2.6924400329589844), ('virginica+Petal_Length', 1.5976412296295166)])
Beginning processing data.
Rows Read: 38, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0331861
Finished writing 38 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: 0.001 seconds 
      Species   Score.0   Score.1   Score.2
0   virginica  0.044230  0.364927  0.590843
1      setosa  0.767412  0.210586  0.022002
2      setosa  0.756523  0.221933  0.021543
3      setosa  0.767652  0.211191  0.021157
4  versicolor  0.116369  0.498615  0.385016