Usar o AutoML em um pipeline do Azure Machine Learning

2025-05-06

APLICA-SE A:Azure Machine Learning SDK v1 para Python

Importante

Este artigo fornece informações sobre como usar o SDK do Azure Machine Learning v1. O SDK v1 foi preterido a partir de 31 de março de 2025. O suporte para ele terminará em 30 de junho de 2026. Você pode instalar e usar o SDK v1 até essa data.

Recomendamos que você faça a transição para o SDK v2 antes de 30 de junho de 2026. Para obter mais informações sobre o SDK v2, consulte o que é a CLI do Azure Machine Learning e o SDK do Python v2? e a referência do SDK v2.

A funcionalidade de AutoML (machine learning automatizado) do Azure Machine Learning ajuda você a descobrir modelos de alto desempenho sem reimplementar todas as abordagens possíveis. Combinado com pipelines do Azure Machine Learning, você pode criar fluxos de trabalho implantáveis que descobrem rapidamente o algoritmo que funciona melhor para seus dados.

Este artigo explica como unir com eficiência uma etapa de preparação de dados a uma etapa de aprendizado de máquina automatizada usando o Python. O AutoML pode descobrir rapidamente o algoritmo que funciona melhor para seus dados, ao mesmo tempo em que coloca você no caminho para MLOps e operacionalização do ciclo de vida do modelo com pipelines.

Pré-requisitos

Uma assinatura do Azure. Caso não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar. Experimente hoje mesmo a versão gratuita ou paga do Azure Machine Learning.
Um workspace do Azure Machine Learning. Consulte Criar recursos que você precisa para começar.
Familiaridade com instalações e SDK do aprendizado de máquina automatizado e pipelines de aprendizado de máquina.

Revise as classes centrais do AutoML

O machine learning automatizado em um pipeline é representado por um AutoMLStep objeto. A classe AutoMLStep é uma subclasse de PipelineStep. Um grafo de PipelineStep objetos define um Pipeline.

Há várias subclasses de PipelineStep. Além do AutoMLStep, este artigo mostra um PythonScriptStep para a preparação de dados e outro para registrar o modelo.

A maneira preferida de mover dados inicialmente para um pipeline de aprendizado de máquina é com Dataset objetos. Para mover dados entre etapas e salvar a saída de dados das execuções, a maneira preferida é com objetos OutputFileDatasetConfig e OutputTabularDatasetConfig. Para ser usado com AutoMLStep, o objeto PipelineData deve ser transformado em um objeto PipelineOutputTabularDataset. Para obter mais informações, consulte Movendo dados para dentro e entre as etapas do pipeline de ML.

O AutoMLStep é configurado por meio de um objeto AutoMLConfig. AutoMLConfig é uma classe flexível, conforme discutido em Definir as configurações do experimento.

Um Pipeline é executado em um Experiment. O pipeline Run tem, para cada etapa, um StepRun filho. As saídas do aprendizado StepRun de máquina automatizado são as métricas de treinamento e o modelo de melhor desempenho.

Para tornar as coisas concretas, este artigo cria um pipeline simples para uma tarefa de classificação. A tarefa é prever a sobrevivência do Titanic, mas não discutimos os dados ou a tarefa, exceto ocasionalmente.

Introdução

Recuperar conjunto de dados inicial

Geralmente, um fluxo de trabalho de machine learning começa com dados de linha de base pré-existentes. Esse é um bom cenário para um conjunto de dados registrado. Os conjuntos de dados são visíveis no espaço de trabalho, no controle de versão de suporte e podem ser explorados interativamente. Há muitas maneiras de criar e popular um conjunto de dados, conforme discutido em Criar conjuntos de dados de Azure Machine Learning. Como estamos usando o SDK do Python para criar nosso pipeline, use o SDK para baixar dados de linha de base e registrá-los com o nome titanic_ds.

from azureml.core import Workspace, Dataset

ws = Workspace.from_config()
if not 'titanic_ds' in ws.datasets.keys() :
    # create a TabularDataset from Titanic training data
    web_paths = ['https://dprepdata.blob.core.windows.net/demo/Titanic.csv',
                 'https://dprepdata.blob.core.windows.net/demo/Titanic2.csv']
    titanic_ds = Dataset.Tabular.from_delimited_files(path=web_paths)

    titanic_ds.register(workspace = ws,
                                     name = 'titanic_ds',
                                     description = 'Titanic baseline data',
                                     create_new_version = True)

titanic_ds = Dataset.get_by_name(ws, 'titanic_ds')

O código primeiro efetua login no espaço de trabalho do Azure Machine Learning definido em config.json. Para saber como criar arquivos de configuração, consulte Criar um arquivo de configuração do workspace. Se já não houver um conjunto de dados chamado 'titanic_ds' registrado, ele criará um. O código baixa dados CSV da web, instancia um TabularDataset e então registra o conjunto de dados no espaço de trabalho. Por fim, a função Dataset.get_by_name() atribui o Dataset para titanic_ds.

Configurar seu armazenamento e o destino de computação

Recursos adicionais de que o pipeline precisa são armazenamento e, em geral, recursos de computação do Azure Machine Learning.

from azureml.core import Datastore
from azureml.core.compute import AmlCompute, ComputeTarget

datastore = ws.get_default_datastore()

compute_name = 'cpu-cluster'
if not compute_name in ws.compute_targets :
    print('creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D2_V2',
                                                                min_nodes=0,
                                                                max_nodes=1)
    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)

    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=20)

    # Show the result
    print(compute_target.get_status().serialize())

compute_target = ws.compute_targets[compute_name]

Os dados intermediários entre a preparação de dados e a etapa do AutoML podem ser armazenados no armazenamento de dados padrão do espaço de trabalho, então você não precisa fazer mais do que chamar get_default_datastore() no objeto Workspace.

Depois disso, o código verifica se o destino de computação 'cpu-cluster' do Azure Machine Learning já existe. Caso contrário, especifique que você deseja um destino de computação baseado em CPU pequeno. Se você planeja usar os recursos de aprendizado profundo do AutoML (por exemplo, a apresentação de texto com suporte a DNN), deverá escolher uma computação com suporte a GPU forte, conforme descrito em tamanhos de máquina virtual otimizados para GPU.

O código é bloqueado até que o destino seja provisionado e, em seguida, imprima alguns detalhes do destino de computação recém-criado. Por fim, o destino de computação nomeado é recuperado do espaço de trabalho e atribuído a compute_target.

Configurar a execução do treinamento

O contexto de tempo de execução é definido criando e configurando um objeto RunConfiguration. Aqui, definimos o destino de computação.

from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies

aml_run_config = RunConfiguration()
# Use just-specified compute target ("cpu-cluster")
aml_run_config.target = compute_target

# Specify CondaDependencies obj, add necessary packages
aml_run_config.environment.python.conda_dependencies = CondaDependencies.create(
    conda_packages=['pandas','scikit-learn'], 
    pip_packages=['azureml-sdk[automl]', 'pyarrow'])

Preparar dados para AutoML

Gravar o código de preparação de dados

O conjunto de dados Titanic de linha de base consiste em dados numéricos e de texto mistos, com alguns valores ausentes. Para prepará-lo para aprendizado de máquina automatizado, a etapa do pipeline de preparação de dados:

Preenche dados ausentes com dados aleatórios ou uma categoria correspondente a Unknown
Transforma dados categóricos em inteiros
Descarta colunas que você não pretende usar
Divide os dados em conjuntos de treinamento e teste
Grava os dados transformados nos OutputFileDatasetConfig diretórios de saída

%%writefile dataprep.py
from azureml.core import Run

import pandas as pd 
import numpy as np 
import argparse

RANDOM_SEED=42

def prepare_age(df):
    # Fill in missing Age values from distribution of present Age values 
    mean = df["Age"].mean()
    std = df["Age"].std()
    is_null = df["Age"].isnull().sum()
    # compute enough (== is_null().sum()) random numbers between the mean, std
    rand_age = np.random.randint(mean - std, mean + std, size = is_null)
    # fill NaN values in Age column with random values generated
    age_slice = df["Age"].copy()
    age_slice[np.isnan(age_slice)] = rand_age
    df["Age"] = age_slice
    df["Age"] = df["Age"].astype(int)
    
    # Quantize age into 5 classes
    df['Age_Group'] = pd.qcut(df['Age'],5, labels=False)
    df.drop(['Age'], axis=1, inplace=True)
    return df

def prepare_fare(df):
    df['Fare'].fillna(0, inplace=True)
    df['Fare_Group'] = pd.qcut(df['Fare'],5,labels=False)
    df.drop(['Fare'], axis=1, inplace=True)
    return df 

def prepare_genders(df):
    genders = {"male": 0, "female": 1, "unknown": 2}
    df['Sex'] = df['Sex'].map(genders)
    df['Sex'].fillna(2, inplace=True)
    df['Sex'] = df['Sex'].astype(int)
    return df

def prepare_embarked(df):
    df['Embarked'].replace('', 'U', inplace=True)
    df['Embarked'].fillna('U', inplace=True)
    ports = {"S": 0, "C": 1, "Q": 2, "U": 3}
    df['Embarked'] = df['Embarked'].map(ports)
    return df
    
parser = argparse.ArgumentParser()
parser.add_argument('--output_path', dest='output_path', required=True)
args = parser.parse_args()
    
titanic_ds = Run.get_context().input_datasets['titanic_ds']
df = titanic_ds.to_pandas_dataframe().drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1)
df = prepare_embarked(prepare_genders(prepare_fare(prepare_age(df))))

df.to_csv(os.path.join(args.output_path,"prepped_data.csv"))

print(f"Wrote prepped data to {args.output_path}/prepped_data.csv")

O snippet de código anterior é um exemplo completo, mas mínimo, de preparação de dados para os dados do Titanic. O snippet começa com um comando mágico da Jupyter para exportar o código para um arquivo. Se você não estiver usando um notebook Jupyter, remova essa linha e crie o arquivo manualmente.

As várias funções do trecho prepare_ modificam a coluna relevante no conjunto de dados de entrada. Essas funções funcionam nos dados depois de serem alterados em um objeto Pandas DataFrame. Em cada caso, os dados ausentes são preenchidos com dados aleatórios representativos ou dados categóricos que indicam Desconhecido. Os dados categóricos baseados em texto são mapeados para inteiros. Colunas não mais necessárias são substituídas ou descartadas.

Depois que o código define as funções de preparação de dados, o código analisa o argumento de entrada, que é o caminho para o qual desejamos escrever nossos dados. (Esses valores são determinados por OutputFileDatasetConfig objetos que serão discutidos na próxima etapa.) O código recupera o 'titanic_cs'Dataset registrado, converte-o em um Pandas DataFrame e chama as várias funções de preparação de dados.

Como o output_path é um diretório, a chamada para to_csv() especifica o nome do arquivo prepped_data.csv.

Gravar a etapa do pipeline de preparação de dados (`PythonScriptStep`)

O código de preparação de dados descrito deve ser associado a um objeto PythonScriptStep a ser usado com um pipeline. O caminho para o qual a saída CSV é gravada é gerado por um objeto OutputFileDatasetConfig. Os recursos preparados anteriormente, como ComputeTarget, RunConfig e 'titanic_ds' Dataset são usados para concluir a especificação.

from azureml.data import OutputFileDatasetConfig
from azureml.pipeline.steps import PythonScriptStep

prepped_data_path = OutputFileDatasetConfig(name="output_path")

dataprep_step = PythonScriptStep(
    name="dataprep", 
    script_name="dataprep.py", 
    compute_target=compute_target, 
    runconfig=aml_run_config,
    arguments=["--output_path", prepped_data_path],
    inputs=[titanic_ds.as_named_input('titanic_ds')],
    allow_reuse=True
)

O objeto prepped_data_path é do tipo OutputFileDatasetConfig que aponta para um diretório. Observe que ele está especificado no parâmetro arguments. Se você examinar a etapa anterior, verá que, dentro do código de preparação de dados, o valor do argumento '--output_path' é o caminho do diretório no qual o arquivo CSV foi gravado.

Treinar com o AutoMLStep

A configuração de uma etapa automatizada do pipeline de machine learning é feita com a AutoMLConfig classe. Para saber mais sobre essa classe flexível, consulte a Classe AutoMLConfig. A entrada e a saída de dados são os únicos aspectos da configuração que exigem atenção especial em um pipeline de machine learning. A entrada e a saída de AutoMLConfig em pipelines serão discutidas mais adiante nesse artigo. Além dos dados, uma vantagem dos pipelines de aprendizado de máquina é a capacidade de usar diferentes alvos computacionais em diferentes etapas. Você pode optar por usar um mais poderoso ComputeTarget apenas para o processo de machine learning automatizado. Fazer isso é tão simples quanto atribuir um RunConfiguration mais poderoso ao parâmetro do AutoMLConfig objeto run_configuration.

Enviar dados para AutoMLStep

Em um pipeline de machine learning, os dados de entrada devem ser um Dataset objeto. A maneira de desempenho mais alto é fornecer os dados de entrada na forma de objetos OutputTabularDatasetConfig. Você cria um objeto desse tipo com o read_delimited_files() em um OutputFileDatasetConfig, como prepped_data_path, como o objeto prepped_data_path.

# type(prepped_data) == OutputTabularDatasetConfig
prepped_data = prepped_data_path.read_delimited_files()

Outra opção é usar Dataset objetos registrados no espaço de trabalho:

prepped_data = Dataset.get_by_name(ws, 'Data_prepared')

Comparando as duas técnicas:

Técnica	Benefícios e desvantagens
`OutputTabularDatasetConfig`	Maior desempenho
	Rota natural de `OutputFileDatasetConfig`
	Os dados não são persistidos após a execução do pipeline

Registrado `Dataset`	Desempenho inferior
	Pode ser gerado de várias maneiras
	Os dados persistem e ficam visíveis em todo o espaço de trabalho
	Notebook mostrando `Dataset` técnica registrada

Especificar saídas de AutoML

As saídas das AutoMLStep são as pontuações de métricas finais do modelo de maior desempenho e o próprio modelo. Para usar essas saídas em etapas de pipeline adicionais, prepare objetos OutputFileDatasetConfig para recebê-las.

from azureml.pipeline.core import TrainingOutput, PipelineData

metrics_data = PipelineData(name='metrics_data',
                            datastore=datastore,
                            pipeline_output_name='metrics_output',
                            training_output=TrainingOutput(type='Metrics'))

model_data = PipelineData(name='best_model_data',
                          datastore=datastore,
                          pipeline_output_name='model_output',
                          training_output=TrainingOutput(type='Model'))

Esse snippet cria os dois PipelineData objetos para as métricas e a saída do modelo. Cada um é nomeado, atribuído ao armazenamento de dados padrão recuperado anteriormente e associado com o específico type de TrainingOutput do AutoMLStep. Como atribuímos pipeline_output_name nesses PipelineData objetos, seus valores estão disponíveis não apenas na etapa de pipeline individual, mas no pipeline como um todo, conforme discutido posteriormente na seção Examinar os resultados do pipeline.

Configurar e criar a etapa de pipeline do AutoML

Depois que as entradas e saídas são definidas, é hora de criar AutoMLConfig e AutoMLStep. Os detalhes da configuração dependem de sua tarefa, conforme descrito em Configurar o treinamento do AutoML com Python. Para a tarefa de classificação de sobrevivência Titanic, o trecho a seguir demonstra uma configuração simples.

from azureml.train.automl import AutoMLConfig
from azureml.pipeline.steps import AutoMLStep

# Change iterations to a reasonable number (50) to get better accuracy
automl_settings = {
    "iteration_timeout_minutes" : 10,
    "iterations" : 2,
    "experiment_timeout_hours" : 0.25,
    "primary_metric" : 'AUC_weighted'
}

automl_config = AutoMLConfig(task = 'classification',
                             path = '.',
                             debug_log = 'automated_ml_errors.log',
                             compute_target = compute_target,
                             run_configuration = aml_run_config,
                             featurization = 'auto',
                             training_data = prepped_data,
                             label_column_name = 'Survived',
                             **automl_settings)

train_step = AutoMLStep(name='AutoML_Classification',
    automl_config=automl_config,
    passthru_automl_config=False,
    outputs=[metrics_data,model_data],
    enable_default_model_output=False,
    enable_default_metrics_output=False,
    allow_reuse=True)

O trecho mostra um idioma comumente usado com AutoMLConfig. Os argumentos que são mais fluidos (hiperparâmetro-ish) são especificados em um dicionário separado, enquanto os valores menos prováveis de serem alterados são especificados diretamente no construtor AutoMLConfig. Nesse caso, o automl_settings especifica uma breve execução: a execução é interrompida após apenas duas iterações ou 15 minutos, o que ocorrer primeiro.

O automl_settings dicionário é passado para o AutoMLConfig Construtor como kwargs. Os outros parâmetros não são complexos:

task é definido como classification para este exemplo. Outros valores válidos são regression e forecasting.
path e debug_log descrevem o caminho para o projeto e um arquivo local ao qual as informações de depuração são gravadas.
compute_target é o compute_target definido anteriormente que, neste exemplo, é um computador baseado em CPU de baixo custo. Se você estiver usando as instalações de aprendizado profundo do AutoML, você desejará alterar o destino de computação para ser baseado em GPU.
featurization está definido como auto. Mais detalhes podem ser encontrados na seção Sobre featurização de dados do documento de configuração do AutoML.
label_column_name indica qual coluna você está interessado em prever.
training_data é determinado pelos objetos OutputTabularDatasetConfig criados a partir das saídas da etapa de preparação de dados.

O próprio AutoMLStep usa AutoMLConfig e tem, como saídas, os objetosPipelineData criados para manter as métricas e os dados do modelo.

Importante

Você deve definir enable_default_model_output e enable_default_metrics_output para True somente se estiver usando AutoMLStepRun.

Neste exemplo, o processo autoML executa validações cruzadas no training_data. Você pode controlar o número de validações cruzadas com o argumento n_cross_validations. Se você já tiver dividido os dados de treinamento como parte de suas etapas de preparação de dados, poderá definir validation_data como seu próprio Dataset.

Ocasionalmente, você pode ver o uso de X para recursos de dados e y para rótulos de dados. Essa técnica foi preterida e você deve usar training_data para entrada.

Registrar o modelo gerado pelo AutoML

A última etapa em um pipeline de machine learning simples é registrar o modelo criado. Ao adicionar o modelo ao registro de modelos do espaço de trabalho, ele fica disponível no portal do Azure e pode ser versionado. Para registrar o modelo, escreva outro PythonScriptStep que receba a saída model_data do AutoMLStep.

Escreva o código para registrar o modelo

Um modelo é registrado em um Workspace. Você provavelmente está familiarizado com o uso de Workspace.from_config() para fazer login no seu workspace em seu computador local, mas existe outra maneira de acessar o workspace a partir de um pipeline de machine learning em execução. O Run.get_context() recupera o ativo run. Este objeto run fornece acesso a muitos objetos importantes, incluindo o Workspace usado aqui.

%%writefile register_model.py
from azureml.core.model import Model, Dataset
from azureml.core.run import Run, _OfflineRun
from azureml.core import Workspace
import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--model_name", required=True)
parser.add_argument("--model_path", required=True)
args = parser.parse_args()

print(f"model_name : {args.model_name}")
print(f"model_path: {args.model_path}")

run = Run.get_context()
ws = Workspace.from_config() if type(run) == _OfflineRun else run.experiment.workspace

model = Model.register(workspace=ws,
                       model_path=args.model_path,
                       model_name=args.model_name)

print("Registered version {0} of model {1}".format(model.version, model.name))

Escrever o código PythonScriptStep

Aviso

Se você estiver usando o SDK do Azure Machine Learning v1 e seu workspace estiver configurado para isolamento de rede, você poderá receber um erro ao executar esta etapa. Para mais informações, consulte HyperdriveStep e AutoMLStep falham com o isolamento da rede.

O registro de modelo PythonScriptStep usa um PipelineParameter para um de seus argumentos. Os parâmetros de pipeline são argumentos para pipelines que podem ser facilmente definidos em tempo de envio de execução. Depois de declarado, eles são passados como argumentos normais.


from azureml.pipeline.core.graph import PipelineParameter

# The model name with which to register the trained model in the workspace.
model_name = PipelineParameter("model_name", default_value="TitanicSurvivalInitial")

register_step = PythonScriptStep(script_name="register_model.py",
                                       name="register_model",
                                       allow_reuse=False,
                                       arguments=["--model_name", model_name, "--model_path", model_data],
                                       inputs=[model_data],
                                       compute_target=compute_target,
                                       runconfig=aml_run_config)

Criar e executar o pipeline do AutoML

Criar e executar um pipeline que contém um AutoMLStep não é diferente de um pipeline normal.

from azureml.pipeline.core import Pipeline
from azureml.core import Experiment

pipeline = Pipeline(ws, [dataprep_step, train_step, register_step])

experiment = Experiment(workspace=ws, name='titanic_automl')

run = experiment.submit(pipeline, show_output=True)
run.wait_for_completion()

Esse código combina as etapas de preparação de dados, aprendizado de máquina automatizado e registro de modelo em um Pipeline objeto. Em seguida, ele cria um objeto Experiment. O Experiment construtor recupera o experimento nomeado se ele existir ou o cria, se necessário. Ele submete o Pipeline ao Experiment, criando um objeto Run que executa o pipeline de forma assíncrona. A função wait_for_completion() é bloqueada até que a execução seja concluída.

Examinar os resultados do pipeline

Depois que o run for concluído, você pode recuperar PipelineData objetos aos quais foi atribuído um pipeline_output_name. Você pode baixar os resultados e carregá-los para processamento adicional.

metrics_output_port = run.get_pipeline_output('metrics_output')
model_output_port = run.get_pipeline_output('model_output')

metrics_output_port.download('.', show_progress=True)
model_output_port.download('.', show_progress=True)

Os arquivos baixados são gravados no subdiretório azureml/{run.id}/. O arquivo de métricas é formatado em JSON e pode ser convertido em um dataframe do Pandas para exame.

Para o processamento local, talvez você precise instalar os pacotes relevantes como o Pandas, o Pickle, o SDK do Azure Machine Learning etc. Para este exemplo, é provável que o melhor modelo encontrado pelo machine learning automatizado dependa do XGBoost.

!pip install xgboost==0.90

import pandas as pd
import json

metrics_filename = metrics_output._path_on_datastore
# metrics_filename = path to downloaded file
with open(metrics_filename) as f:
   metrics_output_result = f.read()
   
deserialized_metrics_output = json.loads(metrics_output_result)
df = pd.DataFrame(deserialized_metrics_output)
df

Este snippet de código mostra o arquivo de métricas sendo carregado de sua localização no armazenamento de dados do Azure. Você também pode carregá-lo do arquivo baixado, conforme mostrado no comentário. Depois de desserializá-lo e convertê-lo em um DataFrame do Pandas, você poderá ver métricas detalhadas para cada uma das iterações da etapa de machine learning automatizada.

O arquivo de modelo pode ser desserializado em um objeto Model que você pode usar para inferência, análise de métricas adicionais e assim por diante.

import pickle

model_filename = model_output._path_on_datastore
# model_filename = path to downloaded file

with open(model_filename, "rb" ) as f:
    best_model = pickle.load(f)

# ... inferencing code not shown ...

Para obter mais informações sobre como carregar e trabalhar com modelos existentes, consulte Implantar modelos de machine learning no Azure.

Baixar os resultados de uma execução do AutoML

Se você tem acompanhado o artigo, você tem um objeto Run já instanciado. Mas você também pode recuperar objetos concluídos Run do Workspace por meio de um objeto Experiment.

O espaço de trabalho contém um registro completo de todos os experimentos e execuções. Você pode usar o portal para localizar e baixar as saídas de experimentos ou usar o código. Para acessar os registros de uma execução histórica, use o Azure Machine Learning para encontrar a ID da execução na qual você está interessado. Com essa ID, você pode escolher o específico run por meio do Workspace e do Experiment.

# Retrieved from Azure Machine Learning web UI
run_id = 'aaaaaaaa-bbbb-cccc-dddd-0123456789AB'
experiment = ws.experiments['titanic_automl']
run = next(run for run in ex.get_runs() if run.id == run_id)

Você precisa alterar a cadeia de caracteres run_id no código anterior para o ID específico de sua execução anterior. O snippet pressupõe que você atribuiu ws ao relevante Workspace com o normalfrom_config(). O experimento de interesse é recuperado diretamente e, em seguida, o código encontra o Run de interesse correspondendo ao valorrun.id.

Depois de ter um objeto Run, você pode baixar as métricas e o modelo.

automl_run = next(r for r in run.get_children() if r.name == 'AutoML_Classification')
outputs = automl_run.get_outputs()
metrics = outputs['default_metrics_AutoML_Classification']
model = outputs['default_model_AutoML_Classification']

metrics.get_port_data_reference().download('.')
model.get_port_data_reference().download('.')

Cada objeto Run contém objetos StepRun que contêm informações sobre a execução da etapa de pipeline individual. O run é pesquisado para o objeto StepRun para o AutoMLStep. As métricas e o modelo são recuperados usando seus nomes padrão, que estão disponíveis mesmo se você não passar objetos PipelineData para o parâmetro outputs do AutoMLStep.

Por fim, as métricas reais e o modelo são baixados para o seu computador local, conforme discutido na seção Examinar resultados do pipeline.