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
automlpacote 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-automldo pacote.- Instale o pacote mais recente
azureml-train-automlem seu ambiente local. - Para obter detalhes sobre o pacote mais recente
azureml-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.
Nota
Suporte para tarefas de processamento de linguagem natural (NLP): a classificação de imagem (multiclasse e multi-label) e o reconhecimento de entidade nomeada estão disponíveis na visualização pública. Saiba mais sobre tarefas de PNL em ML automatizado.
Esses recursos de visualização são fornecidos sem um contrato de nível de serviço. Alguns recursos podem não ser suportados ou podem ter funcionalidade restrita. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.
O código a AutoMLConfig seguir usa o parâmetro no construtor para especificar o task 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.
Importante
Os experimentos automatizados de ML não oferecem suporte ao treinamento com conjuntos de dados que usam acesso a dados baseado em identidade.
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
Datasetclasse 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.
| Tamanho dos dados de treinamento | Técnica de validação |
|---|---|
| Maior que 20.000 linhas | É aplicada a divisão de dados de comboio/validação. O padrão é tomar 10% do conjunto de dados de treinamento inicial como o conjunto de validação. Por sua vez, esse conjunto de validação é usado para o cálculo de métricas. |
| Menor que 20.000 linhas | É aplicada a abordagem de validação cruzada. O número padrão de dobras depende do número de linhas. Se o conjunto de dados for inferior a 1.000 linhas, 10 dobras serão usadas. Se as linhas estiverem entre 1.000 e 20.000, então três dobras são usadas. |
Gorjeta
Você pode carregar dados de teste (visualização) para avaliar modelos que automatizaram o ML gerado para você. Esses recursos são recursos de visualização experimental e podem ser alterados a qualquer momento. Aprenda a:
- Passe os dados de teste para seu objeto AutoMLConfig.
- Teste os modelos de ML automatizados gerados para seu experimento.
Se preferir uma experiência sem código, consulte a etapa 12 em Configurar o AutoML com a interface do usuário do estúdio
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 SVM Linear tem dados grandes e versões de dados pequenos.
Se você quiser substituir essas heurísticas, aplique as seguintes configurações:
| Tarefa | Definição | Notas |
|---|---|---|
| Bloquear algoritmos de streaming de dados | blocked_models no seu AutoMLConfig objeto e liste o(s) modelo(s) que não pretende utilizar. |
Resulta em falha de execução ou tempo de execução longo |
| Usar algoritmos de streaming de dados | allowed_models no seu AutoMLConfig objeto e liste o(s) modelo(s) que deseja usar. |
|
| Usar algoritmos de streaming de dados (experimentos de UI de estúdio) |
Bloqueie todos os modelos, exceto os algoritmos de big data que você deseja usar. |
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
AutoMLparalelizará 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:
| Prós (Vantagens) | Contras (Handicaps) | |
|---|---|---|
| Destino de computação local | ||
| Clusters de computação de ML remoto |
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 parâmetros ou para modificar iterações com os allowed_models modelos disponíveis para incluir ou blocked_models excluir.
A tabela a seguir resume os modelos suportados por tipo de tarefa.
Nota
Se você planeja exportar seus modelos automatizados criados por ML para um modelo ONNX, somente os algoritmos indicados com um * (asterisco) poderão ser convertidos para o formato ONNX. Saiba mais sobre como converter modelos para ONNX.
Observe também que o ONNX só suporta tarefas de classificação e regressão no momento.
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 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, , , 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,0recall_score_weightednorm_macro_recall. 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étrico | Exemplo(s) de caso(s) de uso |
|---|---|
accuracy |
Classificação de imagem, Análise de sentimento, Previsão de churn |
AUC_weighted |
Deteção de fraudes, Classificação de imagens, Deteção de anomalias/spam |
average_precision_score_weighted |
Análise de sentimentos |
norm_macro_recall |
Previsão de churn |
precision_score_weighted |
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 é a forma como são normalizados e normalized_root_mean_squared_error 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.
Nota
r2_score e normalized_root_mean_squared_error também se comportam de forma semelhante como métricas primárias. Se um conjunto de validação fixo for aplicado, essas duas métricas otimizarão o mesmo destino, erro quadrado médio e serão otimizadas pelo mesmo modelo. Quando apenas um conjunto de treinamento está disponível e a validação cruzada é aplicada, eles seriam ligeiramente diferentes, pois o normalizador para é fixado como o intervalo do conjunto de treinamento, mas o normalizador para variaria para cada dobra, pois é a variância para normalized_root_mean_squared_errorr2_score cada dobra.
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 dados para regressão ou à mesma série temporal especificada pelo identificador de r2_scorenormalized_mean_absolute_errorsé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étrico | Exemplo(s) de caso(s) de uso |
|---|---|
spearman_correlation |
|
normalized_root_mean_squared_error |
Previsão de preços (casa/produto/dica), Previsão de pontuação de revisão |
r2_score |
Atraso da companhia aérea, estimativa salarial, tempo de resolução de bugs |
normalized_mean_absolute_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.
| Métrico | Exemplo(s) de caso(s) de uso |
|---|---|
normalized_root_mean_squared_error |
Previsão de preços (previsão), Otimização de estoque, Previsão de demanda |
r2_score |
Previsão de preços (previsão), Otimização de estoque, Previsão de demanda |
normalized_mean_absolute_error |
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.
Nota
Etapas automatizadas de featurização de aprendizado de máquina (normalização de recursos, manipulação de dados ausentes, conversão de texto em numérico, etc.) tornam-se parte do modelo subjacente. Ao usar o modelo para previsões, as mesmas etapas de featurização aplicadas durante o treinamento são aplicadas aos seus dados de entrada automaticamente.
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 de Featurização | Descrição |
|---|---|
"featurization": 'auto' |
Indica que, como parte do pré-processamento, as proteções de dados e as etapas de featurização são executadas automaticamente. Configuração padrão. |
"featurization": 'off' |
Indica que a etapa de featurização não deve ser feita automaticamente. |
"featurization": 'FeaturizationConfig' |
Indica que a etapa de featurização personalizada deve ser usada. Saiba como personalizar a featurização. |
Configuração do Ensemble
Os modelos Ensemble são habilitados por padrão e aparecem como as iterações de execução finais em uma execução 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.
Importante
Os parâmetros a seguir não são parâmetros explícitos da classe AutoMLConfig.
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ãoLogisticRegressionpara tarefas de classificação (ou se a validação cruzada estiver habilitada) eElasticNetpara tarefas de regressão/previsão (ouLogisticRegressionCVElasticNetCVse a validação cruzada estiver habilitada). Esse parâmetro pode ser uma das seguintes cadeias de caracteres:LogisticRegression, , , , ,LightGBMRegressorElasticNetCV,ElasticNetLogisticRegressionCVLightGBMClassifierou .LinearRegressionstack_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.
| Critérios | descrição |
|---|---|
| Sem critérios | Se você não definir nenhum parâmetro de saída, o experimento continuará até que nenhum progresso adicional seja feito em sua métrica principal. |
| Após um período de tempo | Use experiment_timeout_minutes em suas configurações para definir por quanto tempo, em minutos, seu experimento deve continuar a ser executado. Para ajudar a evitar falhas no tempo limite do experimento, há um mínimo de 15 minutos, ou 60 minutos se o tamanho da linha por coluna exceder 10 milhões. |
| Foi atingida uma pontuação | Use experiment_exit_score conclui o experimento depois que uma pontuação métrica primária especificada é atingida. |
Executar experimentação
Aviso
Se você executar um experimento com as mesmas definições de configuração e métrica primária várias vezes, provavelmente verá variação na pontuação final de cada experimento e nos modelos gerados. Os algoritmos que o ML automatizado emprega têm aleatoriedade inerente que pode causar uma pequena variação na saída dos modelos pelo experimento e na pontuação final das métricas do modelo recomendado, como precisão. Você provavelmente também verá resultados com o mesmo nome de modelo, mas hiperparâmetros diferentes usados.
Para ML automatizado, você cria um objeto, que é um objeto nomeado em um ExperimentWorkspace 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 para o método para gerar o AutoMLConfigsubmit modelo.
run = experiment.submit(automl_config, show_output=True)
Nota
As dependências são instaladas primeiro em uma nova máquina. Pode demorar até 10 minutos até que a saída seja mostrada.
A configuração show_output para True resulta na saída sendo mostrada no console.
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().
Gorjeta
O ML automatizado também permite visualizar o código de treinamento de modelo gerado para modelos treinados em ML automático. Esta funcionalidade está em pré-visualização pública e pode ser alterada a qualquer momento.
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)
Importante
Testar seus modelos com um conjunto de dados de teste para avaliar modelos automatizados gerados por ML é um recurso de visualização. Esse recurso é um recurso de visualização experimental e pode ser alterado a qualquer momento.
Aviso
Esse recurso não está disponível para os seguintes cenários de ML automatizado:
Passar os parâmetros ou test_size para o , dispara automaticamente uma execução de teste remoto que usa os test_data dados de teste fornecidos para avaliar o AutoMLConfigmelhor 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 .csv previsões 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.
Nota
ModelProxy é uma classe de visualização experimental e pode mudar a qualquer momento.
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.
Gorjeta
Para modelos registrados, a implantação com um clique está disponível por meio do estúdio do Azure Machine Learning. Veja como implantar modelos registrados a partir do estúdio.
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 .
Nota
O modelo ForecastTCN não é suportado atualmente pelo Explanation Client. Esse modelo não retornará um painel de explicação se ele for retornado como o melhor modelo e não oferecer suporte a execuções de explicação sob demanda.
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.