Pijplijnen maken machine learning uitvoeren met Azure Machine Learning SDK

In dit artikel leert u hoe u pijplijnen kunt maken en uitvoeren machine learning behulp van de Azure Machine Learning SDK. Gebruik ML pijplijnen om een werkstroom te maken die verschillende ML samenwerkt. Publiceer die pijplijn vervolgens voor later gebruik of voor delen met anderen. Volg ML pijplijnen om te zien hoe uw model in de echte wereld presteert en om gegevensdrift te detecteren. ML pijplijnen zijn ideaal voor scenario's voor batchscores, met behulp van verschillende berekeningen, het hergebruiken van stappen in plaats van ze opnieuw uit te voeren en het delen van ML werkstromen met anderen.

Dit artikel is geen zelfstudie. Zie Zelfstudie: Een Azure Machine Learning-pijplijn bouwen voor batch scoren of Automatische ML gebruiken in een Azure Machine Learning-pijplijn in Python voor hulp bij het maken van uw eerste pijplijn.

Hoewel u een ander soort pijplijn, een Azure-pijplijn, kunt gebruiken voor CI/CD-automatisering van ML-taken, wordt dat type pijplijn niet opgeslagen in uw werkruimte. Vergelijk deze verschillende pijplijnen.

De ML pijplijnen die u maakt, zijn zichtbaar voor de leden van Azure Machine Learning werkruimte.

ML pijplijnen worden uitgevoerd op rekendoelen (zie Wat zijn rekendoelen in Azure Machine Learning). Pijplijnen kunnen gegevens lezen en schrijven naar en van ondersteunde Azure Storage locaties.

Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint. Probeer de gratis of betaalde versie van Azure Machine Learning.

Vereisten

• Maak een Azure Machine Learning werkruimte voor al uw pijplijnbronnen.

• Configureer uw ontwikkelomgeving om de Azure Machine Learning SDK te installeren of gebruik een Azure Machine Learning reken-exemplaar waarin de SDK al is geïnstalleerd.

Begin met het koppelen van uw werkruimte:

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

ws = Workspace.from_config()

Resources voor machine learning instellen

Maak de resources die nodig zijn voor het uitvoeren van ML pijplijn:

• Stel een gegevensstore in die wordt gebruikt voor toegang tot de gegevens die nodig zijn in de pijplijnstappen.

• Configureer een -object om te wijzen naar permanente gegevens die zich in een gegevensstore (of Dataset die toegankelijk zijn in) zijn. Configureer een OutputFileDatasetConfig object voor tijdelijke gegevens die worden doorgegeven tussen pijplijnstappen.

• Stel de rekendoelen in waarop uw pijplijnstappen worden uitgevoerd.

Een gegevensstore instellen

Een gegevensopslag slaat de gegevens op die de pijplijn moet openen. Elke werkruimte heeft een standaardgegevensstore. U kunt meer gegevensstores registreren.

Wanneer u uw werkruimte maakt, Azure Files en Azure Blob Storage gekoppeld aan de werkruimte. Er is een standaardgegevensopslag geregistreerd om verbinding te maken met de Azure Blob-opslag. Zie Beslissen wanneer u Azure Files, Azure Blobs of Azure Disks voor meer informatie.

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

Stappen verbruiken in het algemeen gegevens en produceren uitvoergegevens. Met een stap kunt u gegevens maken, zoals een model, een map met modelbestanden en afhankelijke bestanden, of tijdelijke gegevens. Deze gegevens zijn vervolgens beschikbaar voor andere stappen verder in de pijplijn. Zie de artikelen How to Access Data and How to Register Datasets (Toegang tot gegevens en Gegevenssets registreren) voor meer informatie over het verbinden van uw pijplijn met uw gegevens.

Gegevens configureren met Dataset - en OutputFileDatasetConfig -objecten

De voorkeursmethode voor het leveren van gegevens aan een pijplijn is een gegevenssetobject. Het Dataset -object wijst naar gegevens die zich in of toegankelijk zijn vanuit een gegevensstore of op een web-URL. De klasse is abstract, dus u maakt een instantie van een (die verwijst naar een of meer bestanden) of een die wordt gemaakt door van een of meer bestanden met gegevenskolommen met Dataset FileDataset TabularDataset scheidingstekens.

U maakt een Dataset met behulp van methoden zoals from_files of from_delimited_files.

from azureml.core import Dataset

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

Tussenliggende gegevens (of uitvoer van een stap) worden vertegenwoordigd door een OutputFileDatasetConfig-object. output_data1 wordt geproduceerd als de uitvoer van een stap. Deze gegevens kunnen eventueel worden geregistreerd als een gegevensset door aan te register_on_complete roepen. Als u een in één stap maakt en deze gebruikt als invoer voor een andere stap, wordt met die gegevensafhankelijkheid tussen de stappen een impliciete uitvoeringsorder OutputFileDatasetConfig in de pijplijn gemaakt.

OutputFileDatasetConfig -objecten retourneren een map en schrijven standaard uitvoer naar de standaardgegevensstore van de werkruimte.

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

Een rekendoel instellen

In Azure Machine Learning verwijst de term compute (of rekendoel ) naar de machines of clusters die de rekenstappen uitvoeren in uw machine learning pijplijn. Zie Rekendoelen voor modeltraining voor een volledige lijst met rekendoelen en Rekendoelen maken voor het maken en koppelen ervan aan uw werkruimte. Het proces voor het maken en of koppelen van een rekendoel is hetzelfde, ongeacht of u een model traint of een pijplijnstap uitvoeren. Nadat u het rekendoel hebt gemaakt en gekoppeld, gebruikt u ComputeTarget het -object in de pijplijnstap.

Azure Machine Learning berekenen

U kunt een rekenkracht Azure Machine Learning voor het uitvoeren van uw stappen. De code voor andere rekendoelen is vergelijkbaar, met iets andere parameters, afhankelijk van het type.

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

De omgeving van de trainingsrun configureren

De volgende stap is ervoor te zorgen dat de externe trainingsrun alle afhankelijkheden heeft die nodig zijn voor de trainingsstappen. Afhankelijkheden en de runtimecontext worden ingesteld door een -object te maken en te RunConfiguration configureren.

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)

In de bovenstaande code ziet u twee opties voor het verwerken van afhankelijkheden. Zoals u kunt zien, USE_CURATED_ENV = True is de configuratie gebaseerd op een gecureerde omgeving. Gecureerde omgevingen zijn vooraf gecureerd met algemene inter-afhankelijke bibliotheken en kunnen sneller online worden gebracht. Gecureerde omgevingen hebben vooraf samengestelde Docker-afbeeldingen in de Microsoft Container Registry. Zie gecureerde Azure Machine Learning voor meer informatie.

Het pad dat wordt gebruikt als u USE_CURATED_ENV False wijzigt in toont het patroon voor het expliciet instellen van uw afhankelijkheden. In dat scenario wordt een nieuwe aangepaste Docker-afbeelding gemaakt en geregistreerd in een Azure Container Registry binnen uw resourcegroep (zie Inleiding tot privé-Docker-containerregisters in Azure). Het bouwen en registreren van deze afbeelding kan enkele minuten duren.

De pijplijnstappen maken

Zodra u de rekenresource en de omgeving hebt gemaakt, bent u klaar om de stappen van uw pijplijn te definiëren. Er zijn veel ingebouwde stappen beschikbaar via de Azure Machine Learning SDK, zoals u kunt zien in de referentiedocumentatie voor het azureml.pipeline.steps pakket. De meest flexibele klasse is PythonScriptStep,waarmee een Python-script wordt uitgevoerd.

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
)

De bovenstaande code toont een typische eerste pijplijnstap. Uw code voor gegevensvoorbereiding staat in een submap (in dit voorbeeld "prepare.py" in de map "./dataprep.src" ). Als onderdeel van het proces voor het maken van de pijplijn wordt deze map ingepakt en geüpload naar de en wordt tijdens de stap het script uitgevoerd dat is opgegeven compute_target als de waarde voor script_name .

De arguments waarden geven de invoer en uitvoer van de stap op. In het bovenstaande voorbeeld zijn de basislijngegevens de my_dataset gegevensset. De bijbehorende gegevens worden gedownload naar de rekenresource omdat deze in de code wordt opgegeven als as_download() . Met het script prepare.py worden alle taken voor gegevenstransformatie uitgevoerd die geschikt zijn voor de taak en worden de gegevens uitgevoerd naar , van het type output_data1 OutputFileDatasetConfig . Zie Gegevens verplaatsen naar en tussen ML pijplijnstappen (Python) voor meer informatie. De stap wordt uitgevoerd op de computer die is gedefinieerd door compute_target met behulp van de configuratie aml_run_config .

Hergebruik van eerdere resultaten ( ) is essentieel bij het gebruik van pijplijnen in een samenwerkingsomgeving, omdat het elimineren van allow_reuse onnodige herhalingen flexibiliteit biedt. Hergebruik is het standaardgedrag wanneer de script_name, invoer en parameters van een stap hetzelfde blijven. Wanneer hergebruik is toegestaan, worden de resultaten van de vorige run onmiddellijk naar de volgende stap verzonden. Als allow_reuse is ingesteld op , wordt er altijd een nieuwe uitvoering gegenereerd voor deze stap tijdens het uitvoeren van False de pijplijn.

Het is mogelijk om een pijplijn te maken met één stap, maar bijna altijd kiest u ervoor om uw algehele proces in verschillende stappen op te splitsen. U kunt bijvoorbeeld stappen hebben voor gegevensvoorbereiding, training, modelvergelijking en implementatie. U kunt zich bijvoorbeeld voorstellen dat na de data_prep_step hierboven opgegeven, de volgende stap training kan zijn:

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
)

De bovenstaande code is vergelijkbaar met de code in de gegevensvoorbereidingsstap. De trainingscode staat in een map die is gescheiden van die van de gegevensvoorbereidingscode. De OutputFileDatasetConfig uitvoer van de gegevensvoorbereidingsstap wordt gebruikt als output_data1 invoer voor de trainingsstap. Er wordt OutputFileDatasetConfig een nieuw object gemaakt om de resultaten op te nemen voor een latere training_results vergelijkings- of implementatiestap.

Zie voor andere codevoorbeelden hoe u een pijplijn met twee stappen ML en hoe u gegevens terug schrijft naar gegevensstoresna voltooiing van de uitvoering.

Nadat u de stappen hebt bepaald, bouwt u de pijplijn met behulp van enkele of al deze stappen.

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

Een gegevensset gebruiken

Gegevenssets die zijn gemaakt op basis van Azure Blob Storage, Azure Files, Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2, Azure SQL Database en Azure Database for PostgreSQL kunnen worden gebruikt als invoer voor elke pijplijnstap. U kunt uitvoer schrijven naar een DataTransferStep, DatabricksStepof als u gegevens naar een specifiek gegevensstore wilt schrijven OutputFileDatasetConfig gebruiken.

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
)

Vervolgens haalt u de gegevensset in uw pijplijn op met behulp van Run.input_datasets woordenlijst.

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

De lijn Run.get_context() is de moeite waard om te markeren. Met deze functie wordt een opgehaald Run die de huidige experimentele run vertegenwoordigt. In het bovenstaande voorbeeld gebruiken we deze om een geregistreerde gegevensset op te halen. Een ander veelgebruikt gebruik van het object is het ophalen van zowel het experiment zelf als Run de werkruimte waarin het experiment zich bevindt:

# Within a PythonScriptStep

ws = Run.get_context().experiment.workspace

Zie Gegevens verplaatsen naar en tussen ML pijplijnstappen (Python) voormeer informatie, inclusief alternatieve manieren om gegevens door te geven en te openen.

Caching & gebruiken

Als u het gedrag van uw pijplijnen wilt optimaliseren en aanpassen, kunt u een aantal dingen doen met het opslaan in deaching en hergebruik. U kunt bijvoorbeeld het volgende kiezen:

• Schakel het standaard hergebruik van de uitvoer van de stapuitvoer uit door tijdens de allow_reuse=False stapdefinitie in te stellen. Hergebruik is essentieel bij het gebruik van pijplijnen in een samenwerkingsomgeving, omdat het elimineren van onnodige runs flexibiliteit biedt. U kunt er echter voor kiezen om niet opnieuw te gebruiken.
• Uitvoer geforceerd opnieuw maken voor alle stappen in een run met pipeline_run = exp.submit(pipeline, regenerate_outputs=True)

Standaard is voor stappen ingeschakeld en wordt de opgegeven in de allow_reuse source_directory stapdefinitie gehasht. Dus als het script voor een bepaalde stap hetzelfde blijft ( , invoer en de parameters), en er niets anders in de is gewijzigd, wordt de uitvoer van een vorige stap opnieuw gebruikt, wordt de taak niet verzonden naar de berekening en zijn de resultaten van de vorige run direct beschikbaar voor de volgende script_name source_directory stap.

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

De pijplijn indienen

Wanneer u de pijplijn indient, Azure Machine Learning de afhankelijkheden voor elke stap gecontroleerd en wordt een momentopname van de opgegeven bronmap geüpload. Als er geen bronmap is opgegeven, wordt de huidige lokale map geüpload. De momentopname wordt ook opgeslagen als onderdeel van het experiment in uw werkruimte.

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

Wanneer u een pijplijn voor het eerst Azure Machine Learning:

• Downloadt de projectmomentopname naar het rekendoel vanuit de Blob-opslag die is gekoppeld aan de werkruimte.

• Bouwt een Docker-afbeelding die overeenkomt met elke stap in de pijplijn.

• Downloadt de Docker-afbeelding voor elke stap naar het rekendoel vanuit het containerregister.

• Hiermee configureert u de toegang Dataset tot - en OutputFileDatasetConfig -objecten. Voor as_mount() de toegangsmodus wordt FUSE gebruikt om virtuele toegang te bieden. Als de mount niet wordt ondersteund of als de gebruiker toegang heeft opgegeven als , worden de gegevens in plaats daarvan as_upload() gekopieerd naar het rekendoel.

• Voert de stap uit in het rekendoel dat is opgegeven in de stapdefinitie.

• Maakt artefacten, zoals logboeken, stdout en stderr, metrische gegevens en uitvoer die zijn opgegeven door de stap. Deze artefacten worden vervolgens geüpload en bewaard in de standaardgegevensstore van de gebruiker.

Zie de naslaginformatie over experimentklassen voor meer informatie.

Pijplijnparameters gebruiken voor argumenten die worden gewijzigd tijdens de deferatie

Soms hebben de argumenten voor afzonderlijke stappen binnen een pijplijn betrekking op de ontwikkeling en trainingsperiode: dingen zoals trainingssnelheden en -tijd, of paden naar gegevens of configuratiebestanden. Wanneer een model wordt geïmplementeerd, moet u echter dynamisch de argumenten doorgeven waarop u de deferenteert (dat wil zeggen, de query die u het model hebt gebouwd om te beantwoorden). U moet deze typen argumenten pijplijnparameters maken. Als u dit in Python wilt doen, gebruikt u azureml.pipeline.core.PipelineParameter de klasse , zoals wordt weergegeven in het volgende codefragment:

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)

Hoe Python-omgevingen werken met pijplijnparameters

Zoals eerder besproken in Configure the training run's environment, environment state, and Python library dependencies are specified using an object (De omgevingstoestand en afhankelijkheden van de Python-bibliotheek configureren) worden opgegeven met behulp van een Environment -object. Over het algemeen kunt u een bestaande opgeven Environment door te verwijzen naar de naam en, optioneel, een versie:

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

Als u er echter voor kiest om objecten te gebruiken om variabelen dynamisch in te stellen tijdens runtime voor uw pijplijnstappen, kunt u deze techniek van het verwijzen naar een bestaande PipelineParameter niet Environment gebruiken. Als u in plaats daarvan objecten wilt PipelineParameter gebruiken, moet u het environment veld van de instellen op een RunConfiguration Environment -object. Het is uw verantwoordelijkheid om ervoor te zorgen dat een dergelijke afhankelijk is Environment van externe Python-pakketten.

Resultaten van een pijplijn weergeven

Bekijk de lijst met al uw pijplijnen en de details van hun run in de studio:

1. Meld u aan bij Azure Machine Learning Studio.

2. Bekijk uw werkruimte.

3. Selecteer aan de linkerkant Pijplijnen om al uw pijplijn-runs te zien.

4. Selecteer een specifieke pijplijn om de resultaten van de run te bekijken.

Git-tracering en -integratie

Wanneer u een trainingsrun start waarbij de bronmap een lokale Git-opslagplaats is, wordt informatie over de opslagplaats opgeslagen in de geschiedenis van de run. Zie Git-integratie voor meer informatie Azure Machine Learning.

Volgende stappen

• Als u uw pijplijn wilt delen met collega's of klanten, zie Machine learning pijplijnen publiceren
• Gebruik deze Jupyter-notebooks op GitHub om de machine learning verder te verkennen
• Zie de SDK-referentiehulp voor het pakket azureml-pipelines-core en het pakket azureml-pipelines-steps
• Zie de stappen voor tips over foutopsporing en het oplossen van problemen met pijplijnen =
• Informatie over het uitvoeren van notebooks vindt u in het artikel Use Jupyter notebooks to explore this service (Jupyter Notebooks gebruiken om deze service te verkennen).