Featurização de dados em machine learning automatizado

APLICA-SE A: Python SDK azureml v1

Este artigo explica como personalizar as configurações de featurização de dados no Azure Machine Learning para seus experimentos de aprendizado de máquina automatizado (AutoML).

Engenharia de recursos e featurização

Os dados de treinamento consistem em linhas e colunas. Cada linha é uma observação ou registro, e as colunas de cada linha são os recursos que descrevem cada registro. Normalmente, os recursos que melhor caracterizam os padrões nos dados são selecionados para criar modelos preditivos.

Embora muitos dos campos de dados brutos possam ser usados diretamente para treinar um modelo, muitas vezes é necessário criar outros recursos (projetados) que forneçam informações que diferenciem melhor os padrões nos dados. Esse processo é chamado de engenharia de recursos, onde o uso do conhecimento de domínio dos dados é usado para criar recursos que, por sua vez, ajudam os algoritmos de aprendizado de máquina a aprender melhor.

No Azure Machine Learning, as técnicas de dimensionamento e normalização de dados são aplicadas para facilitar a engenharia de recursos. Coletivamente, essas técnicas e essa engenharia de recursos são chamadas de featurização em experimentos automatizados de aprendizado de máquina (ML).

Pré-requisitos

Este artigo pressupõe que você já saiba como configurar um experimento de ML automatizado.

Para obter informações sobre configuração, consulte os seguintes artigos:

• Para uma experiência code-first: Configure o treinamento AutoML com Python
• Para uma experiência sem código: configure o treinamento AutoML sem código para dados tabulares com a interface do usuário do estúdio

Configurar featurização

Em todos os experimentos automatizados de aprendizado de máquina, as técnicas de dimensionamento e normalização automáticas são aplicadas aos seus dados por padrão. Estas técnicas são tipos de featurização que ajudam certos algoritmos que são sensíveis a características em diferentes escalas. Você pode habilitar mais featurização, como imputação de valores ausentes, codificação e transformações.

Para experimentos que você configura com o SDK do Python, você pode habilitar ou desabilitar a configuração de featurização e especificar ainda mais as etapas de featurização a serem usadas para seu experimento. Se você estiver usando o estúdio do Azure Machine Learning, consulte as etapas para habilitar a featurização.

A tabela a seguir mostra as configurações aceitas para featurization na classe AutoMLConfig:

Featurização automática

A tabela a seguir resume as técnicas que são aplicadas automaticamente aos seus dados. Essas técnicas são aplicadas para experimentos configurados usando o SDK ou a interface do usuário do estúdio. Para desativar esse comportamento, defina "featurization": 'off' em seu AutoMLConfig objeto.

Em cada experimento automatizado de aprendizado de máquina, seus dados são automaticamente dimensionados ou normalizados para ajudar os algoritmos a terem um bom desempenho. Durante o treinamento do modelo, uma das seguintes técnicas de dimensionamento ou normalização é aplicada a cada modelo.

Guardrails de dados

As proteções de dados ajudam a identificar possíveis problemas com seus dados (por exemplo, valores ausentes ou desequilíbrio de classe). Eles também ajudam você a tomar ações corretivas para melhorar os resultados.

As proteções de dados são aplicadas:

• Para experimentos SDK: Quando os parâmetros "featurization": 'auto' ou validation=auto são especificados em seu AutoMLConfig objeto
• Para experiências em estúdio: Quando a featurização automática está ativada

Você pode revisar os guardrails de dados para seu experimento:

• Definindo show_output=True quando você envia um experimento usando o SDK.
• No estúdio, na guia Guardrails de dados da sua execução automatizada de ML.

Estados do guardrail de dados

As proteções de dados exibem um dos três estados:

Guardrails de dados suportados

A tabela a seguir descreve os guardrails de dados com suporte no momento e os status associados que você pode ver ao enviar seu experimento:

Personalizar featurização

Você pode personalizar suas configurações de featurização para garantir que os dados e recursos usados para treinar seu modelo de ML resultem em previsões relevantes.

Para personalizar featurizações, especifique "featurization": FeaturizationConfig em seu AutoMLConfig objeto. Se você estiver usando o estúdio do Azure Machine Learning para seu experimento, consulte o artigo de instruções. Para personalizar a featurização para tipos de tarefas de previsão, consulte o tutorial de previsão.

As personalizações suportadas incluem:

Crie o objeto usando chamadas de FeaturizationConfig API:

featurization_config = FeaturizationConfig()
featurization_config.blocked_transformers = ['LabelEncoder']
featurization_config.drop_columns = ['aspiration', 'stroke']
featurization_config.add_column_purpose('engine-size', 'Numeric')
featurization_config.add_column_purpose('body-style', 'CategoricalHash')
#default strategy mean, add transformer param for 3 columns
featurization_config.add_transformer_params('Imputer', ['engine-size'], {"strategy": "median"})
featurization_config.add_transformer_params('Imputer', ['city-mpg'], {"strategy": "median"})
featurization_config.add_transformer_params('Imputer', ['bore'], {"strategy": "most_frequent"})
featurization_config.add_transformer_params('HashOneHotEncoder', [], {"number_of_bits": 3})

Transparência de featurização

Todos os modelos AutoML têm featurização aplicada automaticamente. A featurização inclui engenharia de recursos automatizada (quando "featurization": 'auto') e dimensionamento e normalização, o que afeta o algoritmo selecionado e seus valores de hiperparâmetro. O AutoML suporta diferentes métodos para garantir que você tenha visibilidade do que foi aplicado ao seu modelo.

Considere este exemplo de previsão:

• Há quatro recursos de entrada: A (numérico), B (numérico), C (numérico), D (DateTime).
• O recurso numérico C é descartado porque é uma coluna de ID com todos os valores exclusivos.
• As características numéricas A e B têm valores ausentes e, portanto, são imputadas pela média.
• O recurso DateTime D é dividido em 11 recursos de engenharia diferentes.

Para obter essas informações, use a saída da execução do experimento fitted_model de ML automatizado.

automl_config = AutoMLConfig(…)
automl_run = experiment.submit(automl_config …)
best_run, fitted_model = automl_run.get_output()

Engenharia automatizada de recursos

O get_engineered_feature_names() retorna uma lista de nomes de recursos projetados.

fitted_model.named_steps['timeseriestransformer']. get_engineered_feature_names ()

Esta lista inclui todos os nomes de recursos projetados.

['A', 'B', 'A_WASNULL', 'B_WASNULL', 'year', 'half', 'quarter', 'month', 'day', 'hour', 'am_pm', 'hour12', 'wday', 'qday', 'week']

O get_featurization_summary() obtém um resumo de featurização de todos os recursos de entrada.

fitted_model.named_steps['timeseriestransformer'].get_featurization_summary()

Saída

[{'RawFeatureName': 'A',
  'TypeDetected': 'Numeric',
  'Dropped': 'No',
  'EngineeredFeatureCount': 2,
  'Tranformations': ['MeanImputer', 'ImputationMarker']},
 {'RawFeatureName': 'B',
  'TypeDetected': 'Numeric',
  'Dropped': 'No',
  'EngineeredFeatureCount': 2,
  'Tranformations': ['MeanImputer', 'ImputationMarker']},
 {'RawFeatureName': 'C',
  'TypeDetected': 'Numeric',
  'Dropped': 'Yes',
  'EngineeredFeatureCount': 0,
  'Tranformations': []},
 {'RawFeatureName': 'D',
  'TypeDetected': 'DateTime',
  'Dropped': 'No',
  'EngineeredFeatureCount': 11,
  'Tranformations': ['DateTime','DateTime','DateTime','DateTime','DateTime','DateTime','DateTime','DateTime',ateTime','DateTime','DateTime']}]

Dimensionamento e normalização

Para entender o dimensionamento/normalização e o algoritmo selecionado com seus valores de hiperparâmetro, use fitted_model.steps.

A saída de exemplo a seguir é de execução fitted_model.steps para uma execução escolhida:

[('RobustScaler', 
  RobustScaler(copy=True, 
  quantile_range=[10, 90], 
  with_centering=True, 
  with_scaling=True)), 

  ('LogisticRegression', 
  LogisticRegression(C=0.18420699693267145, class_weight='balanced', 
  dual=False, 
  fit_intercept=True, 
  intercept_scaling=1, 
  max_iter=100, 
  multi_class='multinomial', 
  n_jobs=1, penalty='l2', 
  random_state=None, 
  solver='newton-cg', 
  tol=0.0001, 
  verbose=0, 
  warm_start=False))]

Para obter mais detalhes, use esta função auxiliar:

from pprint import pprint

def print_model(model, prefix=""):
    for step in model.steps:
        print(prefix + step[0])
        if hasattr(step[1], 'estimators') and hasattr(step[1], 'weights'):
            pprint({'estimators': list(e[0] for e in step[1].estimators), 'weights': step[1].weights})
            print()
            for estimator in step[1].estimators:
                print_model(estimator[1], estimator[0]+ ' - ')
        elif hasattr(step[1], '_base_learners') and hasattr(step[1], '_meta_learner'):
            print("\nMeta Learner")
            pprint(step[1]._meta_learner)
            print()
            for estimator in step[1]._base_learners:
                print_model(estimator[1], estimator[0]+ ' - ')
        else:
            pprint(step[1].get_params())
            print()   

Esta função auxiliar retorna a seguinte saída para uma execução específica usando LogisticRegression with RobustScalar como o algoritmo específico.

RobustScaler
{'copy': True,
'quantile_range': [10, 90],
'with_centering': True,
'with_scaling': True}

LogisticRegression
{'C': 0.18420699693267145,
'class_weight': 'balanced',
'dual': False,
'fit_intercept': True,
'intercept_scaling': 1,
'max_iter': 100,
'multi_class': 'multinomial',
'n_jobs': 1,
'penalty': 'l2',
'random_state': None,
'solver': 'newton-cg',
'tol': 0.0001,
'verbose': 0,
'warm_start': False}

Prever probabilidade de classe

Todos os modelos produzidos usando ML automatizado têm objetos wrapper que espelham a funcionalidade de sua classe de origem de código aberto. A maioria dos objetos de wrapper de modelo de classificação retornados pelo ML automatizado implementa a função, que aceita uma amostra de dados de matriz esparsa predict_proba() ou semelhante a uma matriz de seus recursos (valores X) e retorna uma matriz n-dimensional de cada amostra e sua respetiva probabilidade de classe.

Supondo que você tenha recuperado o melhor modelo executado e ajustado usando as mesmas chamadas, você pode ligar predict_proba() diretamente do modelo ajustado, fornecendo uma X_test amostra no formato apropriado, dependendo do tipo de modelo.

best_run, fitted_model = automl_run.get_output()
class_prob = fitted_model.predict_proba(X_test)

Se o modelo subjacente não suportar a predict_proba() função ou se o formato estiver incorreto, uma exceção específica da classe do modelo será lançada. Consulte os documentos de referência RandomForestClassifier e XGBoost para obter exemplos de como essa função é implementada para diferentes tipos de modelo.

Integração BERT em ML automatizado

O BERT é usado na camada de featurização do ML automatizado. Nesta camada, se uma coluna tiver texto livre ou outros tipos de dados, como carimbos de data/hora ou números simples, a caracterização será aplicada em conformidade.

No BERT, o modelo é otimizado e preparado com as etiquetas proporcionadas pelo utilizador. A partir daqui, as incorporações de documentos são saídas como funcionalidades ao lado de outras, como funcionalidades baseadas no carimbo de data/hora ou dia da semana.

Saiba como configurar o AutoML para treinar um modelo de processamento de linguagem natural com Python.

Etapas para invocar o BERT

Para invocar o BERT, defina enable_dnn: True o seu automl_settings e use um cálculo de GPU (vm_size = "STANDARD_NC6" ou uma GPU superior). Se um cálculo de CPU for usado, em vez de BERT, o AutoML habilita o featurizer DNN BiLSTM.

O ML automatizado executa as seguintes etapas para o BERT.

1. Pré-processamento e tokenização de todas as colunas de texto. Por exemplo, o StringCast transformador pode ser encontrado no resumo de featurização do modelo final. Um exemplo de como produzir o resumo de featurização do modelo pode ser encontrado neste caderno.

2. Concatene todas as colunas de texto em uma única coluna de texto, daí o StringConcatTransformer no modelo final.

   Nossa implementação do BERT limita o comprimento total do texto de uma amostra de treinamento a 128 tokens. Isso significa que, idealmente, todas as colunas de texto, quando concatenadas, devem ter, no máximo, 128 tokens de comprimento. Se estiverem presentes várias colunas, cada coluna deve ser removida para que esta condição seja satisfeita. Caso contrário, para colunas concatenadas de comprimento >128 tokens, a camada tokenizadora do BERT trunca essa entrada para 128 tokens.

3. Como parte da varredura de recursos, o AutoML compara o BERT com a linha de base (recursos de saco de palavras) em uma amostra dos dados. Esta comparação determina se o BERT proporcionaria melhorias de precisão. Se o BERT tiver um desempenho melhor do que a linha de base, o AutoML usará o BERT para a featurização de texto para todos os dados. Nesse caso, você vê o PretrainedTextDNNTransformer no modelo final.

O BERT geralmente é mais longo do que outros featurizers. Para um melhor desempenho, recomendamos o uso de STANDARD_NC24r ou STANDARD_NC24rs_V3 para seus recursos RDMA.

O AutoML distribui o treinamento BERT em vários nós, se eles estiverem disponíveis (até um máximo de oito nós). Isso pode ser feito em seu AutoMLConfig objeto definindo o max_concurrent_iterations parâmetro como superior a 1.

Idiomas suportados para BERT no AutoML

Atualmente, o AutoML suporta cerca de 100 idiomas e, dependendo do idioma do conjunto de dados, o AutoML escolhe o modelo BERT apropriado. Para dados alemães, usamos o modelo BERT alemão. Para o inglês, usamos o modelo BERT em inglês. Para todas as outras línguas, utilizamos o modelo BERT multilingue.

No código a seguir, o modelo BERT alemão é acionado, uma vez que o idioma do conjunto de dados é especificado para deu, o código de idioma de três letras para alemão de acordo com a classificação ISO:

from azureml.automl.core.featurization import FeaturizationConfig

featurization_config = FeaturizationConfig(dataset_language='deu')

automl_settings = {
    "experiment_timeout_minutes": 120,
    "primary_metric": 'accuracy',
# All other settings you want to use
    "featurization": featurization_config,
    
    "enable_dnn": True, # This enables BERT DNN featurizer
    "enable_voting_ensemble": False,
    "enable_stack_ensemble": False
}

Conteúdos relacionados

• Implantar modelos de aprendizado de máquina no Azure
• Treinar um modelo de regressão com AutoML e Python