Utilizar o machine learning automatizado num pipeline do Azure Machine Learning no Python
APLICA-SE A:
Python SDK azureml v1
O recurso de ML automatizado do Azure Machine Learning ajuda você a descobrir modelos de alto desempenho sem que você reimplemente todas as abordagens possíveis. Combinado com os pipelines do Azure Machine Learning, você pode criar fluxos de trabalho implantáveis que podem descobrir rapidamente o algoritmo que funciona melhor para seus dados. Este artigo mostrará como unir eficientemente uma etapa de preparação de dados a uma etapa de ML automatizada. O ML automatizado pode descobrir rapidamente o algoritmo que funciona melhor para seus dados, ao mesmo tempo em que coloca você no caminho para MLOps e a operacionalização do ciclo de vida do modelo com pipelines.
Pré-requisitos
Uma subscrição do Azure. Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar. Experimente hoje mesmo a versão gratuita ou paga do Azure Machine Learning .
Uma área de trabalho do Azure Machine Learning. Consulte Criar recursos do espaço de trabalho.
Familiaridade com o aprendizado de máquina automatizado e pipelines de aprendizado de máquina, instalações e SDK do Azure.
Revisar as classes centrais de ML automatizadas
O ML automatizado em um pipeline é representado por um AutoMLStep objeto. A AutoMLStep classe é uma subclasse de PipelineStep. Um gráfico de PipelineStep objetos define um Pipelinearquivo .
Existem várias subclasses de PipelineStep. Além do AutoMLStep, este artigo mostrará um PythonScriptStep para preparação de dados e outro para registro do modelo.
A maneira preferida de mover dados inicialmente para um pipeline de ML é com Dataset objetos. Para mover dados entre etapas e possíveis salvar saída de dados de execuções, a maneira preferida é com OutputFileDatasetConfig e OutputTabularDatasetConfig objetos. Para ser usado com AutoMLStep, o objeto deve ser transformado PipelineData em um PipelineOutputTabularDataset objeto. Para obter mais informações, consulte Dados de entrada e saída de pipelines de ML.
O AutoMLStep é configurado através de um AutoMLConfig objeto. AutoMLConfig é uma classe flexível, conforme discutido em Configurar experimentos automatizados de ML em Python.
A Pipeline corre em um Experimentarquivo . O gasoduto Run tem, para cada passo, um filho StepRun. As saídas do ML StepRun 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 estaremos discutindo os dados ou a tarefa, exceto de passagem.
Começar agora
Recuperar conjunto de dados inicial
Muitas vezes, um fluxo de trabalho de ML começa com dados de linha de base pré-existentes. Este é um bom cenário para um conjunto de dados registrado. Os conjuntos de dados são visíveis em todo o espaço de trabalho, suportam controle de versão e podem ser explorados interativamente. Há muitas maneiras de criar e preencher um conjunto de dados, conforme discutido em Criar conjuntos de dados do Azure Machine Learning. Como usaremos 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 logon no espaço de trabalho do Azure Machine Learning definido no config.json (para obter uma explicação, consulte Criar um arquivo de configuração de espaço de trabalho. Se ainda não houver um conjunto de dados chamado 'titanic_ds' registrado, ele criará um. O código baixa dados CSV da Web, usa-os para instanciar um TabularDataset e, em seguida, registra o conjunto de dados com o espaço de trabalho. Finalmente, a função Dataset.get_by_name() atribui o Dataset a titanic_ds.
Configure seu destino de armazenamento e computação
Recursos adicionais que o pipeline precisará são armazenamento e, geralmente, 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 de ML automatizada podem ser armazenados no armazenamento de dados padrão do espaço de trabalho, portanto, não precisamos fazer mais do que chamar get_default_datastore() o Workspace objeto.
Depois disso, o código verifica se o destino 'cpu-cluster' de computação do Azure Machine Learning já existe. Caso contrário, especificamos que queremos um pequeno destino de computação baseado em CPU. Se você planeja usar os recursos de aprendizado profundo do ML automatizado (por exemplo, featurização de texto com suporte DNN), você deve escolher uma computação com suporte de GPU forte, conforme descrito em Tamanhos de máquina virtual otimizados para GPU.
O código bloqueia até que o destino seja provisionado e, em seguida, imprime alguns detalhes do destino de computação recém-criado. Finalmente, 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 RunConfiguration objeto. Aqui definimos a meta 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 aprendizado de máquina automatizado
Escreva o código de preparação de dados
O conjunto de dados de linha de base do Titanic consiste em dados numéricos e de texto mistos, faltando alguns valores. Para prepará-lo para o aprendizado de máquina automatizado, a etapa do pipeline de preparação de dados irá:
- Preencha os dados em falta com dados aleatórios ou uma categoria correspondente a "Desconhecido"
- Transformar dados categóricos em inteiros
- Soltar colunas que não pretendemos usar
- Divida os dados em conjuntos de treinamento e teste
- Gravar os dados transformados nos caminhos de
OutputFileDatasetConfigsaí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 trecho de código acima é um exemplo completo, mas mínimo, de preparação de dados para os dados do Titanic. O trecho começa com um "comando mágico" do Jupyter para enviar o código para um arquivo. Se você não estiver usando um bloco de anotações Jupyter, remova essa linha e crie o arquivo manualmente.
As várias prepare_ funções no trecho acima modificam a coluna relevante no conjunto de dados de entrada. Essas funções funcionam nos dados depois que eles foram alterados em um objeto Pandas DataFrame . Em cada caso, os dados ausentes são preenchidos com dados aleatórios representativos ou dados categóricos indicando "Desconhecido". Os dados categóricos baseados em texto são mapeados para inteiros. As colunas que não sã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 queremos gravar nossos dados. (Esses valores serão determinados por OutputFileDatasetConfig objetos que serão discutidos na próxima etapa.) O código recupera o registrado 'titanic_cs' Dataset, converte-o em um Pandas DataFramee 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.
Escrever a etapa do pipeline de preparação de dados (PythonScriptStep)
O código de preparação de dados descrito acima deve ser associado a um PythonScripStep objeto a ser usado com um pipeline. O caminho para o qual a saída CSV é gravada é gerado por um OutputFileDatasetConfig objeto. Os recursos preparados anteriormente, como o ComputeTarget, o RunConfig, e o 'titanic_ds' Dataset são usados para completar 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 prepped_data_path objeto é do tipo OutputFileDatasetConfig que aponta para um diretório. Observe que ele está especificado no arguments parâmetro. Se você revisar 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.
Treine com AutoMLStep
A configuração de uma etapa de pipeline de ML automatizada é feita com a AutoMLConfig classe. Essa classe flexível é descrita em Configurar experimentos automatizados de ML em Python. A entrada e saída de dados são os únicos aspetos da configuração que exigem atenção especial em um pipeline de ML. A entrada e saída para AutoMLConfig pipelines é discutida em detalhes abaixo. Além dos dados, uma vantagem dos pipelines de ML é a capacidade de usar diferentes destinos de computação para diferentes etapas. Você pode optar por usar um mais poderoso ComputeTarget apenas para o processo de ML automatizado. Fazer isso é tão simples quanto atribuir um mais poderoso RunConfiguration ao AutoMLConfig parâmetro do run_configuration objeto.
Enviar dados para AutoMLStep
Em um pipeline de ML, os dados de entrada devem ser um Dataset objeto. A maneira de melhor desempenho é fornecer os dados de entrada na forma de OutputTabularDatasetConfig objetos. Você cria um objeto desse tipo com o read_delimited_files() on a OutputFileDatasetConfig, como o , como o prepped_data_pathprepped_data_path objeto.
# 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 | Vantagens e inconvenientes |
|---|---|
OutputTabularDatasetConfig |
Maior desempenho |
Rota natural de OutputFileDatasetConfig |
|
| Os dados não são persistentes após a execução do pipeline | |
Registado Dataset |
Menor desempenho |
| Pode ser gerado de muitas maneiras | |
| Os dados persistem e ficam visíveis em todo o espaço de trabalho | |
Caderno mostrando técnica registrada Dataset |
Especificar saídas de ML automatizadas
As saídas do AutoMLStep são as pontuações métricas finais do modelo de melhor desempenho e desse modelo em si. Para usar essas saídas em outras etapas de pipeline, prepare OutputFileDatasetConfig objetos 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'))
O trecho acima 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 ao particular type do TrainingOutput AutoMLStep. Como atribuímos pipeline_output_name a esses PipelineData objetos, seus valores estarão disponíveis não apenas na etapa individual do pipeline, mas no pipeline como um todo, como será discutido abaixo na seção "Examine os resultados do pipeline".
Configurar e criar a etapa de pipeline de ML automatizada
Uma vez definidas as entradas e saídas, é hora de criar o AutoMLConfig e AutoMLStep. Os detalhes da configuração dependerão da sua tarefa, conforme descrito em Configurar experimentos automatizados de ML em Python. Para a tarefa de classificação de sobrevivência do 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 uma expressão comumente usada com AutoMLConfig. Argumentos que são mais fluidos (hyperparameter-ish) são especificados em um dicionário separado, enquanto os valores menos prováveis de mudar são especificados diretamente no AutoMLConfig construtor. Neste caso, especifique automl_settings uma breve execução: a execução será interrompida após apenas 2 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:
taskestá definido comoclassificationpara este exemplo. Outros valores válidos sãoregressioneforecastingpathedebug_logdescrever o caminho para o projeto e um arquivo local no qual as informações de depuração serão gravadascompute_targeté o definidocompute_targetanteriormente que, neste exemplo, é uma máquina baseada em CPU barata. Se você estiver usando os recursos de Deep Learning do AutoML, convém alterar o destino de computação para ser baseado em GPUfeaturizationestá definido comoauto. Mais detalhes podem ser encontrados na seção Data Featurization do documento de configuração automatizada de MLlabel_column_nameindica qual coluna estamos interessados em prevertraining_dataé definido para osOutputTabularDatasetConfigobjetos feitos a partir das saídas da etapa de preparação de dados
O AutoMLStep próprio toma o AutoMLConfig e tem, como saídas, os objetos criados para armazenar as métricas e os dados do PipelineData modelo.
Importante
Você deve definir enable_default_model_output e enable_default_metrics_output para True somente se estiver usando AutoMLStepRuno .
Neste exemplo, o processo de ML automatizado executará validações cruzadas no training_data. Você pode controlar o número de validações cruzadas com o n_cross_validations argumento. Se você já tiver dividido seus dados de treinamento como parte das etapas de preparação de dados, poderá definir validation_data como seu próprio Dataset.
Ocasionalmente, você pode ver o uso X para recursos de dados e y para rótulos de dados. Esta técnica foi preterida e você deve usar training_data para entrada.
Registrar o modelo gerado pelo ML automatizado
A última etapa em um pipeline de ML simples é registrar o modelo criado. Ao adicionar o modelo ao registro de modelo do espaço de trabalho, ele estará disponível no portal e poderá ser versionado. Para registrar o modelo, escreva outro PythonScriptStep que pegue a model_data saída do AutoMLStep.
Escreva o código para registrar o modelo
Um modelo é registrado em um Workspacearquivo . Você provavelmente está familiarizado com o uso Workspace.from_config() para fazer logon em seu espaço de trabalho em sua máquina local, mas há outra maneira de obter o espaço de trabalho de dentro de um pipeline de ML em execução. O Run.get_context() recupera o ativo Run. Este run objeto fornece acesso a muitos objetos importantes, incluindo os Workspace usados 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))
Escreva o código PythonScriptStep
Aviso
Se estiver a utilizar o SDK do Azure Machine Learning v1 e a sua área de trabalho estiver configurada para isolamento de rede (VNet), poderá receber um erro ao executar este passo. Para obter mais informações, consulte HyperdriveStep e AutoMLStep falham com isolamento de rede.
O registro PythonScriptStep de modelo 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 execução. Uma vez declarados, 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)
Crie e execute seu pipeline de ML automatizado
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()
O código acima combina as etapas de preparação de dados, ML automatizado e registro de modelo em um Pipeline objeto. Em seguida, cria um Experiment objeto. O Experiment construtor recuperará o experimento nomeado se ele existir ou criá-lo, se necessário. Ele envia o Pipeline para o Experiment, criando um Run objeto que executará o pipeline de forma assíncrona. A wait_for_completion() função bloqueia até que a execução seja concluída.
Examinar os resultados do pipeline
Após a run conclusão, você pode recuperar PipelineData objetos que foram atribuídos a um pipeline_output_namearquivo . Você pode baixar os resultados e carregá-los para processamento posterior.
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 Pandas para exame.
Para processamento local, talvez seja necessário instalar pacotes relevantes, como Pandas, Pickle, o SDK do Azure Machine Learning e assim por diante. Para este exemplo, é provável que o melhor modelo encontrado pelo ML 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
O trecho de código acima mostra o arquivo de métricas que está sendo carregado de seu local no armazenamento de dados do Azure. Você também pode carregá-lo a partir do arquivo baixado, como mostrado no comentário. Depois de desserializá-lo e convertê-lo em um Pandas DataFrame, você pode ver métricas detalhadas para cada uma das iterações da etapa de ML automatizada.
O arquivo de modelo pode ser desserializado em um Model objeto 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 Usar um modelo existente com o Azure Machine Learning.
Baixe os resultados de uma execução automatizada de ML
Se você estiver acompanhando o artigo, terá um objeto instanciado run . Mas você também pode recuperar objetos concluídos Run do Workspace por meio de um Experiment objeto.
O espaço de trabalho contém um registro completo de todos os seus experimentos e execuções. Você pode usar o portal para encontrar e baixar os resultados de experimentos ou usar código. Para acessar os registros de uma execução histórica, use o Aprendizado de Máquina do Azure para localizar a ID da execução na qual você está interessado. Com esse ID, você pode escolher o específico run por meio do Workspace e 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ê teria que alterar as cadeias de caracteres no código acima para as especificidades de sua execução histórica. O trecho acima pressupõe que você atribuiu ws ao relevante Workspace com o normal from_config(). O experimento de interesse é recuperado diretamente e, em seguida, o código encontra o Run de interesse combinando o run.id valor.
Depois de ter um Run objeto, 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 Run objeto contém StepRun objetos que contêm informações sobre a execução da etapa de pipeline individual. O run é pesquisado para o StepRun objeto 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 PipelineData objetos para o outputs parâmetro do AutoMLStep.
Finalmente, as métricas e o modelo reais são baixados para sua máquina local, como foi discutido na seção "Examinar resultados do pipeline" acima.
Passos Seguintes
- Execute este bloco de anotações Jupyter mostrando um exemplo completo de ML automatizado em um pipeline que usa regressão para prever tarifas de táxi
- Crie experimentos automatizados de ML sem escrever código
- Explore uma variedade de notebooks Jupyter demonstrando ML automatizado
- Leia sobre a integração de seu pipeline em MLOps de ponta a ponta ou investigue o repositório GitHub MLOps