Configurar o treinamento AutoML com Python

APLICA-SE A: Python SDK azureml v1

Neste guia, saiba como configurar um treinamento automatizado de aprendizado de máquina, AutoML, executado com o SDK Python do Azure Machine Learning usando o ML automatizado do Azure Machine Learning. O ML automatizado seleciona um algoritmo e hiperparâmetros para você e gera um modelo pronto para implantação. Este guia fornece detalhes das várias opções que você pode usar para configurar experimentos automatizados de ML.

Para obter um exemplo de ponta a ponta, consulte Tutorial: AutoML- train regression model.

Se preferir uma experiência sem código, também pode Configurar a formação de AutoML sem código no estúdio de Aprendizagem de Máquina do Azure.

Pré-requisitos

Para este artigo você precisa,

• Uma área de trabalho do Azure Machine Learning. Para criar o espaço de trabalho, consulte Criar recursos do espaço de trabalho.

• O SDK Python do Azure Machine Learning instalado. Para instalar o SDK, você pode,

  • Crie uma instância de computação, que instala automaticamente o SDK e é pré-configurada para fluxos de trabalho de ML. Consulte Criar e gerenciar uma instância de computação do Azure Machine Learning para obter mais informações.

  • Instale o automl pacote você mesmo, que inclui a instalação padrão do SDK.

  Importante

  Os comandos Python neste artigo requerem a versão mais recente azureml-train-automl do pacote.

  • Instale o pacote mais recente azureml-train-automl em seu ambiente local.
  • Para obter detalhes sobre o pacote mais recenteazureml-train-automl, consulte as notas de versão.

  Aviso

  Python 3.8 não é compatível com automl.

Selecionar o tipo de experimentação

Antes de começar seu experimento, você deve determinar o tipo de problema de aprendizado de máquina que está resolvendo. O aprendizado de máquina automatizado suporta os tipos de tarefas , classificationregressione forecasting. Saiba mais sobre os tipos de tarefas.

O código a AutoMLConfig seguir usa o task parâmetro no construtor para especificar o tipo de experimento como classification.

from azureml.train.automl import AutoMLConfig

# task can be one of classification, regression, forecasting
automl_config = AutoMLConfig(task = "classification")

Origem de dados e formato

O machine learning automatizado suporta os dados que residem no ambiente de trabalho local ou na cloud, como o Armazenamento de Blobs do Azure. Os dados podem ser lidos em um Pandas DataFrame ou em um Azure Machine Learning TabularDataset. Saiba mais sobre os conjuntos de dados.

Requisitos para dados de treinamento em aprendizado de máquina:

• Os dados devem estar em forma de tabela.
• O valor a ser previsto, coluna de destino, deve estar nos dados.

Para experimentos remotos, os dados de treinamento devem estar acessíveis a partir da computação remota. O ML automatizado só aceita Conjuntos de Dados Tabulares do Azure Machine Learning ao trabalhar em uma computação remota.

Os conjuntos de dados do Azure Machine Learning expõem a funcionalidade para:

• Transfira facilmente dados de arquivos estáticos ou fontes de URL para seu espaço de trabalho.
• Tornar os dados disponíveis para os scripts de preparação ao executar os recursos de computação na cloud. Consulte Como treinar com conjuntos de dados para obter um exemplo de como usar a Dataset classe para montar dados em seu destino de computação remoto.

O código a seguir cria um TabularDataset a partir de uma URL da Web. Consulte Criar um TabularDataset para obter exemplos de código sobre como criar conjuntos de dados de outras fontes, como arquivos locais e armazenamentos de dados.

from azureml.core.dataset import Dataset
data = "https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/creditcard.csv"
dataset = Dataset.Tabular.from_delimited_files(data)

Para experimentos de computação locais, recomendamos dataframes pandas para tempos de processamento mais rápidos.

import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.read_csv("your-local-file.csv")
train_data, test_data = train_test_split(df, test_size=0.1, random_state=42)
label = "label-col-name"

Dados de treinamento, validação e teste

Você pode especificar dados de treinamento separados e conjuntos de dados de validação diretamente no AutoMLConfig construtor. Saiba mais sobre como configurar dados de treinamento, validação, validação cruzada e teste para seus experimentos de AutoML.

Se você não especificar explicitamente um validation_data ou n_cross_validation parâmetro, o ML automatizado aplicará técnicas padrão para determinar como a validação será executada. Essa determinação depende do número de linhas no conjunto de dados atribuído ao seu training_data parâmetro.

Dados grandes

O ML automatizado suporta um número limitado de algoritmos para treinamento em grandes volumes de dados que podem criar modelos para big data em máquinas virtuais pequenas. A heurística de ML automatizada depende de propriedades como tamanho de dados, tamanho da memória da máquina virtual, tempo limite do experimento e configurações de featurização para determinar se esses algoritmos de dados grandes devem ser aplicados. Saiba mais sobre quais modelos são suportados no ML automatizado.

• Para regressão, Regressor de Descida de Gradiente Online e Regressor Linear Rápido

• Para classificação, Classificador Perceptron Médio e Classificador SVM Linear, onde o classificador Linear SVM tem dados grandes e versões de dados pequenos.

Se você quiser substituir essas heurísticas, aplique as seguintes configurações:

Computação para executar a experimentação

Em seguida, determine onde o modelo será treinado. Um experimento de treinamento automatizado de ML pode ser executado nas seguintes opções de computação.

• Escolha um cálculo local: Se o seu cenário for sobre explorações iniciais ou demonstrações usando pequenos dados e trens curtos (ou seja, segundos ou alguns minutos por criança corrida), o treinamento em seu computador local pode ser uma escolha melhor. Não há tempo de configuração, os recursos de infraestrutura (seu PC ou VM) estão diretamente disponíveis. Veja este bloco de notas para obter um exemplo de computação local.

• Escolha um cluster de computação de ML remoto: Se você estiver treinando com conjuntos de dados maiores, como no treinamento de produção, criando modelos que precisam de trens mais longos, a computação remota fornecerá um desempenho de tempo de ponta a ponta muito melhor porque AutoML paralelizará os trens entre os nós do cluster. Em uma computação remota, o tempo de inicialização da infraestrutura interna adicionará cerca de 1,5 minutos por execução filho, além de minutos adicionais para a infraestrutura de cluster se as VMs ainda não estiverem em funcionamento.O Azure Machine Learning Managed Compute é um serviço gerenciado que permite treinar modelos de aprendizado de máquina em clusters de máquinas virtuais do Azure. A instância de computação também é suportada como um destino de computação.

• Um cluster do Azure Databricks em sua assinatura do Azure. Você pode encontrar mais detalhes em Configurar um cluster do Azure Databricks para ML automatizado. Veja este site do GitHub para obter exemplos de blocos de notas com o Azure Databricks.

Considere estes fatores ao escolher seu destino de computação:

Definir as configurações do experimento

Há várias opções que você pode usar para configurar seu experimento de ML automatizado. Esses parâmetros são definidos instanciando um AutoMLConfig objeto. Consulte a classe AutoMLConfig para obter uma lista completa de parâmetros.

O exemplo a seguir é para uma tarefa de classificação. O experimento usa AUC ponderada como métrica primária e tem um tempo limite de experimento definido para 30 minutos e 2 dobras de validação cruzada.

    automl_classifier=AutoMLConfig(task='classification',
                                   primary_metric='AUC_weighted',
                                   experiment_timeout_minutes=30,
                                   blocked_models=['XGBoostClassifier'],
                                   training_data=train_data,
                                   label_column_name=label,
                                   n_cross_validations=2)

Você também pode configurar tarefas de previsão, o que requer configuração extra. Consulte o artigo Configurar o AutoML para previsão de séries cronológicas para obter mais detalhes.

    time_series_settings = {
                            'time_column_name': time_column_name,
                            'time_series_id_column_names': time_series_id_column_names,
                            'forecast_horizon': n_test_periods
                           }
    
    automl_config = AutoMLConfig(
                                 task = 'forecasting',
                                 debug_log='automl_oj_sales_errors.log',
                                 primary_metric='normalized_root_mean_squared_error',
                                 experiment_timeout_minutes=20,
                                 training_data=train_data,
                                 label_column_name=label,
                                 n_cross_validations=5,
                                 path=project_folder,
                                 verbosity=logging.INFO,
                                 **time_series_settings
                                )

Modelos suportados

O aprendizado de máquina automatizado experimenta diferentes modelos e algoritmos durante o processo de automação e ajuste. Como usuário, não há necessidade de especificar o algoritmo.

Os três valores de parâmetros diferentes task determinam a lista de algoritmos, ou modelos, a serem aplicados. Use os allowed_models parâmetros ou blocked_models para modificar iterações com os modelos disponíveis para incluir ou excluir. A tabela a seguir resume os modelos suportados por tipo de tarefa.

Métrica primária

O primary_metric parâmetro determina a métrica a ser usada durante o treinamento do modelo para otimização. As métricas disponíveis que você pode selecionar são determinadas pelo tipo de tarefa escolhido.

A escolha de uma métrica primária para ML automatizado para otimizar depende de muitos fatores. Recomendamos que a sua principal consideração seja escolher a métrica que melhor represente as necessidades do seu negócio. Em seguida, considere se a métrica é adequada para o perfil do conjunto de dados (tamanho dos dados, intervalo, distribuição de classes, etc.). As seções a seguir resumem as métricas primárias recomendadas com base no tipo de tarefa e no cenário de negócios.

Saiba mais sobre as definições específicas dessas métricas em Compreender os resultados do aprendizado de máquina automatizado.

Métricas para cenários de classificação

Métricas dependentes de limite, como accuracy, recall_score_weighted, norm_macro_recall, e precision_score_weighted podem não otimizar tão bem para conjuntos de dados que são pequenos, têm distorção de classe muito grande (desequilíbrio de classe), ou quando o valor de métrica esperado é muito próximo de 0,0 ou 1,0. Nesses casos, AUC_weighted pode ser uma escolha melhor para a métrica primária. Após a conclusão do ML automatizado, você pode escolher o modelo vencedor com base na métrica mais adequada às suas necessidades de negócios.

Métricas para cenários de regressão

r2_score, normalized_mean_absolute_error e normalized_root_mean_squared_error todos estão tentando minimizar os erros de previsão. r2_score e normalized_root_mean_squared_error ambos minimizam os erros quadrados médios enquanto normalized_mean_absolute_error minimizam o valor absoluto médio dos erros. O valor absoluto trata os erros em todas as magnitudes da mesma forma e os erros quadrados terão uma penalidade muito maior para erros com valores absolutos maiores. Dependendo se erros maiores devem ser punidos mais ou não, pode-se optar por otimizar erro quadrado ou erro absoluto.

A principal diferença entre r2_score e normalized_root_mean_squared_error é a forma como são normalizados e os seus significados. normalized_root_mean_squared_error é o erro quadrático médio da raiz normalizado pelo intervalo e pode ser interpretado como a magnitude média do erro para previsão. r2_score é o erro quadrático médio normalizado por uma estimativa de variância dos dados. É a proporção de variação que pode ser capturada pelo modelo.

Se a classificação, em vez do valor exato é de interesse, pode ser uma escolha melhor, spearman_correlation pois mede a correlação de classificação entre valores reais e previsões.

No entanto, atualmente nenhuma métrica primária para regressão aborda a diferença relativa. Todos , e normalized_root_mean_squared_error tratar um erro de previsão de US$ 20 mil da mesma forma para um trabalhador com um salário de US$ 30 mil como um trabalhador que ganha US$ 20 milhões, se esses dois pontos de dados pertencerem ao mesmo conjunto de r2_scorenormalized_mean_absolute_errordados para regressão ou à mesma série temporal especificada pelo identificador de série temporal. Enquanto, na realidade, prever apenas US $ 20 mil de desconto de um salário de US $ 20 milhões é muito próximo (uma pequena diferença relativa de 0,1%), enquanto US $ 20 mil de desconto de US $ 30 mil não é perto (uma grande diferença relativa de 67%). Para resolver a questão da diferença relativa, pode-se treinar um modelo com métricas primárias disponíveis e, em seguida, selecionar o modelo com melhor mean_absolute_percentage_error ou root_mean_squared_log_error.

Métricas para cenários de previsão de séries temporais

As recomendações são semelhantes às observadas para cenários de regressão.

Featurização de dados

Em cada experimento automatizado de ML, seus dados são automaticamente dimensionados e normalizados para ajudar determinados algoritmos que são sensíveis a recursos que estão em escalas diferentes. Esta escala e normalização é referida como featurização. Consulte Featurization in AutoML para obter mais detalhes e exemplos de código.

Ao configurar seus experimentos em seu AutoMLConfig objeto, você pode ativar/desabilitar a configuração featurization. A tabela a seguir mostra as configurações aceitas para featurização no objeto AutoMLConfig.

Configuração do Ensemble

Os modelos de conjunto são habilitados por padrão e aparecem como as iterações de execução finais em uma execução do AutoML. Atualmente , VotingEnsemble e StackEnsemble são suportados.

A votação implementa o voto suave, que usa médias ponderadas. A implementação de empilhamento usa uma implementação de duas camadas, onde a primeira camada tem os mesmos modelos que o conjunto de votação, e o modelo de segunda camada é usado para encontrar a combinação ideal dos modelos da primeira camada.

Se você estiver usando modelos ONNX ou tiver a explicabilidade do modelo habilitada, o empilhamento será desativado e apenas a votação será utilizada.

O treinamento do Ensemble pode ser desativado usando os enable_voting_ensemble parâmetros e enable_stack_ensemble booleanos.

automl_classifier = AutoMLConfig(
                                 task='classification',
                                 primary_metric='AUC_weighted',
                                 experiment_timeout_minutes=30,
                                 training_data=data_train,
                                 label_column_name=label,
                                 n_cross_validations=5,
                                 enable_voting_ensemble=False,
                                 enable_stack_ensemble=False
                                )

Para alterar o comportamento do conjunto padrão, há vários argumentos padrão que podem ser fornecidos como kwargs em um AutoMLConfig objeto.

• ensemble_download_models_timeout_sec: Durante a geração de modelos VotingEnsemble e StackEnsemble , vários modelos ajustados das execuções infantis anteriores são baixados. Se você encontrar este erro: AutoMLEnsembleException: Could not find any models for running ensembling, talvez seja necessário fornecer mais tempo para que os modelos sejam baixados. O valor padrão é de 300 segundos para baixar esses modelos em paralelo e não há limite máximo de tempo limite. Configure este parâmetro com um valor superior a 300 segundos, se for necessário mais tempo.

  Nota

  Se o tempo limite for atingido e houver modelos baixados, o conjunto prossegue com tantos modelos que ele baixou. Não é necessário que todos os modelos precisem ser baixados para terminar dentro desse tempo limite. Os seguintes parâmetros só se aplicam aos modelos StackEnsemble :

• stack_meta_learner_type: o meta-aprendiz é um modelo treinado sobre o resultado dos modelos heterogêneos individuais. Os meta-alunos padrão são LogisticRegression para tarefas de classificação (ou LogisticRegressionCV se a validação cruzada estiver habilitada) e ElasticNet para tarefas de regressão/previsão (ou ElasticNetCV se a validação cruzada estiver habilitada). Esse parâmetro pode ser uma das seguintes cadeias de caracteres: LogisticRegression, LogisticRegressionCV, LightGBMClassifier, ElasticNet, ElasticNetCV, LightGBMRegressor, ou LinearRegression.

• stack_meta_learner_train_percentage: especifica a proporção do conjunto de formação (ao escolher o tipo de formação de formação e de validação) a reservar para a formação do meta-aluno. O valor predefinido é 0.2.

• stack_meta_learner_kwargs: parâmetros opcionais para passar para o inicializador do meta-aluno. Esses parâmetros e tipos de parâmetros espelham os parâmetros e tipos de parâmetros do construtor de modelo correspondente e são encaminhados para o construtor de modelo.

O código a seguir mostra um exemplo de especificação do comportamento de conjunto personalizado em um AutoMLConfig objeto.

ensemble_settings = {
                     "ensemble_download_models_timeout_sec": 600
                     "stack_meta_learner_type": "LogisticRegressionCV",
                     "stack_meta_learner_train_percentage": 0.3,
                     "stack_meta_learner_kwargs": {
                                                    "refit": True,
                                                    "fit_intercept": False,
                                                    "class_weight": "balanced",
                                                    "multi_class": "auto",
                                                    "n_jobs": -1
                                                  }
                    }
automl_classifier = AutoMLConfig(
                                 task='classification',
                                 primary_metric='AUC_weighted',
                                 experiment_timeout_minutes=30,
                                 training_data=train_data,
                                 label_column_name=label,
                                 n_cross_validations=5,
                                 **ensemble_settings
                                )

Critérios de saída

Há algumas opções que você pode definir em seu AutoMLConfig para terminar seu experimento.

Executar experimentação

Para ML automatizado, você cria um Experiment objeto, que é um objeto nomeado em um Workspace usado para executar experimentos.

from azureml.core.experiment import Experiment

ws = Workspace.from_config()

# Choose a name for the experiment and specify the project folder.
experiment_name = 'Tutorial-automl'
project_folder = './sample_projects/automl-classification'

experiment = Experiment(ws, experiment_name)

Submeta a experimentação para executar e gerar um modelo. Passe o AutoMLConfig para o submit método para gerar o modelo.

run = experiment.submit(automl_config, show_output=True)

Vários filhos são executados em clusters

As execuções filhas automatizadas de experimentos de ML podem ser executadas em um cluster que já esteja executando outro experimento. No entanto, o tempo depende de quantos nós o cluster tem e se esses nós estão disponíveis para executar um experimento diferente.

Cada nó no cluster atua como uma máquina virtual (VM) individual que pode realizar uma única execução de treinamento; para ML automatizado, isso significa uma execução filho. Se todos os nós estiverem ocupados, o novo experimento será enfileirado. Mas se houver nós livres, o novo experimento executará execuções filho de ML automatizadas em paralelo nos nós/VMs disponíveis.

Para ajudar a gerenciar execuções filho e quando elas podem ser executadas, recomendamos que você crie um cluster dedicado por experimento e faça a correspondência entre o número do max_concurrent_iterations experimento e o número de nós no cluster. Dessa forma, você usa todos os nós do cluster ao mesmo tempo com o número de execuções/iterações filhas simultâneas desejadas.

Configure max_concurrent_iterations em seu AutoMLConfig objeto. Se não estiver configurado, então, por padrão, apenas uma execução/iteração filho simultânea é permitida por experimento. No caso da instância de computação, max_concurrent_iterations pode ser definido como o mesmo número de núcleos na VM da instância de computação.

Explore modelos e métricas

O ML automatizado oferece opções para você monitorar e avaliar seus resultados de treinamento.

• Você pode visualizar os resultados do treinamento em um widget ou em linha se estiver em um bloco de anotações. Consulte Monitorar execuções automatizadas de aprendizado de máquina para obter mais detalhes.

• Para obter definições e exemplos dos gráficos e métricas de desempenho fornecidos para cada execução, consulte Avaliar resultados de experimentos de aprendizado de máquina automatizados.

• Para obter um resumo de featurização e entender quais recursos foram adicionados a um modelo específico, consulte Transparência de featurização.

Você pode exibir os hiperparâmetros, as técnicas de dimensionamento e normalização e o algoritmo aplicado a uma execução de ML automatizada específica com a solução de código personalizado, print_model().

Monitore execuções automatizadas de aprendizado de máquina

Para execuções automatizadas de ML, para acessar os gráficos de uma execução anterior, substitua <<experiment_name>> pelo nome do experimento apropriado:

from azureml.widgets import RunDetails
from azureml.core.run import Run

experiment = Experiment (workspace, <<experiment_name>>)
run_id = 'autoML_my_runID' #replace with run_ID
run = Run(experiment, run_id)
RunDetails(run).show()

Modelos de teste (pré-visualização)

Passar os test_data parâmetros ou test_size para o AutoMLConfig, dispara automaticamente uma execução de teste remoto que usa os dados de teste fornecidos para avaliar o melhor modelo que o ML automatizado recomenda após a conclusão do experimento. Esta execução de teste remoto é feita no final do experimento, uma vez que o melhor modelo é determinado. Veja como passar os dados de teste para o seu AutoMLConfig.

Obter resultados de trabalhos de teste

Você pode obter as previsões e métricas do trabalho de teste remoto do estúdio do Azure Machine Learning ou com o código a seguir.

best_run, fitted_model = remote_run.get_output()
test_run = next(best_run.get_children(type='automl.model_test'))
test_run.wait_for_completion(show_output=False, wait_post_processing=True)

# Get test metrics
test_run_metrics = test_run.get_metrics()
for name, value in test_run_metrics.items():
    print(f"{name}: {value}")

# Get test predictions as a Dataset
test_run_details = test_run.get_details()
dataset_id = test_run_details['outputDatasets'][0]['identifier']['savedId']
test_run_predictions = Dataset.get_by_id(workspace, dataset_id)
predictions_df = test_run_predictions.to_pandas_dataframe()

# Alternatively, the test predictions can be retrieved via the run outputs.
test_run.download_file("predictions/predictions.csv")
predictions_df = pd.read_csv("predictions.csv")

O trabalho de teste de modelo gera o arquivo de predictions.csv armazenado no armazenamento de dados padrão criado com o espaço de trabalho. Esse armazenamento de dados é visível para todos os usuários com a mesma assinatura. Os trabalhos de teste não são recomendados para cenários se alguma das informações usadas ou criadas pelo trabalho de teste precisar permanecer privada.

Testar o modelo de ML automatizado existente

Para testar outros modelos de ML automatizados existentes criados, melhor trabalho ou trabalho filho, use ModelProxy() para testar um modelo após a conclusão da execução principal do AutoML. ModelProxy() já retorna as previsões e métricas e não requer processamento adicional para recuperar as saídas.

O código a seguir demonstra como testar um modelo de qualquer execução usando o método ModelProxy.test(). No método test(), você tem a opção de especificar se deseja ver apenas as previsões da execução do teste com o include_predictions_only parâmetro.

from azureml.train.automl.model_proxy import ModelProxy

model_proxy = ModelProxy(child_run=my_run, compute_target=cpu_cluster)
predictions, metrics = model_proxy.test(test_data, include_predictions_only= True
)

Registrar e implantar modelos

Depois de testar um modelo e confirmar que deseja usá-lo na produção, você pode registrá-lo para uso posterior e

Para registrar um modelo de uma execução automatizada de ML, use o register_model() método.

best_run = run.get_best_child()
print(fitted_model.steps)

model_name = best_run.properties['model_name']
description = 'AutoML forecast example'
tags = None

model = run.register_model(model_name = model_name, 
                                  description = description, 
                                  tags = tags)

Para obter detalhes sobre como criar uma configuração de implantação e implantar um modelo registrado em um serviço Web, consulte como e onde implantar um modelo.

Capacidade de interpretação do modelo

A interpretabilidade do modelo permite que você entenda por que seus modelos fizeram previsões e os valores de importância do recurso subjacentes. O SDK inclui vários pacotes para habilitar recursos de interpretabilidade de modelo, tanto no momento do treinamento quanto da inferência, para modelos locais e implantados.

Veja como habilitar recursos de interpretabilidade especificamente em experimentos automatizados de ML.

Para obter informações gerais sobre como as explicações do modelo e a importância dos recursos podem ser habilitadas em outras áreas do SDK fora do aprendizado de máquina automatizado, consulte o artigo conceitual sobre interpretabilidade .

Próximos passos

• Saiba mais sobre como e onde implantar um modelo.

• Saiba mais sobre como treinar um modelo de regressão com o aprendizado de máquina automatizado.

• Solucione problemas de experimentos automatizados de ML.