Delen via

Machine Learning-pijplijnen maken en uitvoeren met behulp van onderdelen met de Azure Machine Learning CLI

VAN TOEPASSING OP: Azure CLI ml-extensie v2 (huidige)

In dit artikel leert u hoe u machine learning-pijplijnen maakt en uitvoert met behulp van Azure CLI en onderdelen. U kunt pijplijnen maken zonder onderdelen te gebruiken, maar onderdelen bieden flexibiliteit en maken hergebruik mogelijk. Azure Machine Learning-pijplijnen kunnen worden gedefinieerd in YAML en worden uitgevoerd vanuit de CLI, geschreven in Python of samengesteld in azure Machine Learning Studio Designer via een gebruikersinterface met slepen en neerzetten. Dit artikel is gericht op de CLI.

Vereisten

Voorgestelde prereading

Uw eerste pijplijn maken met onderdelen

Eerst maakt u een pijplijn met onderdelen met behulp van een voorbeeld. Dit geeft u een eerste indruk van hoe een pijplijn en onderdeel eruitzien in Azure Machine Learning.

Ga in de cli/jobs/pipelines-with-components/basics map van de azureml-examples opslagplaats naar de 3b_pipeline_with_data submap. Deze map bevat drie typen bestanden. Dit zijn de bestanden die u moet maken wanneer u uw eigen pijplijn bouwt.

  • pipeline.yml. Dit YAML-bestand definieert de machine learning-pijplijn. Hierin wordt beschreven hoe u een volledige machine learning-taak kunt opsplitsen in een werkstroom in meerdere stappen. Denk bijvoorbeeld aan de eenvoudige machine learning-taak voor het gebruik van historische gegevens om een verkoopprognosemodel te trainen. Mogelijk wilt u een sequentiële werkstroom bouwen die gegevensverwerking, modeltraining en modelevaluatiestappen bevat. Elke stap is een onderdeel dat een goed gedefinieerde interface heeft en onafhankelijk kan worden ontwikkeld, getest en geoptimaliseerd. De YAML-pijplijn definieert ook hoe de deelstappen verbinding maken met andere stappen in de pijplijn. De modeltrainingsstap genereert bijvoorbeeld een modelbestand en het modelbestand wordt doorgegeven aan een modelevaluatiestap.

  • component.yml. Deze YAML-bestanden definiëren de onderdelen. Ze bevatten de volgende informatie:

    • Metagegevens: Naam, weergavenaam, versie, beschrijving, type, enzovoort. De metagegevens helpen bij het beschrijven en beheren van het onderdeel.
    • Interface: Invoer en uitvoer. Een modeltrainingsonderdeel gebruikt bijvoorbeeld trainingsgegevens en het aantal tijdvakken als invoer en genereert een getraind modelbestand als uitvoer. Nadat de interface is gedefinieerd, kunnen verschillende teams het onderdeel onafhankelijk ontwikkelen en testen.
    • Opdracht, code en omgeving: de opdracht, code en omgeving om het onderdeel uit te voeren. De opdracht is de shell-opdracht om het onderdeel uit te voeren. De code verwijst meestal naar een broncodemap. De omgeving kan een Azure Machine Learning-omgeving zijn (gecureerd of door de klant gemaakt), een Docker-image of een conda-omgeving.

  • component_src. Dit zijn de broncodemappen voor specifieke onderdelen. Ze bevatten de broncode die in het onderdeel wordt uitgevoerd. U kunt uw voorkeurstaal gebruiken, waaronder Python, R en anderen. De code moet worden uitgevoerd met een shell-opdracht. De broncode kan een paar invoeropties van de shell-opdrachtregel gebruiken om te besturen hoe deze stap wordt uitgevoerd. Een trainingsstap kan bijvoorbeeld trainingsgegevens, leersnelheid en het aantal epochs gebruiken om het trainingsproces te controleren. Het argument van een shell-opdracht wordt gebruikt om invoer en uitvoer door te geven aan de code.

U maakt nu een pijplijn met behulp van het 3b_pipeline_with_data voorbeeld. Elk bestand wordt verder uitgelegd in de volgende secties.

Vermeld eerst uw beschikbare rekenresources met behulp van de volgende opdracht:

az ml compute list

Als u dit niet hebt, maakt u een cluster met de naam cpu-cluster door deze opdracht uit te voeren:

Notitie

Sla deze stap over om serverloze berekeningen te gebruiken.

az ml compute create -n cpu-cluster --type amlcompute --min-instances 0 --max-instances 10

Maak nu een pijplijntaak die is gedefinieerd in het pipeline.yml-bestand door de volgende opdracht uit te voeren. Naar het rekendoel wordt in het pipeline.yml-bestand verwezen als azureml:cpu-cluster. Als uw rekendoel een andere naam gebruikt, moet u dit bijwerken in het pipeline.yml bestand.

az ml job create --file pipeline.yml

U ontvangt een JSON-woordenlijst met informatie over de pijplijntaak, waaronder:

Toets Beschrijving
name De op GUID gebaseerde naam van de taak.
experiment_name De naam waaronder taken worden georganiseerd in studio.
services.Studio.endpoint Een URL voor het bewaken en controleren van de pijplijntaak.
status De status van de taak. Het zal op dit moment waarschijnlijk zijn Preparing .

Ga naar de services.Studio.endpoint URL om een visualisatie van de pijplijn te bekijken:

Schermopname van een visualisatie van de pijplijn.

Inzicht in de YAML van de pijplijndefinitie

U bekijkt nu de pijplijndefinitie in het bestand 3b_pipeline_with_data/pipeline.yml .

Notitie

Als u serverloze berekeningen wilt gebruiken, vervangt default_compute: azureml:cpu-clusterdefault_compute: azureml:serverless u door in dit bestand.

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

display_name: 3b_pipeline_with_data
description: Pipeline with 3 component jobs with data dependencies

settings:
  default_compute: azureml:cpu-cluster

outputs:
  final_pipeline_output:
    mode: rw_mount

jobs:
  component_a:
    type: command
    component: ./componentA.yml
    inputs:
      component_a_input: 
        type: uri_folder
        path: ./data

    outputs:
      component_a_output: 
        mode: rw_mount
  component_b:
    type: command
    component: ./componentB.yml
    inputs:
      component_b_input: ${{parent.jobs.component_a.outputs.component_a_output}}
    outputs:
      component_b_output: 
        mode: rw_mount
  component_c:
    type: command
    component: ./componentC.yml
    inputs:
      component_c_input: ${{parent.jobs.component_b.outputs.component_b_output}}
    outputs:
      component_c_output: ${{parent.outputs.final_pipeline_output}}
      #  mode: upload

In de volgende tabel worden de meest gebruikte velden van het YAML-schema van de pijplijn beschreven. Zie het volledige YAML-schema voor pijplijnen voor meer informatie.

Toets Beschrijving
type Vereist. Het taaktype. Het moet pipeline zijn voor pijplijntaken.
display_name De weergavenaam van de pijplijntaak in de gebruikersinterface van de Studio. Bewerkbaar in de gebruikersinterface van studio. Het hoeft niet uniek te zijn voor alle taken in de werkruimte.
jobs Vereist. Een woordenboek van de set individuele taken die moeten worden uitgevoerd als stappen in de pipeline. Deze taken worden beschouwd als onderliggende taken van de bovenliggende pijplijntaak. In de huidige release worden de ondersteunde taaktypen in de pijplijn command en sweep.
inputs Een woordenboek van invoer voor de pijplijnopdracht. De sleutel is een naam voor de invoer binnen de context van de taak en de waarde is de invoerwaarde. U kunt verwijzen naar deze pijplijninvoer door de invoer van een afzonderlijke staptaak in de pijplijn met behulp van de ${{ parent.inputs.<input_name> }} expressie.
outputs Een woordenlijst met uitvoerconfiguraties van de pijplijntaak. De sleutel is een naam voor de uitvoer in de context van de taak en de waarde is de uitvoerconfiguratie. U kunt naar deze pijplijnuitvoer verwijzen door gebruik te maken van de uitvoer van een afzonderlijke taakstap in de pijplijn met behulp van de ${{ parents.outputs.<output_name> }} expressie.

Het 3b_pipeline_with_data voorbeeld bevat een pijplijn met drie stappen.

  • De drie stappen worden gedefinieerd onder jobs. Alle drie de stappen zijn van het type command. De definitie van elke stap bevindt zich in een bijbehorend component*.yml bestand. U kunt de YAML-bestanden zien in de map 3b_pipeline_with_data. componentA.yml wordt beschreven in de volgende sectie.
  • Deze pijplijn heeft gegevensafhankelijkheid, wat gebruikelijk is in echte pijplijnen. Component A neemt gegevensinvoer uit een lokale map onder ./data (regel 18-21) en geeft de uitvoer door aan onderdeel B (regel 29). De uitvoer van onderdeel A kan worden verwezen als ${{parent.jobs.component_a.outputs.component_a_output}}.
  • default_compute definieert de standaard rekenkracht voor de pijplijn. Als een onderdeel onder jobs een andere rekenkracht definieert, worden onderdeelspecifieke instellingen gerespecteerd.

Schermopname van de pijplijn met gegevensvoorbeeld.

Gegevens lezen en schrijven in een pijplijn

Een veelvoorkomend scenario is het lezen en schrijven van gegevens in een pijplijn. In Azure Machine Learning gebruikt u hetzelfde schema voor het lezen en schrijven van gegevens voor alle typen taken (pijplijntaken, opdrachttaken en opruimen van taken). Hieronder volgen voorbeelden van het gebruik van gegevens in pijplijnen voor veelvoorkomende scenario's:

Inzicht in de YAML van de onderdeeldefinitie

Hier volgt het componentA.yml-bestand , een voorbeeld van YAML dat een onderdeel definieert:

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command

name: component_a
display_name: componentA
version: 1

inputs:
  component_a_input:
    type: uri_folder

outputs:
  component_a_output:
    type: uri_folder

code: ./componentA_src

environment: 
  image: python

command: >-
  python hello.py --componentA_input ${{inputs.component_a_input}} --componentA_output ${{outputs.component_a_output}}

In deze tabel worden de meestgebruikte velden van onderdeel YAML gedefinieerd. Zie het volledige YAML-schema voor onderdelen voor meer informatie.

Toets Beschrijving
name Vereist. De naam van het onderdeel. Deze moet uniek zijn in de Azure Machine Learning-werkruimte. Deze moet beginnen met een kleine letter. Kleine letters, cijfers en onderstrepingstekens (_) zijn toegestaan. De maximale lengte is 255 tekens.
display_name De weergavenaam van het onderdeel in de Studio-gebruikersinterface. Het hoeft niet uniek te zijn binnen de werkruimte.
command Vereist. De opdracht die moet worden uitgevoerd.
code Het lokale pad naar de broncodemap die moet worden geüpload en gebruikt voor de component.
environment Vereist. De omgeving die wordt gebruikt om het onderdeel uit te voeren.
inputs Een woordenlijst met onderdeelinvoer. De sleutel is een naam voor de invoer binnen de context van het onderdeel en de waarde is de definitie van de onderdeelinvoer. U kunt verwijzen naar invoer in de opdracht met behulp van de ${{ inputs.<input_name> }} expressie.
outputs Een woordenlijst met onderdeeluitvoer. De sleutel is een naam voor de uitvoer binnen de context van het onderdeel en de waarde is de definitie van de onderdeeluitvoer. U kunt verwijzen naar uitvoer in de opdracht met behulp van de ${{ outputs.<output_name> }} expressie.
is_deterministic Of het resultaat van de vorige taak opnieuw moet worden gebruikt als de invoer van het onderdeel niet verandert. De standaardwaarde is true. Deze instelling staat ook bekend als standaard hergebruik. Het algemene scenario waarin deze wordt ingesteld false , is het afdwingen van het opnieuw laden van gegevens uit cloudopslag of een URL.

In het voorbeeld in 3b_pipeline_with_data/componentA.yml heeft onderdeel A één gegevensinvoer en één gegevensuitvoer, die kan worden verbonden met andere stappen in de bovenliggende pijplijn. Alle bestanden in de code sectie in de component YAML worden geüpload naar Azure Machine Learning wanneer de pijplijntaak wordt verzonden. In dit voorbeeld worden bestanden onder ./componentA_src geüpload. (Regel 16 in componentA.yml.) U ziet de geüploade broncode in de gebruikersinterface van studio: dubbelklik op de componentA-stap in de grafiek en ga naar het tabblad Code , zoals wordt weergegeven in de volgende schermopname. U kunt zien dat het een hello-worldscript is dat eenvoudig afdrukt en de huidige datum en tijd naar het componentA_output pad schrijft. Het onderdeel neemt invoer en levert uitvoer via de opdrachtregel. Het wordt verwerkt in hello.py via argparse.

Schermopname van de pijplijn met gegevensvoorbeeld. Het toont onderdeel A.

Invoer en uitvoer

Invoer en uitvoer definiëren de interface van een onderdeel. Invoer en uitvoer kunnen letterlijke waarden zijn (van het type string, number, integerof boolean) of een object dat een invoerschema bevat.

Objectinvoer (van het type uri_file, uri_folder, mltable, mlflow_modelof custom_model) kan verbinding maken met andere stappen in de bovenliggende pijplijntaak om gegevens/modellen door te geven aan andere stappen. In de pijplijngrafiek wordt de invoer van het objecttype weergegeven als een verbindingspunt.

Letterlijke waarde-invoer (string, number, integer, boolean) zijn de parameters die u tijdens runtime aan het onderdeel kunt doorgeven. U kunt een standaardwaarde voor letterlijke invoer in het default veld toevoegen. Voor number en integer typen kunt u ook minimum- en maximumwaarden toevoegen met behulp van de min velden en max velden. Als de invoerwaarde kleiner is dan het minimum of meer dan het maximum, mislukt de pijplijn bij validatie. Validatie vindt plaats voordat u een pijplijntaak verzendt, wat tijd kan besparen. Validatie werkt voor de CLI, de Python SDK en de gebruikersinterface van Designer. In de volgende schermopname ziet u een validatievoorbeeld in de gebruikersinterface van Designer. Op dezelfde manier kunt u toegestane waarden definiëren in enum velden.

Schermopname van de invoer en uitvoer van het onderdeel lineaire regressiemodel trainen.

Als u invoer wilt toevoegen aan een onderdeel, moet u op drie plaatsen wijzigingen aanbrengen:

  • Het inputs veld in het YAML-onderdeel.
  • Het command veld in het YAML-onderdeel.
  • In onderdeelbroncode voor het afhandelen van de opdrachtregelinvoer.

Deze locaties worden gemarkeerd met groene vakken in de vorige schermafbeelding.

Zie Invoer en uitvoer beheren voor onderdelen en pijplijnen voor meer informatie over invoer en uitvoer.

Omgevingen

De omgeving is de omgeving waarin het onderdeel wordt uitgevoerd. Het kan een Azure Machine Learning-omgeving zijn (gecureerd of aangepast geregistreerd), een Docker-afbeelding of een conda-omgeving. Zie de volgende voorbeelden:

Een onderdeel registreren voor hergebruik en delen

Hoewel sommige onderdelen specifiek zijn voor een bepaalde pijplijn, komt het echte voordeel van onderdelen uit hergebruik en delen. U kunt een onderdeel registreren in uw Machine Learning-werkruimte om het beschikbaar te maken voor hergebruik. Geregistreerde onderdelen ondersteunen automatisch versiebeheer, zodat u het onderdeel kunt bijwerken, maar ervoor zorgen dat pijplijnen waarvoor een oudere versie is vereist, blijven werken.

Ga in de opslagplaats azureml-examples naar de cli/jobs/pipelines-with-components/basics/1b_e2e_registered_components map.

Gebruik de az ml component create opdracht om een onderdeel te registreren:

az ml component create --file train.yml
az ml component create --file score.yml
az ml component create --file eval.yml

Nadat deze opdrachten tot voltooiing zijn uitgevoerd, ziet u de onderdelen in studio, onder Assets>Components:

Schermopname van studio. De geregistreerde onderdelen worden weergegeven.

Selecteer een onderdeel. U ziet gedetailleerde informatie voor elke versie van het onderdeel.

Op het tabblad Details worden basisinformatie weergegeven, zoals de naam van het onderdeel, die deze heeft gemaakt en de versie. Er zijn bewerkbare velden voor tags en beschrijving. U kunt tags gebruiken om zoektrefwoorden toe te voegen. Het beschrijvingsveld ondersteunt Markdown-opmaak. U moet deze gebruiken om de functionaliteit en het basisgebruik van uw onderdeel te beschrijven.

Op het tabblad Taken ziet u de geschiedenis van alle taken die gebruikmaken van het onderdeel.

Geregistreerde onderdelen gebruiken in een YAML-bestand voor een pijplijntaak

U gaat nu 1b_e2e_registered_components gebruiken als voorbeeld voor het gebruik van een geregistreerd onderdeel in de YAML-pijplijn. Ga naar de 1b_e2e_registered_components map en open het pipeline.yml bestand. De sleutels en waarden in de inputs en velden zijn vergelijkbaar met de sleutels en outputs waarden die al zijn besproken. Het enige significante verschil is de waarde van het component veld in de jobs.<job_name>.component vermeldingen. De component waarde bevindt zich in het formulier azureml:<component_name>:<component_version>. De train-job definitie geeft bijvoorbeeld aan dat de nieuwste versie van het geregistreerde onderdeel my_train moet worden gebruikt:

type: command
component: azureml:my_train@latest
inputs:
  training_data: 
    type: uri_folder 
    path: ./data      
  max_epocs: ${{parent.inputs.pipeline_job_training_max_epocs}}
  learning_rate: ${{parent.inputs.pipeline_job_training_learning_rate}}
  learning_rate_schedule: ${{parent.inputs.pipeline_job_learning_rate_schedule}}
outputs:
  model_output: ${{parent.outputs.pipeline_job_trained_model}}
services:
  my_vscode:

Onderdelen beheren

U kunt de details van onderdelen controleren en onderdelen beheren met behulp van CLI v2. Gebruik az ml component -h om gedetailleerde instructies voor commando's met betrekking tot onderdelen te verkrijgen. De volgende tabel bevat alle beschikbare opdrachten. Zie meer voorbeelden in azure CLI-naslaginformatie.

Opdracht Beschrijving
az ml component create Maak een onderdeel.
az ml component list De onderdelen in een werkruimte weergeven.
az ml component show De details van een onderdeel weergeven.
az ml component update Een onderdeel bijwerken. Slechts enkele velden (beschrijving, display_name) ondersteunen update.
az ml component archive Een onderdeelcontainer archiveren.
az ml component restore Een gearchiveerd onderdeel herstellen.

Volgende stap