Usare ML automatizzato nella pipeline di Azure Machine Learning in Python
Si applica a: 
Python SDK azureml v1
La funzionalità automatizzata di Machine Learning di Azure Machine Learning consente di individuare modelli ad alte prestazioni senza dover ripetere ogni possibile approccio. In combinazione con le pipeline di Azure Machine Learning, è possibile creare flussi di lavoro distribuibili in grado di individuare rapidamente l'algoritmo più adatto ai dati. Questo articolo illustra come unire in modo efficiente un passaggio di preparazione dei dati a un passaggio di Machine Learning automatizzato. Machine Learning automatizzato consente di individuare rapidamente l'algoritmo più adatto ai dati, mentre è possibile passare a MLOps e all'operazionalizzazione del ciclo di vita del modello con le pipeline.
Prerequisiti
Una sottoscrizione di Azure. Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning.
Un'area di lavoro di Azure Machine Learning. Consultare Creare le risorse dell'area di lavoro.
Familiarità con Machine Learning automatizzato e strutture di pipeline di Machine Learning e SDK.
Esaminare le classi centrali di Machine Learning automatizzato
Machine Learning automatizzato in una pipeline è rappresentato da un oggetto AutoMLStep. La classe AutoMLStep è una sottoclasse di PipelineStep. Un grafo di oggetti PipelineStep definisce un Pipeline.
Sono presenti diverse sottoclassi di PipelineStep. Oltre a AutoMLStep, questo articolo mostrerà un PythonScriptStep per la preparazione dei dati e un altro per la registrazione del modello.
Il modo preferito per spostare inizialmente i dati in una pipeline di Machine Learning è con oggetti Dataset. Per spostare i dati tra i passaggi e il possibile salvataggio dell'output dei dati dalle esecuzioni, il modo migliore è usare gli oggetti OutputFileDatasetConfig e OutputTabularDatasetConfig. Per essere utilizzato con AutoMLStep, l'oggetto PipelineData deve essere trasformato in un oggetto PipelineOutputTabularDataset. Per altre informazioni, vedere Dati di input e output dalle pipeline di Machine Learning.
Il AutoMLStep viene configurato tramite un oggetto AutoMLConfig. AutoMLConfig è una classe flessibile, come illustrato in Configurare esperimenti di Machine Learning automatizzati in Python.
Un Pipeline viene eseguito in un Experiment. Il Run della pipeline include, per ogni passaggio, un StepRun figlio. Gli output del StepRun di Machine Learning automatizzato sono le metriche di training e il modello con le prestazioni più elevate.
Per rendere concrete le operazioni, questo articolo crea una pipeline semplice per un'attività di classificazione. L'attività prevede la sopravvivenza del Titanic, ma non esamineremo i dati o l'attività tranne che nel passaggio.
Operazioni preliminari
Recuperare il set di dati iniziale
Spesso, un flusso di lavoro di Machine Learning inizia con i dati di base preesistenti. Si tratta di uno scenario valido per un set di dati registrato. I set di dati sono visibili nell'area di lavoro, supportano il controllo delle versioni e possono essere esplorati in modo interattivo. Esistono molti modi per creare e popolare un set di dati, come illustrato in Creare set di dati di Azure Machine Learning. Dal momento che si userà Python SDK per creare la pipeline, usare l'SDK per scaricare i dati di base e registrarlo con il 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')
Il codice esegue prima l'accesso all'area di lavoro di Azure Machine Learning definita in config.json (per una spiegazione, vedere Creare un file di configurazione dell'area di lavoro). Se non è già presente un set di dati denominato 'titanic_ds' registrato, ne crea uno. Il codice scarica i dati CSV dal Web, li usa per creare un'istanza di un TabularDataset e quindi registra il set di dati nell'area di lavoro. Infine, la funzione Dataset.get_by_name() assegna il Dataset a titanic_ds.
Configurare la risorsa di archiviazione e la destinazione di calcolo
Le risorse aggiuntive necessarie per la pipeline sono l'archiviazione e, in genere, le risorse di calcolo di 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]
I dati intermedi tra la preparazione dei dati e il passaggio di Machine Learning automatizzato possono essere archiviati nell'archivio dati predefinito dell'area di lavoro, quindi basterà chiamare get_default_datastore() sull'oggetto Workspace.
Successivamente, il codice controlla se la destinazione di calcolo di Azure Machine Learning 'cpu-cluster' esiste già. In caso contrario, si specifica di volere una piccola destinazione di calcolo basata sulla CPU. Se si prevede di usare le funzionalità di Deep Learning del Machine Learning automatizzato (ad esempio, la definizione delle funzionalità di testo con supporto DNN) è consigliabile scegliere un ambiente di calcolo con supporto GPU avanzato, come descritto in dimensioni delle macchine virtuali ottimizzate per la GPU.
Il codice si blocca fino a quando non viene effettuato il provisioning della destinazione e quindi stampa alcuni dettagli della destinazione di calcolo appena creata. Infine, la destinazione di calcolo denominata viene recuperata dall'area di lavoro e assegnata a compute_target.
Configurare l'esecuzione del training
Il contesto di runtime viene impostato creando e configurando un oggetto RunConfiguration. Qui viene impostata la destinazione di calcolo.
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'])
Preparare i dati per il Machine Learning automatizzato
Scrivere il codice di preparazione dei dati
Il set di dati Titanic di base è costituito da dati numerici e di testo misti, con alcuni valori mancanti. Per prepararlo per il Machine Learning automatizzato, il passaggio della pipeline di preparazione dei dati dovrà:
- Compilare i dati mancanti con dati casuali o una categoria corrispondente a "Sconosciuto"
- Trasformare i dati categorici in numeri interi
- Eliminare colonne che non si intende usare
- Suddividere i dati in set di training e test
- Scrivere i dati trasformati nei percorsi di output
OutputFileDatasetConfig
%%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")
Il frammento di codice precedente è un esempio completo, ma minimo, di preparazione dei dati per i dati Titanic. Il frammento di codice inizia con un "comando magic" di Jupyter per restituire il codice in un file. Se non si usa un notebook di Jupyter, rimuovere tale riga e creare il file manualmente.
Le varie funzioni prepare_ nel frammento di codice precedente modificano la colonna pertinente nel set di dati di input. Queste funzioni operano sui dati dopo che sono state modificate in un oggetto Pandas DataFrame. In ogni caso, i dati mancanti vengono compilati con dati casuali rappresentativi o dati categorici che indicano "Sconosciuto". I dati categorici basati su testo vengono mappati a numeri interi. Le colonne non più necessarie vengono sovrascritte o eliminate.
Dopo che il codice definisce le funzioni di preparazione dei dati, analizza l'argomento di input, ovvero il percorso in cui si vogliono scrivere i dati. (Questi valori verranno determinati da OutputFileDatasetConfig oggetti che verranno discussi nel passaggio successivo.) Il codice recupera il 'titanic_cs' Dataset registrato, lo converte in un DataFrame Pandas e chiama le varie funzioni di preparazione dei dati.
Poiché il output_path è una directory, la chiamata a to_csv() specifica il nome file prepped_data.csv.
Scrivere il passaggio della pipeline di preparazione dei dati (PythonScriptStep)
Il codice di preparazione dei dati descritto in precedenza deve essere associato a un oggetto PythonScripStep da usare con una pipeline. Il percorso in cui viene scritto l'output CSV viene generato da un oggetto OutputFileDatasetConfig. Le risorse preparate in precedenza, ad esempio il ComputeTarget, il RunConfig e il 'titanic_ds' Dataset vengono usate per completare la specifica.
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
)
L'oggetto prepped_data_path è di tipo OutputFileDatasetConfig che punta a una directory. Si noti che è specificato nel parametro arguments. Se si esamina il passaggio precedente, si noterà che all'interno del codice di preparazione dei dati il valore dell'argomento '--output_path' è il percorso della directory in cui è stato scritto il file CSV.
Eseguire il training con AutoMLStep
La configurazione di un passaggio della pipeline di Machine Learning automatizzato viene eseguita con la classe AutoMLConfig. Questa classe flessibile è descritta in Configurare esperimenti di Machine Learning automatizzati in Python. L'input e l'output dei dati sono gli unici aspetti della configurazione che richiedono particolare attenzione in una pipeline di Machine Learning. L'input e l'output per AutoMLConfig nelle pipeline sono descritti in dettaglio di seguito. Oltre ai dati, un vantaggio delle pipeline di Machine Learning è la possibilità di usare destinazioni di calcolo diverse per diversi passaggi. È possibile scegliere di usare un ComputeTarget più potente solo per il processo di Machine Learning automatizzato. In questo modo è semplice assegnare un RunConfiguration più potente al parametro run_configuration dell'oggetto AutoMLConfig.
Inviare dati a AutoMLStep
In una pipeline di Machine Learning i dati di input devono essere un oggetto Dataset. Il modo più efficiente consiste nel fornire i dati di input sotto forma di oggetti OutputTabularDatasetConfig. Si crea un oggetto di tale tipo con il read_delimited_files() in un OutputFileDatasetConfig, ad esempio prepped_data_path o l'oggetto prepped_data_path.
# type(prepped_data) == OutputTabularDatasetConfig
prepped_data = prepped_data_path.read_delimited_files()
Un'altra opzione consiste nell'usare Dataset oggetti registrati nell'area di lavoro:
prepped_data = Dataset.get_by_name(ws, 'Data_prepared')
Confronto tra le due tecniche:
| Tecnica | Vantaggi e svantaggi |
|---|---|
OutputTabularDatasetConfig |
Prestazioni più elevate |
Route naturale da OutputFileDatasetConfig |
|
| I dati non vengono salvati in modo permanente dopo l'esecuzione della pipeline | |
Dataset registrato |
Prestazioni inferiori |
| Può essere generato in molti modi | |
| I dati vengono mantenuti e sono visibili in tutta l'area di lavoro | |
Notebook che mostra la tecnica Dataset registrata |
Specificare output di Machine Learning automatizzato
Gli output della AutoMLStep sono i punteggi finali delle metriche del modello con prestazioni superiori e del modello stesso. Per usare questi output in altri passaggi della pipeline, preparare OutputFileDatasetConfig oggetti per riceverli.
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'))
Il frammento di codice precedente crea i due oggetti PipelineData per le metriche e l'output del modello. Ogni oggetto viene denominato, assegnato all'archivio dati predefinito recuperato in precedenza e associato al particolare type di TrainingOutput dal AutoMLStep. Poiché si assegnano pipeline_output_name su questi oggetti PipelineData, i relativi valori non saranno disponibili solo dal singolo passaggio della pipeline, ma dalla pipeline nel suo complesso, come illustrato di seguito nella sezione "Esaminare i risultati della pipeline".
Configurare e creare il passaggio della pipeline di Machine Learning automatizzato
Dopo aver definito gli input e gli output, è possibile creare il AutoMLConfig e AutoMLStep. I dettagli della configurazione dipendono dall'attività, come descritto in Configurare esperimenti di Machine Learning automatizzato in Python. Per l'attività di classificazione di sopravvivenza Titanic, il frammento di codice seguente illustra una configurazione semplice.
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)
Il frammento di codice mostra un linguaggio comunemente usato con AutoMLConfig. Gli argomenti più fluidi (iperparametri-ish) vengono specificati in un dizionario separato, mentre i valori con minore probabilità di modifica vengono specificati direttamente nel costruttore AutoMLConfig. In questo caso, il automl_settings specifica una breve esecuzione: l'esecuzione verrà interrotta dopo solo 2 iterazioni o 15 minuti, a seconda del primo.
Il dizionario automl_settings viene passato al costruttore AutoMLConfig come kwargs. Gli altri parametri non sono complessi:
taskè impostato suclassificationper questo esempio. Altri valori validi sonoregressioneforecasting.pathedebug_logdescrivono il percorso del progetto e un file locale in cui verranno scritte le informazioni di debugcompute_targetè ilcompute_targetdefinito in precedenza che, in questo esempio, è un computer economico basato sulla CPU. Se si usano le funzionalità di Deep Learning di AutoML, si vorrà modificare la destinazione di calcolo in modo che sia basata su GPUfeaturizationè impostato suauto. Per altri dettagli, vedere la sezione Definizione delle funzionalità dei dati del documento di configurazione di Machine Learning automatizzatolabel_column_nameindica quale colonna si è interessati a prevederetraining_dataè impostato suOutputTabularDatasetConfigoggetti creati dagli output del passaggio di preparazione dei dati
Il AutoMLStep stesso accetta il AutoMLConfig e include, come output, PipelineData oggetti creati per contenere le metriche e i dati del modello.
Importante
È necessario impostare enable_default_model_output e enable_default_metrics_output su True solo se si usa AutoMLStepRun.
In questo esempio, il processo di Machine Learning automatizzato eseguirà convalide incrociate nel training_data. È possibile controllare il numero di convalide incrociate con l'argomento n_cross_validations. Se i dati di training sono già stati suddivisi come parte dei passaggi di preparazione dei dati, è possibile impostare validation_data sul proprio Dataset.
È possibile che occasionalmente vengano utilizzati X per le funzionalità dei dati e y per le etichette dati. Questa tecnica è deprecata ed è consigliabile usare training_data per l'input.
Registrare il modello generato da Machine Learning automatizzato
L'ultimo passaggio di una pipeline di Machine Learning semplice consiste nel registrare il modello creato. Aggiungendo il modello al registro dei modelli dell'area di lavoro, sarà disponibile nel portale e può essere sottoposto a controllo delle versioni. Per registrare il modello, scrivere un altro PythonScriptStep che accetta l'output model_data del AutoMLStep.
Scrivere il codice per registrare il modello
Viene registrato un modello in un Workspace. Probabilmente si ha familiarità con l'uso di Workspace.from_config() per accedere all'area di lavoro nel computer locale, ma esiste un altro modo per ottenere l'area di lavoro dall'interno di una pipeline di Machine Learning in esecuzione. Il Run.get_context() recupera il Run attivo. Questo oggetto run fornisce l'accesso a molti oggetti importanti, inclusi i Workspace usati qui.
%%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))
Scrivere il codice PythonScriptStep
Avviso
Se si usa Azure Machine Learning SDK v1 e l'area di lavoro è configurata per l'isolamento rete (VNet), è possibile che venga visualizzato un errore durante l'esecuzione di questo passaggio. Per altre informazioni, vedere HyperdriveStep e AutoMLStep hanno esito negativo con l'isolamento rete.
La registrazione del modello PythonScriptStep usa un PipelineParameter per uno dei relativi argomenti. I parametri della pipeline sono argomenti per le pipeline che possono essere facilmente impostate in fase di esecuzione-invio. Una volta dichiarati, vengono passati come argomenti normali.
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)
Creare ed eseguire la pipeline di Machine Learning automatizzato
La creazione e l'esecuzione di una pipeline che contiene un AutoMLStep non è diversa da una pipeline normale.
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()
Il codice precedente combina la preparazione dei dati, il Machine Learning automatizzato e i passaggi di registrazione del modello in un oggetto Pipeline. Crea quindi un oggetto Experiment. Il costruttore Experiment recupererà l'esperimento denominato, se presente o lo creerà, se necessario. Invia il Pipeline a Experiment, creando un oggetto Run che eseguirà in modo asincrono la pipeline. La funzione wait_for_completion() si blocca fino al completamento dell'esecuzione.
Esaminare i risultati della pipeline
Al termine di run, è possibile recuperare PipelineData oggetti a cui è stato assegnato un pipeline_output_name. È possibile scaricare i risultati e caricarli per un'ulteriore elaborazione.
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)
I file scaricati vengono scritti nella sottodirectory azureml/{run.id}/. Il file delle metriche è in formato JSON e può essere convertito in un dataframe Pandas per l'esame.
Per l'elaborazione locale, potrebbe essere necessario installare pacchetti pertinenti, ad esempio Pandas, Pickle, Azure Machine Learning SDK e così via. Per questo esempio, è probabile che il modello migliore trovato da Machine Learning automatizzato dipenderà da 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
Il frammento di codice precedente mostra il file delle metriche caricato dalla relativa posizione nell'archivio dati di Azure. È anche possibile caricarlo dal file scaricato, come illustrato nel commento. Dopo averlo deserializzato e convertito in un DataFrame Pandas, è possibile visualizzare metriche dettagliate per ognuna delle iterazioni del passaggio di Machine Learning automatizzato.
Il file del modello può essere deserializzato in un oggetto Model che è possibile usare per l'inferenza, un'ulteriore analisi delle metriche e così via.
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 ...
Per altre informazioni sul caricamento e sull'uso dei modelli esistenti, vedere Usare un modello esistente con Azure Machine Learning.
Scaricare i risultati di un'esecuzione di Machine Learning automatizzato
Se si sta seguendo l'articolo, si creerà un'istanza run oggetto. Ma è anche possibile recuperare gli oggetti Run completati dal Workspace tramite un oggetto Experiment.
L'area di lavoro contiene un record completo di tutti gli esperimenti e le esecuzioni. È possibile usare il portale per trovare e scaricare gli output degli esperimenti o usare il codice. Per accedere ai record da un'esecuzione cronologica, usare Azure Machine Learning per trovare l'ID dell'esecuzione a cui si è interessati. Con tale ID, è possibile scegliere il run specifico tramite 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)
È necessario modificare le stringhe nel codice precedente in base alle specifiche dell'esecuzione cronologica. Il frammento di codice precedente presuppone che sia stato assegnato ws al Workspace pertinente con il normale from_config(). L'esperimento di interesse viene recuperato direttamente e quindi il codice trova il Run di interesse associando il valore run.id.
Dopo aver creato un oggetto Run, è possibile scaricare le metriche e il modello.
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('.')
Ogni oggetto Run contiene StepRun oggetti che contengono informazioni sull'esecuzione del singolo passaggio della pipeline. Il run viene cercato per l'oggetto StepRun per AutoMLStep. Le metriche e il modello vengono recuperati usando i relativi nomi predefiniti, disponibili anche se non si passano oggetti PipelineData al parametro outputs del AutoMLStep.
Infine, le metriche e il modello effettivi vengono scaricati nel computer locale, come illustrato nella sezione "Esaminare i risultati della pipeline" precedente.
Passaggi successivi
- Eseguire questo notebook di Jupyter che mostra un esempio completo di Machine Learning automatizzato in una pipeline che usa la regressione per stimare le tariffe dei taxi
- Creare esperimenti di Machine Learning automatizzato senza scrivere codice
- Esplorare un'ampia gamma di notebook di Jupyter che illustrano il Machine Learning automatizzato
- Leggere le informazioni sull'integrazione della pipeline in MLOps end-to-end o analizzare il repository GitHub MLOps