Megosztás a következőn keresztül:

Automatizált gépi tanulás használata egy Azure Machine Learning-folyamatban a Pythonban

  • Cikk

ÉRVÉNYES:Python SDK azureml v1

Az Azure Machine Learning automatizált gépi tanulási képessége segít felderíteni a nagy teljesítményű modelleket anélkül, hogy minden lehetséges megközelítést újra alkalmaz. Az Azure Machine Learning-folyamatokkal kombinálva üzembe helyezhető munkafolyamatokat hozhat létre, amelyek gyorsan felfedezhetik az adatokhoz legjobban illeszkedő algoritmust. Ez a cikk bemutatja, hogyan csatlakozhat hatékonyan egy adat-előkészítési lépéshez egy automatizált gépi tanulási lépéshez. Az automatizált gépi tanulás gyorsan felfedezheti az adatokhoz legjobban megfelelő algoritmust, miközben útban van az MLOps felé, és folyamatokkal modellezheti az életciklust.

Előfeltételek

Az automatizált gépi tanulás központi osztályainak áttekintése

A folyamat automatizált gépi tanulását egy AutoMLStep objektum jelöli. Az AutoMLStep osztály a következő alosztálya PipelineStep: . Az objektumok gráfja PipelineStep egy Pipeline.

Több alosztálya is van a következőnek PipelineStep: . A cikk amellett, hogy egy AutoMLStepadatelőkészítést és egy PythonScriptStep másikat is megjelenít a modell regisztrálásához.

Az adatok gépi tanulási folyamatba való áthelyezésének elsődleges módja az Dataset objektumok használata. Az adatok lépések közötti áthelyezéséhez és a futtatásokból származó adatkimenetek lehetséges mentéséhez az elsődleges módszer az objektumok és OutputTabularDatasetConfig az OutputFileDatasetConfig objektumok használata. A használatához AutoMLStepaz PipelineData objektumot objektummá kell alakítani PipelineOutputTabularDataset . További információ: Bemeneti és kimeneti adatok az ML-folyamatokból.

Ez AutoMLStep egy AutoMLConfig objektumon keresztül van konfigurálva. AutoMLConfig egy rugalmas osztály, amelyet az automatizált gépi tanulási kísérletek Pythonban való konfigurálása című témakör tartalmaz.

Futtatás Pipeline egy Experiment. A folyamat Run minden lépéshez rendelkezik egy gyermekvel StepRun. Az automatizált gépi tanulás StepRun kimenetei a betanítási metrikák és a legmagasabb teljesítményű modell.

A konkrét dolgok érdekében ez a cikk egy egyszerű folyamatot hoz létre egy besorolási feladathoz. A feladat a Titanic túlélését jósolja, de az adatokról vagy a feladatról csak a továbbításról lesz szó.

Első lépések

Kezdeti adatkészlet lekérése

Az ml-munkafolyamatok gyakran már meglévő alapadatokkal kezdődnek. Ez egy jó forgatókönyv egy regisztrált adatkészlethez. Az adathalmazok a munkaterületen láthatók, támogatják a verziószámozást, és interaktívan feltárhatók. Az adathalmazok létrehozásának és feltöltésének számos módja van, ahogy az Azure Machine Learning-adathalmazok létrehozása című cikk is ismerteti. Mivel a Python SDK-t fogjuk használni a folyamat létrehozásához, az SDK-val töltse le az alapadatokat, és regisztrálja azokat "titanic_ds" néven.

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

A kód először a config.json definiált Azure Machine Learning-munkaterületre jelentkezik be (ennek magyarázatát lásd: Munkaterület konfigurációs fájljának létrehozása). Ha még nincs regisztrálva egy adatkészlet, 'titanic_ds' akkor létrehoz egyet. A kód letölti a CSV-adatokat az internetről, azokkal példányt TabularDataset hoz létre, majd regisztrálja az adathalmazt a munkaterületen. Végül a függvény Dataset.get_by_name() hozzárendeli a Dataset következőhöz titanic_ds: .

A tárolási és számítási cél konfigurálása

A folyamathoz további erőforrásokra lesz szükség a tárolás és általában az Azure Machine Learning számítási erőforrásai.

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]

Az adatelőkészítés és az automatizált gépi tanulási lépés köztes adatai a munkaterület alapértelmezett adattárában tárolhatók, így nem kell többet tennünk, mint az Workspace objektum meghívásaget_default_datastore().

Ezután a kód ellenőrzi, hogy az Azure Machine Learning számítási cél 'cpu-cluster' már létezik-e. Ha nem, meg kell adni, hogy egy kis cpu-alapú számítási célt szeretnénk. Ha az automatizált gépi tanulás mélytanulási funkcióit (például a szöveg featurizálását DNN-támogatással) tervezi használni, válasszon erős GPU-támogatással rendelkező számítást a GPU-optimalizált virtuálisgép-méretekben leírtak szerint.

A kód blokkolja a cél üzembe helyezését, majd kinyomtatja az imént létrehozott számítási cél néhány részletét. Végül a rendszer lekéri a névvel ellátott számítási célt a munkaterületről, és hozzá lesz rendelve.compute_target

A betanítási futtatás konfigurálása

A futtatókörnyezet beállítása objektum RunConfiguration létrehozásával és konfigurálásával történik. Itt állítjuk be a számítási célt.

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

Adatok előkészítése automatizált gépi tanuláshoz

Az adatelőkészítési kód megírása

Az alapkonfigurációs Titanic-adatkészlet vegyes numerikus és szöveges adatokból áll, és néhány érték hiányzik. Az automatizált gépi tanulás előkészítéséhez az adatelőkészítési folyamat lépése a következő lesz:

  • Hiányzó adatok kitöltése véletlenszerű adatokkal vagy "Ismeretlen" kategóriával
  • Kategorikus adatok átalakítása egész számokká
  • Nem használni kívánt oszlopok elvetése
  • Adatok felosztása betanítási és tesztelési csoportokra
  • Az átalakított adatok írása a OutputFileDatasetConfig kimeneti útvonalakra
%%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")

A fenti kódrészlet egy teljes, de minimális példa a Titanic-adatok adatelőkészítésére. A kódrészlet egy Jupyter "magic command" paranccsal kezdődik, amely a kódot egy fájlba irányítja. Ha nem Jupyter-jegyzetfüzetet használ, távolítsa el ezt a sort, és hozza létre manuálisan a fájlt.

A fenti kódrészlet különböző prepare_ függvényei módosítják a bemeneti adathalmaz megfelelő oszlopát. Ezek a függvények akkor működnek az adatokon, ha pandas-objektummá DataFrame változtak. A hiányzó adatok minden esetben reprezentatív véletlenszerű adatokkal vagy kategorikus adatokkal vannak kitöltve, amelyek "Ismeretlen" értéket jeleznek. A szövegalapú kategorikus adatok egész számokra lesznek leképezve. A már nem szükséges oszlopok felülíródnak vagy elvethetők.

Miután a kód meghatározta az adat-előkészítési függvényeket, a kód elemzi a bemeneti argumentumot, amely az az elérési út, amelyhez meg szeretnénk írni az adatokat. (Ezeket az értékeket a következő lépésben tárgyalt objektumok határozzák meg OutputFileDatasetConfig .) A kód lekéri a regisztrált 'titanic_cs'Datasetadatokat, pandassá DataFramealakítja, és meghívja a különböző adat-előkészítési függvényeket.

Mivel ez output_path egy könyvtár, a hívás to_csv() megadja a fájlnevet prepped_data.csv.

Az adatelőkészítési folyamat lépésének megírása (PythonScriptStep)

A fent leírt adatelőkészítési kódot egy PythonScripStep folyamathoz használandó objektumhoz kell társítani. A CSV-kimenet elérési útját egy OutputFileDatasetConfig objektum hozza létre. A korábban előkészített erőforrások, például a ComputeTarget, a RunConfig, és azokat 'titanic_ds' Dataset használják a specifikáció befejezéséhez.

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
)

Az prepped_data_path objektum típusa OutputFileDatasetConfig egy könyvtárra mutat. Figyelje meg, hogy a paraméterben arguments van megadva. Ha áttekinti az előző lépést, láthatja, hogy az adatelőkészítési kódban az argumentum '--output_path' értéke az a könyvtár elérési útja, amelyen a CSV-fájl meg lett írva.

Betanítása az AutoMLStep használatával

Az automatikus gépi tanulási folyamat konfigurálását az AutoMLConfig osztály végzi. Ezt a rugalmas osztályt az automatizált gépi tanulási kísérletek Pythonban való konfigurálása című témakör ismerteti. Az adatbemenet és a kimenet a konfiguráció egyetlen olyan aspektusa, amely különös figyelmet igényel az ML-folyamatban. A folyamatok bemenetét AutoMLConfig és kimenetét az alábbiakban részletesen ismertetjük. Az adatokon túl az ML-folyamatok előnye, hogy különböző számítási célokat használhatnak különböző lépésekhez. Dönthet úgy, hogy csak az automatizált gépi tanulási folyamathoz használ nagyobb teljesítményűet ComputeTarget . Ez olyan egyszerű, mint egy erősebb RunConfigurationAutoMLConfig objektum paraméterének hozzárendelése run_configuration .

Adatok küldése ide: AutoMLStep

Az ML-folyamatokban a bemeneti adatoknak objektumnak kell lenniük Dataset . A legeredményesebb módszer a bemeneti adatok objektumok formájában történő OutputTabularDatasetConfig biztosítása. Létrehozhat egy ilyen típusú objektumot a read_delimited_files() rajta lévővelOutputFileDatasetConfig, például az prepped_data_pathprepped_data_path objektummal.

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

Egy másik lehetőség a munkaterületen regisztrált objektumok használata Dataset :

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

A két technika összehasonlítása:

Módszer Előnyök és hátrányok
OutputTabularDatasetConfig Nagyobb teljesítmény
Természetes útvonal innen: OutputFileDatasetConfig
A folyamat futtatása után az adatok nem maradnak meg
Bejegyzett Dataset Alacsonyabb teljesítmény
Többféleképpen is létrehozható
Az adatok megmaradnak, és az egész munkaterületen láthatók
Regisztrált Dataset technikát megjelenítő jegyzetfüzet

Automatizált gépi tanulási kimenetek megadása

A kimenetek a AutoMLStep magasabb teljesítményű modell és maga a modell végső metrikapontszámai. Ha további folyamatlépésekben szeretné használni ezeket a kimeneteket, készítse elő OutputFileDatasetConfig az objektumokat a fogadásukra.

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

A fenti kódrészlet létrehozza a két PipelineData objektumot a metrikákhoz és a modell kimenetéhez. Mindegyik neve el van nevezve, a korábban lekért alapértelmezett adattárhoz van rendelve, és az adott type adathoz TrainingOutput van társítva a AutoMLStep. Mivel ezekhez az PipelineData objektumokhoz rendelünk hozzá pipeline_output_name értékeket, az értékek nem csak az egyes folyamatlépésekből, hanem a folyamat egészéből is elérhetők lesznek, ahogy az alábbiakban a "Folyamateredmények vizsgálata" című szakaszban fogjuk tárgyalni.

Az automatizált gépi tanulási folyamat lépéseinek konfigurálása és létrehozása

A bemenetek és kimenetek definiálása után itt az ideje, hogy létrehozzák az ésAutoMLStep.AutoMLConfig A konfiguráció részletei a feladattól függenek, ahogyan az automatizált gépi tanulási kísérletek Pythonban való konfigurálása című cikkben leírtak szerint. A Titanic túlélési besorolási feladatához az alábbi kódrészlet egy egyszerű konfigurációt mutat be.

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)

A kódrészlet egy gyakran használt AutoMLConfigkifejezéssel jelenik meg. A folyadékosabb argumentumokat (hyperparameter-ish) egy külön szótárban adhatók meg, míg a kisebb valószínűséggel változó értékek közvetlenül a AutoMLConfig konstruktorban vannak megadva. Ebben az esetben adjon automl_settings meg egy rövid futtatást: a futtatás csak 2 iteráció vagy 15 perc után fejeződik be, attól függően, hogy melyik lesz az első.

A automl_settings szótár átkerül a AutoMLConfig konstruktornak, mint kwargs. A többi paraméter nem bonyolult:

  • task beállítás értéke ebben a classification példában. Egyéb érvényes értékek a következők:regressionforecasting
  • path és debug_log írja le a projekt elérési útját és egy helyi fájlt, amelybe hibakeresési információkat fog írni
  • compute_target az a korábban definiált compute_target , hogy ebben a példában egy olcsó CPU-alapú gép. Ha az AutoML mélytanulási lehetőségeit használja, a számítási célt GPU-alapúra szeretné módosítani
  • featurization beállítás értéke : auto. További részletek az automatizált gépi tanulási konfigurációs dokumentum Adat featurizálás szakaszában találhatók
  • label_column_name azt jelzi, hogy melyik oszlopot szeretnénk előrejelezni
  • training_dataaz adatelőkészítési lépés kimenetéből származó objektumokra van állítva OutputTabularDatasetConfig

A AutoMLStep metrikák és a AutoMLConfig modelladatok tárolására létrehozott objektumokat saját maga veszi át, és kimenetként PipelineData is rendelkezik.

Fontos

Csak akkor kell beállítania enable_default_model_output , és enable_default_metrics_output csak akkor, True ha használja AutoMLStepRun.

Ebben a példában az automatizált gépi tanulási folyamat keresztellenőrzéseket hajt végre a training_data. Az argumentummal n_cross_validations szabályozhatja a keresztérvényesítések számát. Ha már felosztotta a betanítási adatokat az adatelőkészítési lépések részeként, beállíthatja validation_data a sajátját Dataset.

Előfordulhat, hogy időnként megjelenik az adatfunkciók és y az adatfeliratok használataX. Ez a technika elavult, és a bemenethez kell használnia training_data .

Az automatizált gépi tanulás által létrehozott modell regisztrálása

Egy egyszerű ML-folyamat utolsó lépése a létrehozott modell regisztrálása. Ha hozzáadja a modellt a munkaterület modellregisztrációs adatbázisához, az elérhető lesz a portálon, és verziószámozott lesz. A modell regisztrálásához írjon egy másikat PythonScriptStep , amely a model_data kimenetet veszi fel AutoMLStep.

Írja meg a kódot a modell regisztrálásához

A modell regisztrálva van egy Workspace. Valószínűleg ismeri Workspace.from_config() a munkaterületre való bejelentkezést a helyi gépen, de van egy másik módja is a munkaterület lekérésének egy futó ML-folyamaton belül. A Run.get_context() rendszer lekéri az aktív Run. Ez az run objektum számos fontos objektumhoz biztosít hozzáférést, beleértve az Workspace itt használt objektumokat is.

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

PythonScriptStep-kód írása

Figyelmeztetés

Ha az Azure Machine Learning SDK 1-et használja, és a munkaterület hálózati elkülönítésre (VNet) van konfigurálva, a lépés futtatásakor hibaüzenet jelenhet meg. További információ: A HyperdriveStep és az AutoMLStep hálózatelkülönítéssel meghiúsul.

A modellregisztrálás PythonScriptStep egy argumentumot használ PipelineParameter . A folyamatparaméterek olyan folyamatok argumentumai, amelyek egyszerűen beállíthatók a futtatáskor. A deklarált értékeket a függvény normál argumentumként adja át.


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)

Automatizált gépi tanulási folyamat létrehozása és futtatása

Egy olyan folyamat létrehozása és futtatása, amely egy AutoMLStep normál folyamattól nem különbözik.

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

A fenti kód egyesíti az adatok előkészítését, az automatizált gépi tanulást és a modellregisztrációs lépéseket egy Pipeline objektumban. Ezután létrehoz egy objektumot Experiment . A Experiment konstruktor lekéri az elnevezett kísérletet, ha létezik, vagy szükség esetén létrehozza. Elküldi az objektumot a PipelineExperimentfolyamat Run aszinkron futtatásához. A wait_for_completion() függvény blokkolja, amíg a futtatás befejeződik.

Folyamat eredményeinek vizsgálata

run A befejezés után lekérheti PipelineData a hozzárendelt pipeline_output_nameobjektumokat. Letöltheti az eredményeket, és betöltheti őket további feldolgozásra.

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)

A letöltött fájlok az alkönyvtárba azureml/{run.id}/vannak írva. A metrikák fájlja JSON-formátumú, és a vizsgálathoz Pandas-adatkeretté alakítható.

Előfordulhat, hogy a helyi feldolgozáshoz telepítenie kell a megfelelő csomagokat, például a Pandast, a Pickle-t, az Azure Machine Learning SDK-t stb. Ebben a példában valószínű, hogy az automatizált gépi tanulás által talált legjobb modell az XGBoosttól függ.

!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

A fenti kódrészlet a metrikafájlt jeleníti meg, amely az Azure-adattárból töltődik be. A letöltött fájlból is betöltheti a megjegyzésben látható módon. Miután deszerializálta és Pandas DataFrame-gé alakította át, részletes metrikákat láthat az automatizált gépi tanulási lépés egyes iterációihoz.

A modellfájl deszerializálható egy Model objektumba, amelyet a következtetéshez, a további metrikák elemzéséhez és így tovább használhat.

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

A meglévő modellek betöltéséről és használatáról további információt a Meglévő modell használata az Azure Machine Learningben című témakörben talál.

Automatizált ml-futtatás eredményeinek letöltése

Ha követte a cikket, egy példányosított objektummal run fog rendelkezni. A kész Run objektumokat Workspace azonban egy objektum útján Experiment is lekérheti.

A munkaterület tartalmazza az összes kísérlet és futtatás teljes rekordját. A portálon megkeresheti és letöltheti a kísérletek kimeneteit, vagy használhat kódot. Ha egy korábbi futtatás rekordjait szeretné elérni, az Azure Machine Learning segítségével keresse meg annak a futtatásnak az azonosítóját, amelyben érdeklődik. Ezzel az azonosítóval kiválaszthatja az adott run azonosítót az és Experimenta Workspace .

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

A fenti kódban szereplő sztringeket az előzményfuttatás jellemzőire kell módosítania. A fenti kódrészlet feltételezi, hogy a megfelelőhöz Workspace rendelte ws a normál from_config(). A program közvetlenül lekéri az Run érdeklődési kísérletet, majd a kód az érték egyeztetésével megkeresi a run.id kamatot.

Miután rendelkezik egy Run objektummal, letöltheti a metrikákat és a modellt.

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

Minden Run objektum olyan objektumokat tartalmaz StepRun , amelyek információkat tartalmaznak az egyes folyamatlépések futtatásáról. A run keresett objektum AutoMLStepa StepRun . A metrikák és a modell az alapértelmezett nevük alapján lesznek lekérve, amelyek akkor is elérhetők, ha nem ad át PipelineData objektumokat a outputsAutoMLStepparaméternek.

Végül a rendszer letölti a tényleges metrikákat és modellt a helyi gépre, amint azt a fenti "Folyamateredmények vizsgálata" című szakaszban tárgyaltuk.

Következő lépések