Använda AutoML i en Azure Machine Learning-pipeline

GÄLLER FÖR:Azure Machine Learning SDK v1 för Python

Med Funktionen automatisk maskininlärning (AutoML) i Azure Machine Learning kan du identifiera högpresterande modeller utan att omimplementera alla möjliga metoder. I kombination med Azure Machine Learning-pipelines kan du skapa distribuerade arbetsflöden som snabbt identifierar den algoritm som fungerar bäst för dina data.

Den här artikeln beskriver hur du effektivt ansluter ett steg för förberedelse av data till ett automatiserat maskininlärningssteg med hjälp av Python. AutoML kan snabbt identifiera algoritmen som fungerar bäst för dina data, samtidigt som du är på väg mot MLOps och drift av modellens livscykel med pipelines.

Förutsättningar

• En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen av Azure Machine Learning idag.

• En Azure Machine Learning-arbetsyta. Se Skapa resurser som du behöver för att komma igång.

• Kunskaper om Azures automatiserade maskininlärnings - och maskininlärningspipelines och SDK.

Granska AutoML:s centrala klasser

Automatiserad maskininlärning i en pipeline representeras av ett AutoMLStep objekt. Klassen AutoMLStep är en underklass av PipelineStep. Ett diagram med PipelineStep objekt definierar en Pipeline.

Det finns flera underklasser av PipelineStep. Förutom AutoMLStep visar den här artikeln en PythonScriptStep för förberedelse av data och en annan för att registrera modellen.

Det bästa sättet att först flytta data till en maskininlärningspipeline är med Dataset objekt. Om du vill flytta data mellan steg och spara dataresultat från körningar, är det föredragna sättet med OutputFileDatasetConfig och OutputTabularDatasetConfig objekt. För att kunna användas med AutoMLStepPipelineData måste objektet omvandlas till ett PipelineOutputTabularDataset objekt. Mer information finns i Flytta data till och mellan ML-pipelinesteg.

AutoMLStep Konfigureras via ett AutoMLConfig objekt. AutoMLConfig är en flexibel klass, enligt beskrivningen i Konfigurera dina experimentinställningar.

En Pipeline körs i en Experiment. Pipelinen Run har för varje steg ett underordnat StepRun. Utdata från den automatiserade maskininlärningen StepRun är träningsmåtten och modellen med högst prestanda.

För att göra saker konkreta skapar den här artikeln en enkel pipeline för en klassificeringsuppgift. Uppgiften förutsäger Titanics överlevnad, men vi diskuterar inte data eller uppgift förutom i förbigående.

Kom igång

Hämta den första datamängden

Ofta börjar ett maskininlärningsarbetsflöde med befintliga baslinjedata. Det här är ett bra scenario för en registrerad datauppsättning. Datauppsättningar visas på arbetsytan, stöder versionshantering och kan utforskas interaktivt. Det finns många sätt att skapa och fylla i en datauppsättning, enligt beskrivningen i Skapa Azure Machine Learning-datamängder. Eftersom vi använder Python SDK för att skapa vår pipeline använder du SDK:et för att ladda ned baslinjedata och registrera dem med namnet 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')

Koden loggar först in på Azure Machine Learning-arbetsytan som definierats i config.json. Information om hur du skapar konfigurationsfiler finns i Skapa en konfigurationsfil för arbetsytan. Om det inte redan finns en datauppsättning med namnet 'titanic_ds' registrerad skapar den en. Koden laddar ned CSV-data från webben, instansierar en TabularDatasetoch registrerar sedan datauppsättningen med arbetsytan. Slutligen tilldelar Dataset.get_by_name() funktionen Dataset till titanic_ds.

Konfigurera ditt lagrings- och beräkningsmål

Ytterligare resurser som pipelinen behöver är lagrings- och i allmänhet Azure Machine Learning-beräkningsresurser.

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]

Mellanliggande data mellan dataförberedelsen och AutoML-steget kan lagras i arbetsytans standarddatalager, så du behöver inte göra mer än att anropa get_default_datastore() objektet Workspace .

Därefter kontrollerar koden om Azure Machine Learning-beräkningsmålet 'cpu-cluster' redan finns. Om inte anger du att du vill ha ett litet CPU-baserat beräkningsmål. Om du planerar att använda AutoML:s djupinlärningsfunktioner (till exempel textfunktioner med DNN-stöd) bör du välja en datorkraft med starkt GPU-stöd, enligt beskrivningen i GPU-optimerade virtuella datorstorlekar.

Koden blockerar tills målet har etablerats och skriver sedan ut lite information om det just skapade beräkningsmålet. Slutligen hämtas det namngivna beräkningsmålet från arbetsytan och tilldelas till compute_target.

Konfigurera träningskörningen

Körningskontexten anges genom att skapa och konfigurera ett RunConfiguration objekt. Här anger vi beräkningsmålet.

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

Förbereda data för AutoML

Skriva koden för förberedelse av data

Titanic-baslinjedatauppsättningen består av blandade numeriska data och textdata, där vissa värden saknas. För att förbereda den för automatiserad maskininlärning, steget för arbetsflöde för databereddning:

• Fyller saknade data med antingen slumpmässiga data eller en kategori som motsvarar Okänd
• Omvandlar kategoriska data till heltal
• Tar bort kolumner som du inte tänker använda
• Delar upp data i tränings- och testuppsättningar
• Skriver de transformerade data till utdatasökvägarna 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")

Föregående kodfragment är ett komplett, men minimalt, exempel på dataförberedelse för Titanic-data. Kodfragmentet börjar med ett Jupyter magic-kommando för att mata ut koden till en fil. Om du inte använder en Jupyter-anteckningsbok tar du bort den raden och skapar filen manuellt.

De olika prepare_ funktionerna i kodfragmentet ändrar relevant kolumn i indatauppsättningen. Dessa funktioner fungerar på data när de har ändrats till ett Pandas-objekt DataFrame . I varje fall fylls saknade data antingen med representativa slumpmässiga data eller kategoriska data som anger Okänd. Textbaserade kategoridata mappas till heltal. Kolumner som inte längre behövs skrivs över eller tas bort.

När koden har definierat funktionerna för förberedelse av data parsar koden indataargumentet, vilket är den sökväg som vi vill skriva våra data till. (Dessa värden bestäms av OutputFileDatasetConfig objekt som beskrivs i nästa steg.) Koden hämtar den registrerade 'titanic_cs'Dataset, konverterar den till en Pandas DataFrameoch anropar de olika funktionerna för dataförberedelse.

output_path Eftersom är en katalog anger anropet till to_csv() filnamnet prepped_data.csv.

Skriv pipelinesteget för dataförberedelse (PythonScriptStep)

Koden för förberedelse av data måste associeras med ett PythonScriptStep objekt som ska användas med en pipeline. Sökvägen till vilken CSV-utdata skrivs genereras av ett OutputFileDatasetConfig objekt. Resurserna som förbereddes tidigare, till exempel ComputeTarget, RunConfigoch 'titanic_ds' Dataset används för att slutföra specifikationen.

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
)

Objektet prepped_data_path är av den typ OutputFileDatasetConfig som pekar på en katalog. Observera att den anges i parametern arguments . Om du granskar föregående steg ser du att i koden för förberedelse av data är värdet för argumentet '--output_path' den katalogsökväg där CSV-filen skrevs.

Träna med AutoMLStep

Du konfigurerar ett steg för automatiserad maskininlärningspipeline med AutoMLConfig klassen. Mer information om den här flexibla klassen finns i AutoMLConfig-klass. Indata och utdata är de enda aspekterna av konfigurationen som kräver särskild uppmärksamhet i en maskininlärningspipeline. Indata och utdata för AutoMLConfig i pipelines beskrivs senare i den här artikeln. Utöver data är en fördel med maskininlärningspipelines möjligheten att använda olika beräkningsmål för olika steg. Du kan välja att använda en mer kraftfull ComputeTarget endast för den automatiserade maskininlärningsprocessen. Det är lika enkelt som att tilldela ett kraftfullare RunConfiguration objekt till AutoMLConfig objektets run_configuration parameter.

Skicka data till AutoMLStep

I en maskininlärningspipeline måste indata vara ett Dataset objekt. Det bästa sättet är att tillhandahålla indata i form av OutputTabularDatasetConfig objekt. Du skapar ett objekt av den read_delimited_files() typen med på , OutputFileDatasetConfigtill exempel prepped_data_path, till exempel prepped_data_path -objektet.

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

Ett annat alternativ är att använda Dataset objekt som är registrerade på arbetsytan:

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

Jämföra de två teknikerna:

Ange AutoML-utdata

Utdata från AutoMLStep är de slutliga måttpoängen för modellen med högre prestanda och själva modellen. Om du vill använda dessa utdata i ytterligare pipelinesteg förbereder du OutputFileDatasetConfig objekt för att ta emot dem.

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

Det här kodfragmentet skapar de två PipelineData objekten för mått och modellutdata. Var och en namnges, tilldelas till det standarddatalager som hämtades tidigare och associeras med den specifika typeTrainingOutput från AutoMLStep. Eftersom vi tilldelar pipeline_output_name dessa PipelineData objekt är deras värden tillgängliga inte bara från det enskilda pipelinesteget, utan från pipelinen som helhet, enligt beskrivningen senare i avsnittet Granska pipelineresultat.

Konfigurera och skapa autoML-pipelinesteget

När indata och utdata har definierats är det dags att skapa AutoMLConfig och AutoMLStep. Informationen om konfigurationen beror på din uppgift, enligt beskrivningen i Konfigurera AutoML-träning med Python. För titanics överlevnadsklassificeringsuppgift visar följande kodfragment en enkel konfiguration.

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)

Kodfragmentet visar ett idiom som ofta används med AutoMLConfig. Argument som är mer flytande (hyperparameter-ish) anges i en separat ordlista, medan värdena som är mindre benägna att ändras anges direkt i AutoMLConfig konstruktorn. I det här fallet specificerar automl_settings en kort körning: körningen stoppas efter bara två iterationer eller 15 minuter, beroende på vilket som kommer först.

Ordlistan automl_settings skickas till AutoMLConfig konstruktorn som kwargs. De andra parametrarna är inte komplexa:

• task är inställt på classification för det här exemplet. Andra giltiga värden är regression och forecasting.
• path och debug_log beskriva sökvägen till projektet och en lokal fil som felsökningsinformationen skrivs till.
• compute_target är den tidigare definierade compute_target som i det här exemplet är en billig processorbaserad dator. Om du använder AutoML:s djupinlärningsanläggningar vill du ändra beräkningsmålet till GPU-baserat.
• featurization är inställt på auto. Mer information finns i avsnittet Data featurization i AutoML-konfigurationsdokumentet.
• label_column_name anger vilken kolumn du är intresserad av att förutsäga.
• training_data är inställt på OutputTabularDatasetConfig objekt som har skapats från utdata från dataförberedelsesteget.

Själva AutoMLStep tar AutoMLConfig och har, som utdata, de PipelineData objekt som skapats för att lagra mått och modelldata.

I det här exemplet utför AutoML-processen korsvalidering på training_data. Du kan styra antalet korsvalideringar med n_cross_validations argumentet . Om du redan har delat upp dina träningsdata som en del av dina dataförberedelsesteg kan du ange validation_data till egna Dataset.

Ibland kan du se användningen av X för datafunktioner och y för dataetiketter. Den här tekniken är inaktuell och du bör använda training_data för indata.

Registrera modellen som genereras av AutoML

Det sista steget i en enkel maskininlärningspipeline är att registrera den skapade modellen. Genom att lägga till modellen i arbetsytans modellregister är den tillgänglig i Azure-portalen och kan versionshanteras. Om du vill registrera modellen skriver du en annan PythonScriptStep som tar model_data utdata från AutoMLStep.

Skriv koden för att registrera modellen

En modell är registrerad i en Workspace. Du är förmodligen bekant med att använda Workspace.from_config() för att logga in på din arbetsyta på den lokala datorn, men det finns ett annat sätt att hämta arbetsytan från en maskininlärningspipeline som körs. Run.get_context() Hämtar den aktiva run. Det här run objektet ger åtkomst till många viktiga objekt, inklusive det Workspace som används här.

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

Skriva PythonScriptStep-koden

Modellregistreringen PythonScriptStep använder en PipelineParameter för ett av argumenten. Pipelineparametrar är argument till pipelines som enkelt kan anges vid körningsöverföring. När de har deklarerats skickas de som normala argument.

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)

Skapa och kör din AutoML-pipeline

Att skapa och köra en pipeline som innehåller en AutoMLStep är inte annorlunda än en vanlig pipeline.

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

Den här koden kombinerar stegen för förberedelse av data, automatiserad maskininlärning och modellregistrering i ett Pipeline objekt. Sedan skapas ett Experiment objekt. Konstruktorn Experiment hämtar det namngivna experimentet om det finns eller skapar det om det behövs. Den skickar Pipeline till Experiment och skapar ett Run-objekt som asynkront kör en pipeline. Funktionen wait_for_completion() blockeras tills körningen har slutförts.

Granska pipelineresultat

När run är slutförd kan du hämta PipelineData-objekt som har tilldelats en pipeline_output_name. Du kan ladda ned resultaten och läsa in dem för vidare bearbetning.

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)

Nedladdade filer skrivs till underkatalogen azureml/{run.id}/. Måttfilen är JSON-formaterad och kan konverteras till en Pandas-dataram för undersökning.

För lokal bearbetning kan du behöva installera relevanta paket, till exempel Pandas, Pickle, Azure Machine Learning SDK och så vidare. I det här exemplet är det troligt att den bästa modellen som hittas av automatiserad maskininlärning är beroende av 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

Det här kodfragmentet visar måttfilen som läses in från dess plats i Azure-datalagret. Du kan också läsa in den från den nedladdade filen, som du ser i kommentaren. När du har deserialiserat den och konverterat den till en Pandas DataFrame kan du se detaljerade mått för var och en av iterationerna i det automatiserade maskininlärningssteget.

Modellfilen kan deserialiseras till ett Model objekt som du kan använda för slutsatsdragning, ytterligare måttanalys och så vidare.

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

Mer information om hur du läser in och arbetar med befintliga modeller finns i Distribuera maskininlärningsmodeller till Azure.

Ladda ned resultatet av en AutoML-körning

Om du har följt artikeln har du ett instansierat Run objekt. Men du kan också hämta slutförda Run objekt från Workspace via ett Experiment objekt.

Arbetsytan innehåller en fullständig post över alla dina experiment och körningar. Du kan antingen använda portalen för att hitta och ladda ned utdata från experiment eller använda kod. För att komma åt dokumentationen från en historisk körning använder du Azure Machine Learning för att hitta ID:t för den körning som du är intresserad av. Med det ID:t kan du välja det specifika run med hjälp av Workspace och 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)

Du måste ändra strängen run_id i föregående kod till det specifika ID:t för din historiska körning. Kodfragmentet förutsätter att du har tilldelat ws till den relevanta Workspace med den normala from_config(). Experimentet av intresse hämtas direkt och sedan hittar Run koden intresse genom att matcha run.id värdet.

När du har ett Run objekt kan du ladda ned måtten och modellen.

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

Varje Run objekt innehåller StepRun objekt som innehåller information om den enskilda pipelinestegkörningen. run söks StepRun efter objektet för AutoMLStep. Måtten och modellen hämtas med hjälp av deras standardnamn, som är tillgängliga även om du inte skickar PipelineData objekt till parametern outputs för AutoMLStep.

Slutligen laddas de faktiska mätvärdena och modellen ned till din lokala dator, så som det diskuterades i avsnittet Granska pipelineresultat.

Relaterat innehåll

• Jupyter-notebook med regressionsmodell av NYC Taxi-data
• Konfigurera automatisk ML-träning utan kod för tabelldata
• Jupyter Notebooks som demonstrerar automatiserad maskininlärning
• MLOps: Modellhantering, distribution, stamträd och övervakning
• MLOpsPython GitHub-lagringsplats