microsoftml.rx_fast_linear: modelo linear com ascendente estocástico de coordenada dupla

Artigo
05/23/2023

Uso

microsoftml.rx_fast_linear()

Descrição

Um treinador de otimização de SDCA (ascendente estocástico de coordenada dupla) para classificação e regressão binárias lineares.

Detalhes

rx_fast_linear é um treinador baseado no método SDCA (ascendente estocástico de coordenada dupla), uma técnica de otimização de ponta para funções de objetivo convexa. O algoritmo pode ser dimensionado para ser usado em grandes conjuntos de dados de memória insuficiente devido a uma implementação semiassíncrona que dá suporte a multithreading. A convergência é garantida por meio da imposição periódica da sincronização entre as atualizações primária e dupla em um thread separado. Também são fornecidas várias opções de funções de perda. O método SDCA combina várias das melhores propriedades e funcionalidades dos algoritmos de regressão logística e de SVM. Para obter mais informações sobre SDCA, confira as citações na seção de referência.

Os algoritmos de otimização tradicionais, como o SGD (descendente de gradiente estocástico), otimizam a função de perda empírica diretamente. O SDCA escolhe uma abordagem diferente que otimiza o problema de dupla. A função de perda dupla é parametrizada por pesos para cada exemplo. Em cada iteração, quando um exemplo de treinamento do conjunto de dados de treinamento é lido, o peso do exemplo correspondente é ajustado para que a função de perda dupla seja otimizada em relação ao exemplo atual. O SDCA não exige nenhuma taxa de aprendizado para determinar o tamanho da etapa, o que é exigido por vários métodos de descendente de gradiente.

rx_fast_linear dá suporte à classificação binária com três tipos de funções de perda no momento: perda de log, perda de dobradiça e perda de dobradiça suavizada. A regressão linear também dá suporte à função de perda ao quadrado. A regularização de rede elástica pode ser especificada pelos parâmetros l2_weight e l1_weight. Observe que o l2_weight tem um efeito sobre a taxa de convergência. Em geral, quanto maior o l2_weight, mais rápida é a convergência do SDCA.

Observe que o rx_fast_linear é um algoritmo estocástico de otimização de streaming. Os resultados dependem da ordem dos dados de treinamento. Para obter resultados reproduzíveis, é recomendado definir shuffle como False e train_threads como 1.

Argumentos

formula

A fórmula descrita em revoscalepy.rx_formula. 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.

method

Especifica o tipo de modelo com uma cadeia de caracteres: "binary" para a classificação binária padrão ou "regression" para a regressão linear.

loss_function

Especifica a função de perda empírica a ser otimizada. Para classificação binária, as seguintes opções estão disponíveis:

log_loss: a perda de log. Esse é o padrão.
hinge_loss: a perda de dobradiça do SVM. O respectivo parâmetro representa o tamanho da margem.
smooth_hinge_loss: a perda de dobradiça suavizada. O respectivo parâmetro representa a constante de suavização.

Para regressão linear, no momento há suporte para squared_loss de perda ao quadrado. Quando esse parâmetro é definido como None, o valor padrão depende do tipo de aprendizado:

log_loss para classificação binária.
squared_loss para regressão linear.

O exemplo a seguir altera a loss_function para hinge_loss: rx_fast_linear(..., loss_function=hinge_loss()).

l1_weight

Especifica o peso de regularização de L1. O valor precisa ser não negativo ou None. Se None for especificado, o valor real será computado automaticamente com base no conjunto de dados. None é o valor padrão.

l2_weight

Especifica o peso de regularização de L2. O valor precisa ser não negativo ou None. Se None for especificado, o valor real será computado automaticamente com base no conjunto de dados. None é o valor padrão.

train_threads

Especifica quantos threads simultâneos podem ser usados para executar o algoritmo. Quando esse parâmetro é definido como None, o número de threads usados é determinado com base no número de processadores lógicos disponíveis para o processo, bem como pela dispersão de dados. Defina-o como 1 para executar o algoritmo em um só thread.

convergence_tolerance

Especifica o limite de tolerância usado como um critério de convergência. Ele precisa estar entre 0 e 1. O valor padrão é 0.1. O algoritmo é considerado convergido quando a lacuna de dualidade relativa, que é a proporção entre a lacuna de dualidade e a perda primária, cai abaixo da tolerância de convergência especificada.

max_iterations

Especifica um limite superior no número de iterações de treinamento. Esse parâmetro precisa ser positivo ou None. Se None for especificado, o valor real será computado automaticamente com base no conjunto de dados. Cada iteração exige uma passagem completa nos dados de treinamento. O treinamento é encerrado depois que ocorre uma das duas opções: o número total de iterações atinge o limite superior especificado ou a função de perda é convergida.

ordem aleatória

Especifica se os dados de treinamento devem ser embaralhados. Defina True para embaralhar os dados e False para não os embaralhar. O valor padrão é True. O SDCA é um algoritmo estocástico de otimização. Quando o embaralhamento está ativado, os dados de treinamento são embaralhados em cada iteração.

check_frequency

O número de iterações após o qual a função de perda é computada e verificada para determinar se ela foi convergida. O valor especificado precisa ser um inteiro positivo ou None. Se for None, o valor real será computado automaticamente com base no conjunto de dados. Caso contrário, por exemplo, se checkFrequency = 5 for especificado, a função de perda será computada e a convergência será verificada a cada cinco iterações. A computação da função de perda exige uma passagem completa separada nos dados de treinamento.

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 FastLinear com o modelo treinado.

Observação

Esse algoritmo é multithreading e não tentará carregar o conjunto de dados inteiro na memória.

Confira também

hinge_loss, log_loss, smoothed_hinge_loss, squared_loss, rx_predict

Referências

Como escalar verticalmente o ascendente estocástico de coordenada dupla

Métodos de ascendente estocástico de coordenada dupla para minimização de perda regularizada

Exemplo de classificação binária

'''
Binary Classification.
'''
import numpy
import pandas
from microsoftml import rx_fast_linear, 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)

forest_model = rx_fast_linear(
    formula=" isCase ~ age + parity + education + spontaneous + induced ",
    data=data_train)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(forest_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, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
Using 2 threads to train.
Automatically choosing a check frequency of 2.
Auto-tuning parameters: maxIterations = 8064.
Auto-tuning parameters: L2 = 2.666837E-05.
Auto-tuning parameters: L1Threshold (L1/L2) = 0.
Using best model from iteration 568.
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.5810985
Elapsed time: 00:00:00.0084876
Beginning processing data.
Rows Read: 62, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0292334
Finished writing 62 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: Less than .001 seconds 
  isCase PredictedLabel     Score  Probability
0   True           True  0.990544     0.729195
1  False          False -2.307120     0.090535
2  False          False -0.608565     0.352387
3   True           True  1.028217     0.736570
4   True          False -3.913066     0.019588

Exemplo de regressão

'''
Regression.
'''
import numpy
import pandas
from microsoftml import rx_fast_linear, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

attitude = get_dataset("attitude")

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

attitudedf = attitude.as_df()
data_train, data_test = train_test_split(attitudedf)

model = rx_fast_linear(
    formula="rating ~ complaints + privileges + learning + raises + critical + advance",
    method="regression",
    data=data_train)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(model, data=data_test,
                     extra_vars_to_write=["rating"])
                     
# Print the first five rows
print(rx_data_step(score_ds, number_rows_read=5))