Sdílet prostřednictvím

Použití automatizovaného strojového učení v kanálu Azure Machine Learning v Pythonu

  • Článek

PLATÍ PRO: Python SDK azureml v1

Funkce automatizovaného strojového učení ve službě Azure Machine Learning pomáhá zjišťovat vysoce výkonné modely, aniž byste museli znovu vytvářet všechny možné přístupy. V kombinaci s kanály Azure Machine Learning můžete vytvářet nasaditelné pracovní postupy, které rychle zjistí algoritmus, který je pro vaše data nejvhodnější. V tomto článku se dozvíte, jak efektivně spojit krok přípravy dat s automatizovaným krokem ML. Automatizované strojové učení dokáže rychle zjistit algoritmus, který je pro vaše data nejvhodnější, a zároveň vás umístí na cestu k MLOps a zprovoznění životního cyklu modelu s kanály.

Požadavky

Kontrola centrálních tříd automatizovaného strojového učení

Automatizované strojové učení v kanálu je reprezentováno objektem AutoMLStep . Třída AutoMLStep je podtřídou třídy PipelineStep. Graf PipelineStep objektů definuje .Pipeline

Existuje několik podtříd .PipelineStep Kromě tohoto AutoMLStepčlánku se zobrazí PythonScriptStep také příprava dat a další pro registraci modelu.

Upřednostňovaným způsobem, jak nejprve přesunout data do kanálu ML, je s Dataset objekty. Pokud chcete přesouvat data mezi kroky a možným uložením výstupu dat ze spuštění, je upřednostňovaným způsobem s OutputFileDatasetConfig objekty a OutputTabularDatasetConfig objekty. Chcete-li objekt použít AutoMLSteps objektem, PipelineData musí být transformován na PipelineOutputTabularDataset objekt. Další informace najdete v tématu Vstupní a výstupní data z kanálů ML.

Konfiguruje se AutoMLStep prostřednictvím objektu AutoMLConfig . AutoMLConfig je flexibilní třída, jak je popsáno v tématu Konfigurace experimentů automatizovaného strojového učení v Pythonu.

A Pipeline běží v objektu Experiment. Run Kanál má pro každý krok podřízený StepRunkanál . Výstupy automatizovaného strojového učení StepRun jsou trénovací metriky a nejvýkonnější model.

Aby bylo všechno konkrétní, tento článek vytvoří jednoduchý kanál pro úlohu klasifikace. Úkol předpovídá přežití Titanicu, ale nebudeme diskutovat o datech nebo úkolu s výjimkou předávání.

Začínáme

Načtení počáteční datové sady

Pracovní postup ML často začíná před existujícími daty směrného plánu. Toto je vhodný scénář pro registrovanou datovou sadu. Datové sady jsou viditelné v celém pracovním prostoru, podporují správu verzí a dají se interaktivně prozkoumat. Existuje mnoho způsobů, jak vytvořit a naplnit datovou sadu, jak je popsáno v tématu Vytváření datových sad Azure Machine Learning. Vzhledem k tomu, že k vytvoření kanálu použijeme sadu Python SDK, pomocí sady SDK stáhněte základní data a zaregistrujte je s názvem "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')

Kód se nejprve přihlásí k pracovnímu prostoru Azure Machine Learning definovanému v config.json (vysvětlení najdete v tématu Vytvoření konfiguračního souboru pracovního prostoru. Pokud ještě není datová sada s názvem 'titanic_ds' zaregistrovaná, vytvoří ji. Kód stáhne data CSV z webu, použije je k vytvoření instance TabularDataset a pak zaregistruje datovou sadu v pracovním prostoru. Nakonec funkce Dataset.get_by_name() přiřadí Dataset funkci titanic_ds.

Konfigurace úložiště a cílového výpočetního objektu

Další prostředky, které kanál bude potřebovat, jsou úložiště a obecně výpočetní prostředky služby 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]

Průběžná data mezi přípravou dat a krokem automatizovaného strojového učení se dají uložit do výchozího úložiště dat pracovního prostoru, takže nemusíme provádět více než volání get_default_datastore() objektu Workspace .

Potom kód zkontroluje, jestli už cílový výpočetní objekt 'cpu-cluster' služby Azure Machine Learning existuje. Pokud ne, určíme, že chceme malý cílový výpočetní objekt založený na procesoru. Pokud plánujete používat funkce hloubkového učení automatizovaného strojového učení (například funkci funkce textu s podporou DNN), měli byste zvolit výpočetní prostředky se silnou podporou GPU, jak je popsáno ve velikostech virtuálních počítačů optimalizovaných pro GPU.

Kód blokuje, dokud se cíl nezřídí, a pak vytiskne některé podrobnosti o právě vytvořeném cílovém výpočetním objektu. Nakonec se pojmenovaný cílový výpočetní objekt načte z pracovního prostoru a přiřadí se mu compute_target.

Konfigurace trénovacího spuštění

Kontext modulu runtime je nastavený vytvořením a konfigurací objektu RunConfiguration . Tady nastavíme cílový výpočetní objekt.

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'])

Příprava dat pro automatizované strojové učení

Zápis kódu pro přípravu dat

Základní datová sada Titanic se skládá ze smíšených číselných a textových dat s některými chybějícími hodnotami. Pokud ho chcete připravit na automatizované strojové učení, krok kanálu přípravy dat:

  • Vyplnění chybějících dat náhodnými daty nebo kategorií odpovídající neznámé
  • Transformace kategorických dat na celá čísla
  • Vyřazení sloupců, které nemáme v úmyslu použít
  • Rozdělení dat do trénovacích a testovacích sad
  • Zápis transformovaných dat do OutputFileDatasetConfig výstupních cest
%%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")

Výše uvedený fragment kódu je úplný, ale minimální příklad přípravy dat pro data Titanic. Fragment kódu začíná příkazem "magic" Jupyter pro výstup kódu do souboru. Pokud nepoužíváte poznámkový blok Jupyter, odeberte tento řádek a vytvořte ho ručně.

Různé prepare_ funkce ve výše uvedeném fragmentu kódu upravují příslušný sloupec ve vstupní datové sadě. Tyto funkce pracují s daty po změně na objekt Pandas DataFrame . V každém případě chybějící data jsou buď vyplněná reprezentativními náhodnými daty, nebo kategorickými daty označujícími "Neznámé". Textová kategorická data se mapují na celá čísla. Sloupce, které už nepotřebujete, se přepíšou nebo zahodí.

Jakmile kód definuje funkce pro přípravu dat, kód parsuje vstupní argument, což je cesta, ke které chceme zapsat data. (Tyto hodnoty budou určeny OutputFileDatasetConfig objekty, které budou popsány v dalším kroku.) Kód načte zaregistrovaný 'titanic_cs' Datasetkód , převede ho na Pandas DataFramea volá různé funkce pro přípravu dat.

Vzhledem k tomu, že je adresář output_path , volání určuje to_csv() název souboru prepped_data.csv.

Zápis kroku kanálu přípravy dat (PythonScriptStep)

Výše popsaný kód přípravy dat musí být přidružený k objektu PythonScripStep , který se má použít s kanálem. Cesta, ke které se zapisuje výstup CSV, je generována objektem OutputFileDatasetConfig . Prostředky připravené dříve, například ComputeTarget, a RunConfigjsou 'titanic_ds' Dataset použity k dokončení specifikace.

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
)

Objekt prepped_data_path je typu OutputFileDatasetConfig , který odkazuje na adresář. Všimněte si, že je zadaný v parametru arguments . Pokud si projdete předchozí krok, uvidíte, že v kódu pro přípravu dat je hodnota argumentu '--output_path' cesta k adresáři, na kterou byl soubor CSV zapsán.

Trénovat pomocí nástroje AutoMLStep

Konfigurace kroku automatizovaného kanálu ML se provádí s AutoMLConfig třídou. Tato flexibilní třída je popsaná v tématu Konfigurace experimentů automatizovaného strojového učení v Pythonu. Vstup a výstup dat jsou jedinými aspekty konfigurace, které vyžadují zvláštní pozornost v kanálu ML. Vstup a výstup pro AutoMLConfig kanály je podrobně popsán níže. Kromě dat je výhodou kanálů ML možnost používat různé výpočetní cíle pro různé kroky. Pro automatizovaný proces STROJOVÉho učení můžete použít výkonnější ComputeTarget . To je stejně jednoduché jako přiřazení výkonnějšího RunConfiguration parametru AutoMLConfig objektu run_configuration .

Odeslání dat do AutoMLStep

V kanálu ML musí být vstupní data objektem Dataset . Nejvýkonnější způsob je poskytnout vstupní data ve formě OutputTabularDatasetConfig objektů. Objekt tohoto typu vytvoříte pomocí objektu read_delimited_files() na objektu OutputFileDatasetConfig, jako prepped_data_pathje například prepped_data_path objekt.

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

Další možností je použít Dataset objekty zaregistrované v pracovním prostoru:

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

Porovnání těchto dvou technik:

Postup Výhody a nevýhody
OutputTabularDatasetConfig Vyšší výkon
Přirozená trasa z OutputFileDatasetConfig
Data se po spuštění kanálu neuchovávají
Registrovaný Dataset Nižší výkon
Lze vygenerovat mnoha způsoby.
Data se uchovávají a jsou viditelná v celém pracovním prostoru.
Poznámkový blok znázorňující zaregistrovanou Dataset techniku

Určení automatizovaných výstupů ML

Výstupy AutoMLStep jsou konečné skóre metriky vyššího modelu a samotného modelu. Pokud chcete tyto výstupy použít v dalších krocích kanálu, připravte OutputFileDatasetConfig objekty na jejich příjem.

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'))

Výše uvedený fragment kódu vytvoří dva PipelineData objekty pro metriky a výstup modelu. Každý se jmenuje, přiřazený k výchozímu úložišti dat načteným dříve a je přidružen ke konkrétnímu type z TrainingOutput objektu AutoMLStep. Vzhledem k tomu, že tyto PipelineData objekty přiřadímepipeline_output_name, budou jejich hodnoty k dispozici nejen z jednotlivých kroků kanálu, ale z kanálu jako celku, jak je popsáno níže v části Prozkoumání výsledků kanálu.

Konfigurace a vytvoření kroku automatizovaného kanálu ML

Jakmile jsou definovány vstupy a výstupy, je čas vytvořit AutoMLConfig a AutoMLStep. Podrobnosti o konfiguraci budou záviset na vaší úloze, jak je popsáno v tématu Konfigurace experimentů automatizovaného strojového učení v Pythonu. Pro úlohu klasifikace přežití Titanic ukazuje následující fragment kódu jednoduchou konfiguraci.

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)

Fragment kódu ukazuje idiom běžně používaný s AutoMLConfig. Argumenty, které jsou více tekutin (hyperparametry-ish), jsou zadány v samostatném slovníku, zatímco hodnoty s menší pravděpodobností změny se zadají přímo v konstruktoru AutoMLConfig . V tomto případě automl_settings zadejte krátké spuštění: spuštění se zastaví pouze po 2 iteraci nebo 15 minutách, podle toho, co nastane dříve.

Slovník automl_settings se předá konstruktoru AutoMLConfig jako kwargs. Ostatní parametry nejsou složité:

  • task je pro tento příklad nastaven classification . Další platné hodnoty jsou regression a forecasting
  • path a debug_log popište cestu k projektu a místnímu souboru, do kterého se zapíšou informace o ladění.
  • compute_target je dříve definovaná compute_target , že v tomto příkladu je levný počítač založený na procesoru. Pokud používáte možnosti hlubokého učení AutoML, měli byste změnit cílový výpočetní objekt tak, aby byl založený na GPU.
  • featurization je nastavena na autohodnotu . Další podrobnosti najdete v části Featurizace dat v dokumentu o konfiguraci automatizovaného strojového učení.
  • label_column_name určuje, který sloupec nás zajímá o predikci.
  • training_data je nastaven na OutputTabularDatasetConfig objekty vytvořené z výstupů kroku přípravy dat.

Sám AutoMLStep přebírá AutoMLConfig objekty PipelineData vytvořené k uchovávání metrik a dat modelu a jako výstupy.

Důležité

Musíte nastavit enable_default_model_output a enable_default_metrics_output pouze True pokud používáte AutoMLStepRun.

V tomto příkladu proces automatizovaného strojového učení provede křížové ověření v systému training_data. Počet křížových ověření můžete řídit pomocí argumentu n_cross_validations . Pokud jste už trénovací data rozdělili v rámci kroků přípravy dat, můžete nastavit validation_data vlastní Dataset.

Někdy se může zobrazit použití X datových funkcí a y popisků dat. Tato technika je zastaralá a měli byste ji použít training_data pro vstup.

Registrace modelu generovaného automatizovaným strojovém učením

Posledním krokem v jednoduchém kanálu ML je registrace vytvořeného modelu. Přidáním modelu do registru modelů pracovního prostoru bude dostupný na portálu a může být verze. Pokud chcete zaregistrovat model, napište jiný PythonScriptStep , který přebírá model_data výstup AutoMLStep.

Napsání kódu pro registraci modelu

Model je registrován v .Workspace Pravděpodobně znáte použití Workspace.from_config() k přihlášení k pracovnímu prostoru na místním počítači, ale existuje jiný způsob, jak získat pracovní prostor ze spuštěného kanálu ML. Načte Run.get_context() aktivní Run. Tento run objekt poskytuje přístup k mnoha důležitým objektům, včetně Workspace zde použitých.

%%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))

Napsání kódu PythonScriptStep

Upozorňující

Pokud používáte sadu Azure Machine Learning SDK v1 a váš pracovní prostor je nakonfigurovaný pro izolaci sítě (VNet), může se při spuštění tohoto kroku zobrazit chyba. Další informace naleznete v tématu HyperdriveStep a AutoMLStep selhání s izolací sítě.

Registrace modelu PythonScriptStep používá PipelineParameter pro jeden z jeho argumentů. Parametry kanálu jsou argumenty kanálů, které je možné snadno nastavit v době odeslání za běhu. Jakmile se deklarují, předají se jako normální argumenty.


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)

Vytvoření a spuštění automatizovaného kanálu ML

Vytvoření a spuštění kanálu, který obsahuje AutoMLStep , se neliší od normálního kanálu.

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()

Výše uvedený kód kombinuje kroky přípravy dat, automatizovaného strojového učení a registrace modelu do objektu Pipeline . Potom vytvoří Experiment objekt. Konstruktor Experiment načte pojmenovaný experiment, pokud existuje, nebo ho v případě potřeby vytvoří. Odešle Pipeline do objektu Experiment, vytvoření Run objektu, který bude asynchronně spustit kanál. Funkce wait_for_completion() blokuje, dokud se nespustí.

Prozkoumání výsledků kanálu

run Po dokončení můžete načíst PipelineData objekty, které byly přiřazeny pipeline_output_name. Výsledky si můžete stáhnout a načíst je pro další zpracování.

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)

Stažené soubory se zapisují do podadresáře azureml/{run.id}/. Soubor metrik je formátovaný ve formátu JSON a lze ho převést na datový rámec Pandas ke zkoumání.

Pro místní zpracování možná budete muset nainstalovat relevantní balíčky, jako jsou Pandas, Pickle, sada Azure Machine Learning SDK atd. V tomto příkladu je pravděpodobné, že nejlepší model nalezený automatizovaným ml bude záviset na 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

Výše uvedený fragment kódu ukazuje soubor metrik, který se načítá z jeho umístění v úložišti dat Azure. Můžete ho také načíst ze staženého souboru, jak je znázorněno v komentáři. Jakmile ho deserializujete a převedete na datový rámec Pandas, můžete zobrazit podrobné metriky pro každou iteraci automatizovaného kroku ML.

Soubor modelu lze deserializovat do objektu Model , který můžete použít k odvozování, další analýze metrik atd.

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 ...

Další informace o načítání a práci s existujícími modely najdete v tématu Použití existujícího modelu se službou Azure Machine Learning.

Stažení výsledků automatizovaného spuštění ML

Pokud jste postupovali podle článku, budete mít objekt instance run . Dokončené Run objekty ale můžete načíst také z objektu Workspace Experiment .

Pracovní prostor obsahuje úplný záznam všech experimentů a spuštění. Pomocí portálu můžete vyhledat a stáhnout výstupy experimentů nebo použít kód. Pokud chcete získat přístup k záznamům z historického spuštění, pomocí služby Azure Machine Learning vyhledejte ID spuštění, které vás zajímá. Pomocí tohoto ID můžete zvolit konkrétní run způsob a Workspace 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)

Řetězce ve výše uvedeném kódu byste museli změnit na specifika historického spuštění. Výše uvedený fragment kódu předpokládá, že jste přiřadili ws příslušnému Workspace normálnímu from_config()kódu . Experiment zájmu se přímo načte a pak kód najde Run zájem tím, že se shoduje s run.id hodnotou.

Jakmile máte Run objekt, můžete si stáhnout metriky a model.

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('.')

Každý Run objekt obsahuje StepRun objekty, které obsahují informace o spuštění jednotlivých kroků kanálu. StepRun Vyhledá se run objekt pro AutoMLStepobjekt . Metriky a model se načítají pomocí výchozích názvů, které jsou k dispozici, i když nepředáte PipelineData objekty parametru outputs AutoMLStep.

Nakonec se skutečné metriky a model stáhnou do místního počítače, jak je popsáno v části Prozkoumat výsledky kanálu výše.

Další kroky