Skapa och köra pipelines för maskininlärning med Azure Machine Learning SDK

I den här artikeln får du lära dig hur du skapar och kör pipelines för maskininlärning med hjälp av Azure Machine Learning SDK. Använd ML pipelines för att skapa ett arbetsflöde som sammanfogar olika ML faser. Publicera sedan pipelinen för senare åtkomst eller delning med andra. Spåra ML pipelines för att se hur din modell presterar i den verkliga världen och för att identifiera dataavdrift. ML pipelines är idealiska för scenarier med batchbedömning, med hjälp av olika beräkningar, återanvändning av steg i stället för att köra dem igen och dela ML arbetsflöden med andra.

Den här artikeln är inte en självstudie. Vägledning om hur du skapar din första pipeline finns i Självstudie: Skapa en Azure Machine Learning-pipeline för batchbedömning eller Använda automatiserad ML i en Azure Machine Learning-pipeline i Python.

Du kan använda en annan typ av pipeline som kallas en Azure-pipeline för CI/CD-automatisering av ML-uppgifter, men den typen av pipeline lagras inte på din arbetsyta. Jämför dessa olika pipelines.

De ML pipelines som du skapar är synliga för medlemmarna i din Azure Machine Learning arbetsyta.

ML pipelines körs på beräkningsmål (se Vad är beräkningsmål i Azure Machine Learning). Pipelines kan läsa och skriva data till och från Azure Storage platser.

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.

Krav

• Skapa en Azure Machine Learning för att innehålla alla dina pipelineresurser.

• Konfigurera utvecklingsmiljön för att installera Azure Machine Learning SDK eller använd en Azure Machine Learning-beräkningsinstans med SDK:n redan installerad.

Börja med att koppla din arbetsyta:

import azureml.core
from azureml.core import Workspace, Datastore

ws = Workspace.from_config()

Konfigurera maskininlärningsresurser

Skapa de resurser som krävs för att köra ML pipeline:

• Konfigurera ett datalager som används för att komma åt de data som behövs i pipelinestegen.

• Konfigurera ett Dataset objekt så att det pekar på beständiga data som finns i, eller som är tillgängliga i, ett datalager. Konfigurera ett OutputFileDatasetConfig -objekt för tillfälliga data som skickas mellan pipelinestegen.

• Konfigurera de beräkningsmål som pipelinestegen ska köras på.

Konfigurera ett datalager

Ett datalager lagrar data som pipelinen kan komma åt. Varje arbetsyta har ett standarddatalager. Du kan registrera fler datalager.

När du skapar din arbetsyta Azure Files och Azure Blob Storage till arbetsytan. Ett standarddatalager registreras för att ansluta till Azure Blob Storage. Mer information finns i Avgöra när du ska Azure Files, Azure Blobs eller Azure Disks.

# Default datastore 
def_data_store = ws.get_default_datastore()

# Get the blob storage associated with the workspace
def_blob_store = Datastore(ws, "workspaceblobstore")

# Get file storage associated with the workspace
def_file_store = Datastore(ws, "workspacefilestore")

Steg förbrukar vanligtvis data och producerar utdata. Ett steg kan skapa data, till exempel en modell, en katalog med modell och beroende filer eller tillfälliga data. Dessa data är sedan tillgängliga för andra steg senare i pipelinen. Mer information om hur du ansluter din pipeline till dina data finns i artiklarna How to Access Data (Så här kommer du åt data) och How to Register Datasets (Så här registrerar du datamängder).

Konfigurera data med Dataset - och OutputFileDatasetConfig -objekt

Det bästa sättet att tillhandahålla data till en pipeline är ett datamängdsobjekt. Objektet Dataset pekar på data som finns i eller är tillgängliga från ett datalager eller en webbadress. Klassen är abstrakt, så du skapar en instans av antingen en (som refererar till en eller flera filer) eller en som skapas av från en eller flera filer med Dataset FileDataset TabularDataset avgränsade datakolumner.

Du skapar en Dataset med metoder som from_files eller from_delimited_files.

from azureml.core import Dataset

my_dataset = Dataset.File.from_files([(def_blob_store, 'train-images/')])

Mellanliggande data (eller utdata från ett steg) representeras av ett OutputFileDatasetConfig-objekt. output_data1 skapas som utdata från ett steg. Du kan också registrera dessa data som en datauppsättning genom att anropa register_on_complete . Om du skapar en i ett steg och använder den som indata till ett annat steg, skapar databeroendet mellan steg en OutputFileDatasetConfig implicit körningsordning i pipelinen.

OutputFileDatasetConfig -objekt returnerar en katalog och skriver som standard utdata till arbetsytans standarddatalager.

from azureml.data import OutputFileDatasetConfig

output_data1 = OutputFileDatasetConfig(destination = (datastore, 'outputdataset/{run-id}'))
output_data_dataset = output_data1.register_on_complete(name = 'prepared_output_data')

Konfigurera ett beräkningsmål

I Azure Machine Learning avser termen beräkning (eller beräkningsmål) de datorer eller kluster som gör beräkningsstegen i din maskininlärningspipeline. Se beräkningsmål för modellträning för en fullständig lista över beräkningsmål och Skapa beräkningsmål för hur du skapar och kopplar dem till din arbetsyta. Processen för att skapa och eller koppla ett beräkningsmål är densamma oavsett om du tränar en modell eller kör ett pipelinesteg. När du har skapat och bifogat beräkningsmålet använder du ComputeTarget objektet i pipelinesteget.

Azure Machine Learning beräkning

Du kan skapa en Azure Machine Learning beräkning för att köra dina steg. Koden för andra beräkningsmål är liknande, med lite olika parametrar, beroende på typ.

from azureml.core.compute import ComputeTarget, AmlCompute

compute_name = "aml-compute"
vm_size = "STANDARD_NC6"
if compute_name in ws.compute_targets:
    compute_target = ws.compute_targets[compute_name]
    if compute_target and type(compute_target) is AmlCompute:
        print('Found compute target: ' + compute_name)
else:
    print('Creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size=vm_size,  # STANDARD_NC6 is GPU-enabled
                                                                min_nodes=0,
                                                                max_nodes=4)
    # create the compute target
    compute_target = ComputeTarget.create(
        ws, compute_name, provisioning_config)

    # Can poll for a minimum number of nodes and for a specific timeout.
    # If no min node count is provided it will use the scale settings for the cluster
    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=20)

    # For a more detailed view of current cluster status, use the 'status' property
    print(compute_target.status.serialize())

Konfigurera träningskörningens miljö

Nästa steg är att se till att fjärrträningskörningen har alla beroenden som krävs för träningsstegen. Beroenden och körningskontexten anges genom att skapa och konfigurera ett RunConfiguration -objekt.

from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core import Environment 

aml_run_config = RunConfiguration()
# `compute_target` as defined in "Azure Machine Learning compute" section above
aml_run_config.target = compute_target

USE_CURATED_ENV = True
if USE_CURATED_ENV :
    curated_environment = Environment.get(workspace=ws, name="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu")
    aml_run_config.environment = curated_environment
else:
    aml_run_config.environment.python.user_managed_dependencies = False
    
    # Add some packages relied on by data prep step
    aml_run_config.environment.python.conda_dependencies = CondaDependencies.create(
        conda_packages=['pandas','scikit-learn'], 
        pip_packages=['azureml-sdk', 'azureml-dataset-runtime[fuse,pandas]'], 
        pin_sdk_version=False)

Koden ovan visar två alternativ för att hantera beroenden. Som vi ser USE_CURATED_ENV = True baseras konfigurationen på en curated environment (hanterad miljö). Curated environments are "prebacked" with common inter-dependent libraries and can be faster to bring online. Curated Environments har fördefinierade Docker-avbildningar i Microsoft Container Registry. Mer information finns i Azure Machine Learning miljöer.

Sökvägen som du ändrar USE_CURATED_ENV till visar mönstret för att uttryckligen ange dina False beroenden. I det scenariot skapas och registreras en ny anpassad Docker-avbildning i en Azure Container Registry i resursgruppen (se Introduktion till privata Docker-containerregister i Azure). Det kan ta ganska många minuter att skapa och registrera den här avbildningen.

Skapa dina pipelinesteg

När du har skapat beräkningsresursen och miljön är du redo att definiera pipelinens steg. Det finns många inbyggda steg tillgängliga via Azure Machine Learning SDK, som du kan se i referensdokumentationen för azureml.pipeline.steps paketet. Den mest flexibla klassen är PythonScriptStep, som kör ett Python-skript.

from azureml.pipeline.steps import PythonScriptStep
dataprep_source_dir = "./dataprep_src"
entry_point = "prepare.py"
# `my_dataset` as defined above
ds_input = my_dataset.as_named_input('input1')

# `output_data1`, `compute_target`, `aml_run_config` as defined above
data_prep_step = PythonScriptStep(
    script_name=entry_point,
    source_directory=dataprep_source_dir,
    arguments=["--input", ds_input.as_download(), "--output", output_data1],
    compute_target=compute_target,
    runconfig=aml_run_config,
    allow_reuse=True
)

Koden ovan visar ett typiskt inledande pipelinesteg. Din kod för förberedelse av data finns i en -underkatalog (i det här "prepare.py" exemplet i katalogen "./dataprep.src" ). Som en del av processen för att skapa pipeline zippas den här katalogen och laddas upp till och steget kör skriptet som compute_target angetts som värde för script_name .

Värdena arguments anger indata och utdata för steget. I exemplet ovan är baslinjedata my_dataset datamängden. Motsvarande data laddas ned till beräkningsresursen eftersom koden anger den som as_download() . Skriptet utför prepare.py de datatransformeringsuppgifter som är lämpliga för den tillgängliga uppgiften och matar ut data till output_data1 , av typen OutputFileDatasetConfig . Mer information finns i Flytta data till och mellan ML pipelinesteg (Python). Steget körs på den dator som definieras av compute_target med hjälp av konfigurationen aml_run_config .

Återanvändning av tidigare resultat ( ) är viktigt när du använder pipelines i en samarbetsmiljö eftersom det är flexibelt allow_reuse att eliminera onödiga omkörningar. Återanvändning är standardbeteendet när script_name, indata och parametrar för ett steg förblir desamma. När återanvändning tillåts skickas resultat från den föregående körningen omedelbart till nästa steg. Om allow_reuse är inställt False på genereras alltid en ny körning för det här steget under pipelinekörningen.

Det är möjligt att skapa en pipeline med ett enda steg, men nästan alltid väljer du att dela upp den övergripande processen i flera steg. Du kan till exempel ha steg för förberedelse av data, träning, modelljämförelse och distribution. Man kan till exempel anta att nästa steg kan vara träning efter det data_prep_step som anges ovan:

train_source_dir = "./train_src"
train_entry_point = "train.py"

training_results = OutputFileDatasetConfig(name = "training_results",
    destination = def_blob_store)

    
train_step = PythonScriptStep(
    script_name=train_entry_point,
    source_directory=train_source_dir,
    arguments=["--prepped_data", output_data1.as_input(), "--training_results", training_results],
    compute_target=compute_target,
    runconfig=aml_run_config,
    allow_reuse=True
)

Koden ovan liknar koden i förberedelsesteget för data. Träningskoden finns i en annan katalog än den för dataförberedelsekoden. Utdata OutputFileDatasetConfig från dataförberedelsesteget output_data1 används som indata för träningssteget. Ett nytt OutputFileDatasetConfig -objekt training_results skapas för att innehålla resultatet för en senare jämförelse eller ett senare distributionssteg.

Andra kodexempel finns i hur du skapar en pipeline ML två steg och hur du skriver tillbaka data till datalager när körningen är klar.

När du har definierat stegen skapar du pipelinen med hjälp av några eller alla dessa steg.

# list of steps to run (`compare_step` definition not shown)
compare_models = [data_prep_step, train_step, compare_step]

from azureml.pipeline.core import Pipeline

# Build the pipeline
pipeline1 = Pipeline(workspace=ws, steps=[compare_models])

Använda en datauppsättning

Datauppsättningar som skapats från Azure Blob Storage, Azure Files, Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2, Azure SQL Database och Azure Database for PostgreSQL kan användas som indata för alla pipelinesteg. Du kan skriva utdata till en DataTransferStep, DatabricksStep,eller om du vill skriva data till ett specifikt datalager använder du OutputFileDatasetConfig.

dataset_consuming_step = PythonScriptStep(
    script_name="iris_train.py",
    inputs=[iris_tabular_dataset.as_named_input("iris_data")],
    compute_target=compute_target,
    source_directory=project_folder
)

Sedan hämtar du datauppsättningen i din pipeline med hjälp Run.input_datasets ordlistan.

# iris_train.py
from azureml.core import Run, Dataset

run_context = Run.get_context()
iris_dataset = run_context.input_datasets['iris_data']
dataframe = iris_dataset.to_pandas_dataframe()

Det är Run.get_context() värt att markera raden. Den här funktionen hämtar en som Run representerar den aktuella experimentella körningen. I exemplet ovan använder vi den för att hämta en registrerad datauppsättning. Ett annat vanligt Run användningsobjekt är att hämta både själva experimentet och arbetsytan där experimentet finns:

# Within a PythonScriptStep

ws = Run.get_context().experiment.workspace

Mer information, inklusive alternativa sätt att skicka och komma åt data, finns i Flytta data till och ML pipelinesteg (Python).

Cachelagring & återanvändning

Om du vill optimera och anpassa beteendet för dina pipelines kan du göra några saker kring cachelagring och återanvändning. Du kan till exempel välja att:

• Inaktivera standardåteranvänte av stegkörningens utdata genom att ange allow_reuse=False under stegdefinitionen. Återanvändning är viktigt när du använder pipelines i en samarbetsmiljö eftersom det är flexibelt att eliminera onödiga körningar. Du kan dock välja bort återanvändning.
• Tvinga återskapande av utdata för alla steg i en körning med pipeline_run = exp.submit(pipeline, regenerate_outputs=True)

Som standard är allow_reuse för steg aktiverat och det som anges i source_directory stegdefinitionen hash-kodas. Om skriptet för ett visst steg förblir detsamma ( , indata och parametrar) och inget annat i har ändrats återanvänds utdata från en tidigare stegkörning, jobbet skickas inte till beräkningen och resultaten från den föregående körningen blir omedelbart tillgängliga för nästa steg i script_name source_directory stället.

step = PythonScriptStep(name="Hello World",
                        script_name="hello_world.py",
                        compute_target=aml_compute,
                        source_directory=source_directory,
                        allow_reuse=False,
                        hash_paths=['hello_world.ipynb'])

Skicka pipelinen

När du skickar pipelinen kontrollerar Azure Machine Learning beroenden för varje steg och laddar upp en ögonblicksbild av källkatalogen som du har angett. Om ingen källkatalog anges laddas den aktuella lokala katalogen upp. Ögonblicksbilden lagras också som en del av experimentet på din arbetsyta.

from azureml.core import Experiment

# Submit the pipeline to be run
pipeline_run1 = Experiment(ws, 'Compare_Models_Exp').submit(pipeline1)
pipeline_run1.wait_for_completion()

Första gången du kör en pipeline Azure Machine Learning:

• Laddar ned projektögonblicksbild till beräkningsmålet från bloblagringen som är associerad med arbetsytan.

• Skapar en Docker-avbildning som motsvarar varje steg i pipelinen.

• Laddar ned Docker-avbildningen för varje steg till beräkningsmålet från containerregistret.

• Konfigurerar åtkomst till Dataset - och OutputFileDatasetConfig -objekt. För as_mount() åtkomstläge används FUSE för att ge virtuell åtkomst. Om montering inte stöds eller om användaren har angett åtkomst som as_upload() , kopieras data i stället till beräkningsmålet.

• Kör steget i beräkningsmålet som anges i stegdefinitionen.

• Skapar artefakter, till exempel loggar, stdout och stderr, mått och utdata som anges i steget. Dessa artefakter laddas sedan upp och sparas i användarens standarddatalager.

Mer information finns i experimentklassreferensen.

Använda pipelineparametrar för argument som ändras vid inferenstiden

Ibland relaterar argumenten till enskilda steg i en pipeline till utvecklings- och träningsperioden: saker som träningsfrekvens och övning eller sökvägar till data eller konfigurationsfiler. När en modell distribueras bör du dock dynamiskt skicka argumenten som du vill dra slutsatser om (det vill säga frågan som du skapade modellen för att svara på!). Du bör göra dessa typer av argument till pipelineparametrar. Om du vill göra detta i Python använder azureml.pipeline.core.PipelineParameter du klassen , som du ser i följande kodfragment:

from azureml.pipeline.core import PipelineParameter

pipeline_param = PipelineParameter(name="pipeline_arg", default_value="default_val")
train_step = PythonScriptStep(script_name="train.py",
                            arguments=["--param1", pipeline_param],
                            target=compute_target,
                            source_directory=project_folder)

Så här fungerar Python-miljöer med pipelineparametrar

Som vi nämnt tidigare i Konfigurera träningskörningens miljöanges miljötillstånd och Python-biblioteksberoenden med hjälp av ett Environment -objekt. I allmänhet kan du ange en befintlig Environment genom att referera till dess namn och, om du vill, en version:

aml_run_config = RunConfiguration()
aml_run_config.environment.name = 'MyEnvironment'
aml_run_config.environment.version = '1.0'

Men om du väljer att använda objekt för att dynamiskt ange variabler vid körning för dina pipelinesteg kan du inte använda den här metoden för att referera till PipelineParameter en befintlig Environment . Om du vill använda objekt PipelineParameter måste du i stället ange fältet för till ett environment RunConfiguration Environment -objekt. Det är ditt ansvar att se till att sådana Environment har sina beroenden på externa Python-paket korrekt inställda.

Visa resultat för en pipeline

Se listan över alla dina pipelines och deras körningsinformation i Studio:

1. Logga in på Azure Machine Learning studio.

2. Visa din arbetsyta.

3. Till vänster väljer du Pipelines för att se alla dina pipelinekörningar.

4. Välj en specifik pipeline för att se körningsresultaten.

Git-spårning och -integrering

När du startar en träningskörning där källkatalogen är en lokal Git-lagringsplats lagras information om lagringsplatsen i körningshistoriken. Mer information finns i Git-integrering för Azure Machine Learning.

Nästa steg

• Information om hur du delar din pipeline med kollegor eller kunder finns i Publicera pipelines för maskininlärning
• Använd dessa Jupyter Notebooks på GitHub utforska maskininlärningspipelines ytterligare
• Se SDK-referenshjälpen för paketet azureml-pipelines-core och paketet azureml-pipelines-steps
• Se instruktioner för tips om felsökning av pipelines=
• Lär dig att köra notebook-filer genom att följa artikeln Använda Jupyter-notebooks till att utforska tjänsten.