Skapa och köra maskininlärningspipelines med hjälp av komponenter med Azure Machine Learning CLI

GÄLLER FÖR: Azure CLI ml-tillägget v2 (aktuellt)

I den här artikeln får du lära dig hur du skapar och kör maskininlärningspipelines med hjälp av Azure CLI och komponenter. Du kan skapa pipelines utan att använda komponenter, men komponenter ger flexibilitet och möjliggör återanvändning. Azure Machine Learning-pipelines kan definieras i YAML och köras från CLI, redigeras i Python eller skapas i Azure Machine Learning Studio Designer via ett dra och släpp-användargränssnitt. Den här artikeln fokuserar på CLI.

Förutsättningar

• Ett Azure-abonnemang. Om du inte har något skapar du ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen av Azure Machine Learning.

• En Azure Machine Learning-arbetsyta.

• Azure CLI-tillägget för Machine Learning, installerat och konfigurerat.

• En klon av exempellagringsplatsen. Du kan använda dessa kommandon för att klona lagringsplatsen:

  git clone https://github.com/Azure/azureml-examples --depth 1
  cd azureml-examples/cli/jobs/pipelines-with-components/basics
  

Föreslagen förläsning

• Vad är Azure Machine Learning-pipelines?
• Vad är en Azure Machine Learning-komponent?

Skapa din första pipeline med komponenter

Först skapar du en pipeline med komponenter med hjälp av ett exempel. Om du gör det får du ett första intryck av hur en pipeline och komponent ser ut i Azure Machine Learning.

cli/jobs/pipelines-with-components/basics I katalogen på azureml-examples lagringsplatsen går du till underkatalogen3b_pipeline_with_data. Det finns tre typer av filer i den här katalogen. Det här är de filer som du behöver skapa när du skapar en egen pipeline.

• pipeline.yml. Den här YAML-filen definierar maskininlärningspipelinen. Den beskriver hur du delar upp en fullständig maskininlärningsuppgift i ett arbetsflöde med flera steg. Tänk till exempel på den enkla maskininlärningsuppgiften att använda historiska data för att träna en modell för försäljningsprognoser. Du kanske vill skapa ett sekventiellt arbetsflöde som innehåller databehandling, modellträning och modellutvärderingssteg. Varje steg är en komponent som har ett väldefinierat gränssnitt och som kan utvecklas, testas och optimeras oberoende av varandra. Yaml-pipelinen definierar också hur de underordnade stegen ansluter till andra steg i pipelinen. Till exempel genererar modellträningssteget en modellfil och modellfilen skickas till ett modellutvärderingssteg.

• component.yml. Dessa YAML-filer definierar komponenterna. De innehåller följande information:

  • Metadata: Namn, visningsnamn, version, beskrivning, typ och så vidare. Metadata hjälper till att beskriva och hantera komponenten.
  • Gränssnitt: Indata och utdata. En modellträningskomponent tar till exempel träningsdata och antalet epoker som indata och genererar en tränad modellfil som utdata. När gränssnittet har definierats kan olika team utveckla och testa komponenten oberoende av varandra.
  • Kommando, kod och miljö: Kommandot, koden och miljön för att köra komponenten. Kommandot är kommandot shell för att köra komponenten. Koden refererar vanligtvis till en källkodskatalog. Miljön kan vara en Azure Machine Learning-miljö (kuraterad eller kundskapad), Docker-avbildning eller conda-miljö.

• component_src. Det här är källkodskatalogerna för specifika komponenter. De innehåller källkoden som körs i komponenten. Du kan använda önskat språk, inklusive Python, R och andra. Koden måste köras av ett gränssnittskommando. Källkoden kan ta några indata från kommandoraden för att styra hur det här steget körs. Ett träningssteg kan till exempel ta träningsdata, inlärningshastighet och antalet epoker för att kontrollera träningsprocessen. Argumentet för ett gränssnittskommando används för att skicka indata och utdata till koden.

Nu ska du skapa en pipeline med hjälp av exemplet 3b_pipeline_with_data . Varje fil förklaras ytterligare i följande avsnitt.

Börja med att ange tillgängliga beräkningsresurser med hjälp av följande kommando:

az ml compute list

Om du inte har det skapar du ett kluster med namnet cpu-cluster genom att köra det här kommandot:

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

Skapa nu ett pipelinejobb som har definierats i filen pipeline.yml genom att köra följande kommando. Beräkningsmålet refereras i filen pipeline.yml som azureml:cpu-cluster. Om beräkningsmålet använder ett annat namn ska du komma ihåg att uppdatera det i filen pipeline.yml.

az ml job create --file pipeline.yml

Du bör få en JSON-ordlista med information om pipelinejobbet, inklusive:

Gå till services.Studio.endpoint URL:en för att se en visualisering av pipelinen:

Förstå pipelinedefinitionen YAML

Nu ska du titta på pipelinedefinitionen i filen 3b_pipeline_with_data/pipeline.yml .

$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

I följande tabell beskrivs de vanligaste fälten i YAML-schemat för pipeline. Mer information finns i yaml-schemat för hela pipelinen.

Det 3b_pipeline_with_data exemplet innehåller en pipeline i tre steg.

• De tre stegen definieras under jobs. Alla tre stegen är av typen command. Varje stegs definition finns i en motsvarande component*.yml fil. Du kan se YAML-komponentfilerna i katalogen 3b_pipeline_with_data . componentA.yml beskrivs i nästa avsnitt.
• Den här pipelinen har databeroende, vilket är vanligt i verkliga pipelines. Komponent A tar dataindata från en lokal mapp under ./data (raderna 18–21) och skickar utdata till komponent B (rad 29). Komponent A:s utdata kan refereras till som ${{parent.jobs.component_a.outputs.component_a_output}}.
• default_compute definierar standardberäkningen för pipelinen. Om en komponent under jobs definierar en annan beräkning respekteras komponentspecifika inställningar.

Läsa och skriva data i en pipeline

Ett vanligt scenario är att läsa och skriva data i en pipeline. I Azure Machine Learning använder du samma schema för att läsa och skriva data för alla typer av jobb (pipelinejobb, kommandojobb och svepjobb). Här följer exempel på hur du använder data i pipelines för vanliga scenarier:

• Lokala data
• Webbfil med en offentlig URL
• Azure Machine Learning-datalager och sökväg
• Azure Machine Learning-datatillgång

Förstå komponentdefinitionen YAML

Här är componentA.yml-filen , ett exempel på YAML som definierar en komponent:

$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}}

Den här tabellen definierar de vanligaste fälten i komponenten YAML. Mer information finns i YAML-schemat för den fullständiga komponenten.

I exemplet i 3b_pipeline_with_data/componentA.yml har komponent A en datainmatning och en datautdata, som kan anslutas till andra steg i den överordnade pipelinen. Alla filer i code avsnittet i komponenten YAML laddas upp till Azure Machine Learning när pipelinejobbet skickas. I det här exemplet laddas filer under ./componentA_src upp. (Rad 16 i componentA.yml.) Du kan se den uppladdade källkoden i studiogränssnittet: dubbelklicka på componentA-steget i diagrammet och gå till fliken Kod , som du ser på följande skärmbild. Du kan se att det är ett hello-world-skript som gör några enkla utskrifter och att det skriver aktuellt datum och tid till componentA_output sökvägen. Komponenten tar indata och ger utdata via kommandoraden. Det hanteras i hello.py via argparse.

Indata och utdata

Indata och utdata definierar gränssnittet för en komponent. Indata och utdata kan vara literalvärden (av typen string, number, integereller boolean) eller ett objekt som innehåller ett indataschema.

Objektindata (av typen uri_file, uri_folder, mltable, mlflow_modeleller custom_model) kan ansluta till andra steg i det överordnade pipelinejobbet för att skicka data/modeller till andra steg. I pipelinediagrammet återges objekttypens indata som en anslutningspunkt.

Literala värdeindata (string, number, integer, boolean) är de parametrar som du kan skicka till komponenten vid körning. Du kan lägga till ett standardvärde för literalindata i fältet default . För number och integer typer kan du också lägga till lägsta och högsta värden med hjälp av fälten min och max . Om indatavärdet är mindre än det lägsta eller högsta värdet misslyckas pipelinen vid valideringen. Verifieringen sker innan du skickar ett pipelinejobb, vilket kan spara tid. Valideringen fungerar för CLI, Python SDK och designergränssnittet. Följande skärmbild visar ett valideringsexempel i designergränssnittet. På samma sätt kan du definiera tillåtna värden i enum fält.

Om du vill lägga till indata i en komponent måste du göra ändringar på tre platser:

• Fältet inputs i YAML-komponenten.
• Fältet command i YAML-komponenten.
• I komponentens källkod för att hantera kommandoradsindata.

Dessa platser är markerade med gröna rutor i föregående skärmbild.

Mer information om indata och utdata finns i Hantera indata och utdata för komponenter och pipelines.

Miljöer

Miljön är den miljö där komponenten körs. Det kan vara en Azure Machine Learning-miljö (kuraterad, anpassad eller registrerad), en Docker-avbildning eller en conda-miljö. Se följande exempel:

• Registrerad Azure Machine Learning-miljötillgång. Miljön refereras i komponenten med azureml:<environment-name>:<environment-version> syntax.
• Offentlig docker-avbildning.
• Conda-fil. Conda-filen måste användas tillsammans med en basavbildning.

Registrera en komponent för återanvändning och delning

Även om vissa komponenter är specifika för en viss pipeline, kommer den verkliga fördelen med komponenter från återanvändning och delning. Du kan registrera en komponent på din Machine Learning-arbetsyta för att göra den tillgänglig för återanvändning. Registrerade komponenter stöder automatisk versionshantering så att du kan uppdatera komponenten, men se till att pipelines som kräver en äldre version fortsätter att fungera.

Gå till cli/jobs/pipelines-with-components/basics/1b_e2e_registered_components mappen i azureml-examples-arkivet.

Om du vill registrera en komponent använder du az ml component create kommandot:

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

När de här kommandona har körts kan du se komponenterna i studio under Tillgångar>komponenter:

Välj en komponent. Du ser detaljerad information för varje version av komponenten.

Fliken Information visar grundläggande information som komponentnamnet, vem som skapade det och versionen. Det finns redigerbara fält för Taggar och Beskrivning. Du kan använda taggar för att lägga till söknyckelord. Beskrivningsfältet stöder Markdown-formatering. Du bör använda den för att beskriva komponentens funktioner och grundläggande användning.

På fliken Jobb visas historiken för alla jobb som använder komponenten.

Använda registrerade komponenter i en YAML-fil för pipelinejobb

Nu ska du använda 1b_e2e_registered_components som ett exempel på hur du använder den registrerade komponenten i YAML-pipelinen. Gå till 1b_e2e_registered_components katalogen och öppna pipeline.yml filen. Nycklarna och värdena i fälten inputs och outputs liknar de som redan har diskuterats. Den enda signifikanta skillnaden är värdet för component fältet i posterna jobs.<job_name>.component . Värdet component finns i formuläret azureml:<component_name>:<component_version>. Definitionen train-job anger till exempel att den senaste versionen av den registrerade komponenten my_train ska användas:

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:

Hantera komponenter

Du kan kontrollera komponentinformation och hantera komponenter med hjälp av CLI v2. Använd az ml component -h för att få detaljerade instruktioner om komponentkommandon. I följande tabell visas alla tillgängliga kommandon. Se fler exempel i Azure CLI-referens.

Nästa steg

• Prova CLI v2-komponentexemplet