Delen via

Geautomatiseerde ML gebruiken in een Azure Machine Learning-pijplijn in Python

  • Artikel

VAN TOEPASSING OP: Python SDK azureml v1

Met de geautomatiseerde ML-functionaliteit van Azure Machine Learning kunt u krachtige modellen ontdekken zonder dat u elke mogelijke benadering opnieuw hoeft te implementeren. In combinatie met Azure Machine Learning-pijplijnen kunt u implementeerbare werkstromen maken waarmee u snel het algoritme kunt detecteren dat het beste werkt voor uw gegevens. In dit artikel leest u hoe u efficiënt een stap voor gegevensvoorbereiding kunt toevoegen aan een geautomatiseerde ML-stap. Geautomatiseerde ML kan snel het algoritme ontdekken dat het beste werkt voor uw gegevens, terwijl u onderweg bent naar MLOps en de levenscyclus van modellen operationeel wilt maken met pijplijnen.

Vereisten

Bekijk de centrale klassen van geautomatiseerde ML

Geautomatiseerde ML in een pijplijn wordt vertegenwoordigd door een AutoMLStep object. De AutoMLStep klasse is een subklasse van PipelineStep. Een grafiek met PipelineStep objecten definieert een Pipeline.

Er zijn verschillende subklassen van PipelineStep. Naast het AutoMLStepartikel wordt in dit artikel een PythonScriptStep voor gegevensvoorbereiding en een andere voor het registreren van het model weergegeven.

De voorkeursmethode voor het in eerste instantie verplaatsen van gegevens naar een ML-pijplijn is met Dataset objecten. Als u gegevens tussen stappen wilt verplaatsen en gegevensuitvoer van uitvoeringen wilt opslaan, is de voorkeurswijze met OutputFileDatasetConfig en OutputTabularDatasetConfig objecten. Als u wilt gebruiken, AutoMLStepmoet het PipelineData object worden omgezet in een PipelineOutputTabularDataset object. Zie Invoer- en uitvoergegevens van ML-pijplijnen voor meer informatie.

De AutoMLStep is geconfigureerd via een AutoMLConfig object. AutoMLConfig is een flexibele klasse, zoals beschreven in Geautomatiseerde ML-experimenten configureren in Python.

Een Pipeline uitvoering in een Experiment. De pijplijn Run heeft voor elke stap een onderliggend element StepRun. De uitvoer van de geautomatiseerde ML StepRun zijn de metrische trainingsgegevens en het best presterende model.

Om dingen concreet te maken, maakt dit artikel een eenvoudige pijplijn voor een classificatietaak. De taak voorspelt het overleven van De Titanic, maar we bespreken de gegevens of taken niet, behalve in het doorgeven.

Aan de slag

Eerste gegevensset ophalen

Vaak begint een ML-werkstroom met bestaande basislijngegevens. Dit is een goed scenario voor een geregistreerde gegevensset. Gegevenssets zijn zichtbaar in de werkruimte, bieden ondersteuning voor versiebeheer en kunnen interactief worden verkend. Er zijn veel manieren om een gegevensset te maken en te vullen, zoals beschreven in Azure Machine Learning-gegevenssets maken. Omdat we de Python SDK gebruiken om onze pijplijn te maken, gebruikt u de SDK om basislijngegevens te downloaden en te registreren met de naam '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')

De code meldt zich eerst aan bij de Azure Machine Learning-werkruimte die is gedefinieerd in config.json (zie Een werkruimteconfiguratiebestand maken voor een uitleg. Als er nog geen geregistreerde gegevensset 'titanic_ds' is, wordt er een gemaakt. De code downloadt CSV-gegevens van het web, gebruikt ze om een TabularDataset instantie te maken en registreert vervolgens de gegevensset bij de werkruimte. Ten slotte wijst de functie Dataset.get_by_name() de Dataset toe aan titanic_ds.

Uw opslag- en rekendoel configureren

Aanvullende resources die de pijplijn nodig heeft, zijn opslag en over het algemeen Rekenresources van 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]

De tussenliggende gegevens tussen de gegevensvoorbereiding en de geautomatiseerde ML-stap kunnen worden opgeslagen in het standaardgegevensarchief van de werkruimte, dus we hoeven niet meer te doen dan het Workspace object aanroepenget_default_datastore().

Daarna controleert de code of het Azure Machine Learning-rekendoel 'cpu-cluster' al bestaat. Zo niet, dan geven we aan dat we een klein REKENdoel op basis van CPU willen. Als u van plan bent om de deep learning-functies van geautomatiseerde ML te gebruiken (bijvoorbeeld tekst met DNN-ondersteuning) moet u een berekening met sterke GPU-ondersteuning kiezen, zoals beschreven in de grootten van de met GPU geoptimaliseerde virtuele machines.

De codeblokken totdat het doel is ingericht en vervolgens enkele details van het zojuist gemaakte rekendoel afdrukken. Ten slotte wordt het benoemde rekendoel opgehaald uit de werkruimte en toegewezen aan compute_target.

De trainingsuitvoering configureren

De runtimecontext wordt ingesteld door een RunConfiguration object te maken en te configureren. Hier stellen we het rekendoel in.

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

Gegevens voorbereiden voor geautomatiseerde machine learning

De code voor gegevensvoorbereiding schrijven

De gegevensset Van de basislijn Titanic bestaat uit gemengde numerieke en tekstgegevens, waarbij enkele waarden ontbreken. Om deze voor te bereiden op geautomatiseerde machine learning, zal de pijplijnstap voor gegevensvoorbereiding het volgende doen:

  • Ontbrekende gegevens vullen met willekeurige gegevens of een categorie die overeenkomt met 'Onbekend'
  • Categorische gegevens transformeren naar gehele getallen
  • Kolommen verwijderen die we niet willen gebruiken
  • De gegevens splitsen in trainings- en testsets
  • De getransformeerde gegevens naar de OutputFileDatasetConfig uitvoerpaden schrijven
%%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")

Het bovenstaande codefragment is een volledig, maar minimaal voorbeeld van gegevensvoorbereiding voor de Titanic-gegevens. Het codefragment begint met een Jupyter -magic-opdracht om de code naar een bestand uit te voeren. Als u geen Jupyter-notebook gebruikt, verwijdert u deze regel en maakt u het bestand handmatig.

De verschillende prepare_ functies in het bovenstaande fragment wijzigen de relevante kolom in de invoergegevensset. Deze functies werken aan de gegevens zodra deze zijn gewijzigd in een Pandas-object DataFrame . In elk geval worden ontbrekende gegevens gevuld met representatieve willekeurige gegevens of categorische gegevens die 'Onbekend' aangeven. Categorische gegevens op basis van tekst worden toegewezen aan gehele getallen. Kolommen die niet meer nodig zijn, worden overschreven of verwijderd.

Nadat de code de functies voor gegevensvoorbereiding heeft gedefinieerd, parseert de code het invoerargument. Dit is het pad waarnaar we onze gegevens willen schrijven. (Deze waarden worden bepaald door OutputFileDatasetConfig objecten die in de volgende stap worden besproken.) De code haalt de geregistreerde 'titanic_cs'Dataset, converteert deze naar een Pandas DataFrameen roept de verschillende functies voor gegevensvoorbereiding aan.

Omdat het output_path een map is, geeft de aanroep om de bestandsnaam prepped_data.csvop te to_csv() geven.

De pijplijnstap voor gegevensvoorbereiding schrijven (PythonScriptStep)

De hierboven beschreven gegevensvoorbereidingscode moet worden gekoppeld aan een PythonScripStep object dat moet worden gebruikt met een pijplijn. Het pad waarnaar de CSV-uitvoer wordt geschreven, wordt gegenereerd door een OutputFileDatasetConfig object. De resources die eerder zijn voorbereid, zoals de ComputeTarget, de RunConfigen de 'titanic_ds' Dataset resources, worden gebruikt om de specificatie te voltooien.

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
)

Het prepped_data_path object is van het type OutputFileDatasetConfig dat verwijst naar een map. U ziet dat deze is opgegeven in de arguments parameter. Als u de vorige stap bekijkt, ziet u dat in de code voor gegevensvoorbereiding de waarde van het argument '--output_path' het mappad is waarop het CSV-bestand is geschreven.

Trainen met AutoMLStep

Het configureren van een geautomatiseerde ML-pijplijnstap wordt uitgevoerd met de AutoMLConfig klasse. Deze flexibele klasse wordt beschreven in Geautomatiseerde ML-experimenten configureren in Python. Gegevensinvoer en -uitvoer zijn de enige aspecten van de configuratie die speciale aandacht vereisen in een ML-pijplijn. Hieronder vindt u gedetailleerde informatie over de invoer en uitvoer voor AutoMLConfig in pijplijnen. Naast gegevens is een voordeel van ML-pijplijnen de mogelijkheid om verschillende rekendoelen te gebruiken voor verschillende stappen. U kunt ervoor kiezen om alleen een krachtiger ComputeTarget gebruik te maken voor het geautomatiseerde ML-proces. Dit is net zo eenvoudig als het toewijzen van een krachtigere RunConfiguration aan de parameter van run_configuration het AutoMLConfig object.

Gegevens verzenden naar AutoMLStep

In een ML-pijplijn moeten de invoergegevens een Dataset object zijn. De best presterende manier is het leveren van de invoergegevens in de vorm van OutputTabularDatasetConfig objecten. U maakt een object van dat type met de read_delimited_files() op een OutputFileDatasetConfig, zoals het prepped_data_pathobject, zoals het prepped_data_path object.

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

Een andere optie is het gebruik van Dataset objecten die zijn geregistreerd in de werkruimte:

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

De twee technieken vergelijken:

Techniek Voordelen en nadelen
OutputTabularDatasetConfig Hogere prestaties
Natuurlijke route van OutputFileDatasetConfig
Gegevens worden niet behouden nadat de pijplijn is uitgevoerd
Geregistreerd Dataset Lagere prestaties
Kan op veel manieren worden gegenereerd
Gegevens blijven behouden en zijn zichtbaar in de hele werkruimte
Notitieblok met geregistreerde Dataset techniek

Geautomatiseerde ML-uitvoer opgeven

De uitvoer van de resultaten AutoMLStep zijn de uiteindelijke metrische scores van het hogere presterende model en dat model zelf. Als u deze uitvoer in verdere pijplijnstappen wilt gebruiken, bereidt u objecten voor OutputFileDatasetConfig om ze te ontvangen.

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

Met het bovenstaande codefragment worden de twee PipelineData objecten voor de metrische gegevens en modeluitvoer gemaakt. Elk is benoemd, toegewezen aan het standaardgegevensarchief dat eerder is opgehaald en gekoppeld aan het specifieke type van TrainingOutput de AutoMLStep. Omdat we deze PipelineData objecten toewijzenpipeline_output_name, zijn hun waarden niet alleen beschikbaar vanuit de afzonderlijke pijplijnstap, maar ook vanuit de pijplijn als geheel, zoals hieronder wordt besproken in de sectie 'Pijplijnresultaten onderzoeken'.

De geautomatiseerde ML-pijplijnstap configureren en maken

Zodra de invoer en uitvoer zijn gedefinieerd, is het tijd om de AutoMLConfig en AutoMLStepte maken. De details van de configuratie zijn afhankelijk van uw taak, zoals beschreven in Geautomatiseerde ML-experimenten configureren in Python. Het volgende codefragment laat een eenvoudige configuratie zien voor de Taak voor het overleven van de Titanic.

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)

Het fragment toont een idioom die vaak wordt gebruikt met AutoMLConfig. Argumenten die vloeiender zijn (hyperparameter-ish) worden opgegeven in een afzonderlijke woordenlijst, terwijl de waarden die minder waarschijnlijk zullen worden gewijzigd, rechtstreeks in de AutoMLConfig constructor worden opgegeven. In dit geval geeft u automl_settings een korte uitvoering op: de uitvoering stopt na slechts 2 iteraties of 15 minuten, afhankelijk van wat het eerst komt.

De automl_settings woordenlijst wordt als kwargs doorgegeven aan de AutoMLConfig constructor. De andere parameters zijn niet complex:

  • task is ingesteld op classification dit voorbeeld. Andere geldige waarden zijn regression en forecasting
  • path en debug_log beschrijf het pad naar het project en een lokaal bestand waarnaar foutopsporingsgegevens worden geschreven
  • compute_target is de eerder gedefinieerde compute_target dat in dit voorbeeld een goedkope MACHINE op basis van CPU is. Als u de Deep Learning-faciliteiten van AutoML gebruikt, wilt u het rekendoel wijzigen in GPU
  • featurization is ingesteld op auto. Meer informatie vindt u in de sectie Data Featurization van het geautomatiseerde ML-configuratiedocument
  • label_column_name geeft aan welke kolom we geïnteresseerd zijn in het voorspellen
  • training_data is ingesteld op de OutputTabularDatasetConfig objecten die zijn gemaakt op basis van de uitvoer van de gegevensvoorbereidingsstap

De AutoMLStep zelf neemt de AutoMLConfig en heeft, als uitvoer, de PipelineData objecten die zijn gemaakt om de metrische gegevens en modelgegevens op te slaan.

Belangrijk

U moet deze optie alleen instellen en enable_default_metrics_outputTrue alleen instellen enable_default_model_output als u .AutoMLStepRun

In dit voorbeeld voert het geautomatiseerde ML-proces kruisvalidaties uit op de training_data. U kunt het aantal kruisvalidaties met het n_cross_validations argument bepalen. Als u uw trainingsgegevens al hebt gesplitst als onderdeel van uw stappen voor gegevensvoorbereiding, kunt u deze instellen validation_data op een eigen Dataset.

Soms ziet u het gebruik X voor gegevensfuncties en y voor gegevenslabels. Deze techniek is afgeschaft en u moet deze gebruiken training_data voor invoer.

Het model registreren dat wordt gegenereerd door geautomatiseerde ML

De laatste stap in een eenvoudige ML-pijplijn is het gemaakte model registreren. Door het model toe te voegen aan het modelregister van de werkruimte, is het beschikbaar in de portal en kan het worden geversied. Als u het model wilt registreren, schrijft u een andere PythonScriptStep die de uitvoer van het model_dataAutoMLStepmodel gebruikt.

De code schrijven om het model te registreren

Een model is geregistreerd in een Workspace. U bent waarschijnlijk bekend met het aanmelden Workspace.from_config() bij uw werkruimte op uw lokale computer, maar er is een andere manier om de werkruimte op te halen vanuit een actieve ML-pijplijn. Hiermee Run.get_context() wordt de actieve Runopgehaald. Dit run object biedt toegang tot veel belangrijke objecten, waaronder de Workspace objecten die hier worden gebruikt.

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

De PythonScriptStep-code schrijven

Waarschuwing

Als u de Azure Machine Learning SDK v1 gebruikt en uw werkruimte is geconfigureerd voor netwerkisolatie (VNet), treedt er mogelijk een fout op bij het uitvoeren van deze stap. Zie HyperdriveStep en AutoMLStep mislukken met netwerkisolatie voor meer informatie.

Bij het registreren PythonScriptStep van modellen wordt een PipelineParameter voor een van de argumenten gebruikt. Pijplijnparameters zijn argumenten voor pijplijnen die eenvoudig kunnen worden ingesteld tijdens het indienen van uitvoeringen. Zodra ze zijn gedeclareerd, worden ze doorgegeven als normale argumenten.


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)

Uw geautomatiseerde ML-pijplijn maken en uitvoeren

Het maken en uitvoeren van een pijplijn die een AutoMLStep bevat, verschilt niet van een normale pijplijn.

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

De bovenstaande code combineert de stappen voor gegevensvoorbereiding, geautomatiseerde ML en modelregistering in een Pipeline object. Vervolgens wordt er een Experiment object gemaakt. De Experiment constructor haalt het benoemde experiment op als het bestaat of maakt het indien nodig. Hiermee wordt het Pipeline naar het Experimentobject verzonden, dat een Run object maakt waarmee de pijplijn asynchroon wordt uitgevoerd. De wait_for_completion() functie blokkeert totdat de uitvoering is voltooid.

Pijplijnresultaten onderzoeken

Zodra de run bewerking is voltooid, kunt u objecten ophalen PipelineData waaraan een pipeline_output_name. U kunt de resultaten downloaden en laden voor verdere verwerking.

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)

Gedownloade bestanden worden naar de submap azureml/{run.id}/geschreven. Het bestand met metrische gegevens is JSON-indeling en kan worden geconverteerd naar een Pandas-dataframe voor onderzoek.

Voor lokale verwerking moet u mogelijk relevante pakketten installeren, zoals Pandas, Pickle, de Azure Machine Learning SDK, enzovoort. In dit voorbeeld is het waarschijnlijk dat het beste model dat door geautomatiseerde ML wordt gevonden, afhankelijk is van 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

In het bovenstaande codefragment ziet u het bestand met metrische gegevens dat wordt geladen vanaf de locatie in het Azure-gegevensarchief. U kunt het ook laden vanuit het gedownloade bestand, zoals wordt weergegeven in de opmerking. Nadat u deze hebt gedeserialiseerd en geconverteerd naar een Pandas DataFrame, kunt u gedetailleerde metrische gegevens zien voor elk van de iteraties van de geautomatiseerde ML-stap.

Het modelbestand kan worden gedeserialiseerd in een Model object dat u kunt gebruiken voor deductie, verdere analyse van metrische gegevens, enzovoort.

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

Zie Een bestaand model gebruiken met Azure Machine Learning voor meer informatie over het laden en werken met bestaande modellen.

De resultaten van een geautomatiseerde ML-uitvoering downloaden

Als u het artikel hebt gevolgd, hebt u een geïnstantieerd run object. U kunt echter ook voltooide Run objecten ophalen uit de Workspace manier van een Experiment object.

De werkruimte bevat een volledige record van al uw experimenten en uitvoeringen. U kunt de portal gebruiken om de uitvoer van experimenten te zoeken en te downloaden of code te gebruiken. Als u toegang wilt krijgen tot de records vanuit een historische uitvoering, gebruikt u Azure Machine Learning om de id te vinden van de uitvoering waarin u geïnteresseerd bent. Met die id kunt u de specifieke run kiezen via de Workspace en 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)

U moet de tekenreeksen in de bovenstaande code wijzigen in de details van uw historische uitvoering. In het bovenstaande fragment wordt ervan uitgegaan dat u aan de relevante hebt Workspace toegewezen ws met het normale from_config()bestand. Het interesse-experiment wordt rechtstreeks opgehaald en vervolgens wordt met de code de Run interesse gevonden door de run.id waarde te vergelijken.

Zodra u een Run object hebt, kunt u de metrische gegevens en het model downloaden.

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

Elk Run object bevat StepRun objecten die informatie bevatten over de afzonderlijke pijplijnstapuitvoering. Er run wordt gezocht naar het StepRun object voor de AutoMLStep. De metrische gegevens en het model worden opgehaald met behulp van hun standaardnamen, die beschikbaar zijn, zelfs als u geen objecten doorgeeft PipelineData aan de outputs parameter van de AutoMLStep.

Ten slotte worden de werkelijke metrische gegevens en het model gedownload naar uw lokale computer, zoals is besproken in de sectie Pijplijnresultaten onderzoeken hierboven.

Volgende stappen