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

GÄLLER FÖR: Python SDK azure-ai-ml v2 (aktuell)

I den här artikeln får du lära dig hur du skapar en Azure Machine Learning-pipeline med hjälp av Azure Machine Learning Python SDK v2 för att slutföra en bildklassificeringsuppgift. Den här pipelinen innehåller tre steg: förbereda data, träna en bildklassificeringsmodell och poängsätta modellen. Machine Learning-pipelines optimerar arbetsflödet med hastighet, portabilitet och återanvändning, så att du kan fokusera på maskininlärning i stället för infrastruktur och automatisering.

Exempelpipeline tränar ett litet Keras konvolutionellt neuralt nätverk för att klassificera bilder i datasetet Fashion MNIST. Pipelinen ser ut så här:

I den här artikeln utför du följande uppgifter:

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

Förutsättningar

• En Azure Machine Learning-arbetsyta. Om du inte har någon slutför du självstudien Skapa resurser.
• En Python-miljö med Azure Machine Learning Python SDK v2 installerat. Installationsinstruktioner finns i Komma igång. Den här miljön är till för att definiera och kontrollera dina Azure Machine Learning-resurser och är skild från den miljö som används vid körning för träning.
• En klon av exempellagringsplatsen.

Om du vill köra träningsexemplen klonar du först exempellagringsplatsen och navigerar till sdk katalogen:

git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/sdk

Starta en interaktiv Python-session

Den här artikeln använder Azure Machine Learning Python SDK för att skapa och styra en Azure Machine Learning-pipeline. Artikeln förutsätter att du kör kodfragmenten interaktivt i antingen en Python REPL-miljö eller en Jupyter Notebook.

Den här artikeln baseras på notebook-filen image_classification_keras_minist_convnet.ipynb i sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet katalogen för Azure Machine Learning-exempellagringsplatsen .

Importera obligatoriska bibliotek

Importera alla Azure Machine Learning-bibliotek som du behöver för den här artikeln:

# import required libraries
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

from azure.ai.ml import MLClient
from azure.ai.ml.dsl import pipeline
from azure.ai.ml import load_component

Förbered indata för ditt pipelinejobb

Du måste förbereda indata för bildklassificeringspipelinen.

Fashion MNIST är en datamängd med modebilder uppdelade i 10 klasser. Varje bild är en 28 x 28 gråskalebild. Det finns 60 000 träningsbilder och 10 000 testbilder.

import urllib3
import shutil
import gzip
import os
from pathlib import Path
from azure.ai.ml import Input

base_url = "https://azureopendatastorage.blob.core.windows.net/mnist/"
base_dir = Path("mnist")
if not base_dir.exists():
    base_dir.mkdir(parents=True)

c = urllib3.PoolManager()
for target_file in [
    "train-images-idx3-ubyte.gz",
    "train-labels-idx1-ubyte.gz",
    "t10k-images-idx3-ubyte.gz",
    "t10k-labels-idx1-ubyte.gz",
]:
    if (base_dir / target_file[:-3]).exists():
        continue
    with c.request("GET", base_url + target_file, preload_content=False) as resp, open(
        base_dir / target_file, "wb"
    ) as out_file:
        shutil.copyfileobj(resp, out_file)
        resp.release_conn()
    with gzip.open(base_dir / target_file, "rb") as f_in, open(
        base_dir / target_file[:-3], "wb"
    ) as f_out:
        shutil.copyfileobj(f_in, f_out)
    os.unlink(base_dir / target_file)

mnist_ds = Input(path=base_dir.as_posix())

Genom att definiera en Inputskapar du en referens till datakällans plats. Data finns kvar på den befintliga platsen, så ingen extra lagringskostnad tillkommer.

Skapa komponenter för att skapa pipelinen

Bildklassificeringsuppgiften kan delas upp i tre steg: förbereda data, träna modellen och poängsätta modellen.

En Azure Machine Learning-komponent är en fristående kod som slutför ett steg i en maskininlärningspipeline. I den här artikeln skapar du tre komponenter för bildklassificeringsuppgiften:

• Förbereda data för träning och testning
• Träna ett neuralt nätverk för bildklassificering med hjälp av träningsdata
• Poängsätta modellen med hjälp av testdata

För varje komponent slutför du följande steg:

1. Förbereda Python-skriptet som innehåller körningslogik
2. Definiera komponentens gränssnitt
3. Lägg till andra metadata för komponenten, inklusive körningsmiljön och kommandot för att köra komponenten

I nästa avsnitt visas hur du skapar komponenterna på två sätt. För de två första komponenterna använder du en Python-funktion. För den tredje komponenten använder du YAML-definition.

Skapa dataförberedelsekomponenten

Den första komponenten i den här pipelinen konverterar komprimerade datafiler fashion_ds till två .csv filer, en för träning och den andra för bedömning. Du använder en Python-funktion för att definiera den här komponenten.

Om du följer exemplet i lagringsplatsen för Azure Machine Learning-exempel är källfilerna redan tillgängliga i prep mappen. Den här mappen innehåller två filer för att konstruera komponenten: prep_component.py, som definierar komponenten och conda.yaml, som definierar körningsmiljön för komponenten.

Definiera komponent med hjälp av en Python-funktion

command_component() Med funktionen som dekoratör kan du enkelt definiera komponentens gränssnitt, dess metadata och koden som ska köras från en Python-funktion. Varje dekorerad Python-funktion omvandlas till en enda statisk specifikation (YAML) som pipelinetjänsten kan bearbeta.

# Converts MNIST-formatted files at the passed-in input path to training data output path and test data output path
import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="prep_data",
    version="1",
    display_name="Prep Data",
    description="Convert data to CSV file, and split to training and test data",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def prepare_data_component(
    input_data: Input(type="uri_folder"),
    training_data: Output(type="uri_folder"),
    test_data: Output(type="uri_folder"),
):
    convert(
        os.path.join(input_data, "train-images-idx3-ubyte"),
        os.path.join(input_data, "train-labels-idx1-ubyte"),
        os.path.join(training_data, "mnist_train.csv"),
        60000,
    )
    convert(
        os.path.join(input_data, "t10k-images-idx3-ubyte"),
        os.path.join(input_data, "t10k-labels-idx1-ubyte"),
        os.path.join(test_data, "mnist_test.csv"),
        10000,
    )


def convert(imgf, labelf, outf, n):
    f = open(imgf, "rb")
    l = open(labelf, "rb")
    o = open(outf, "w")

    f.read(16)
    l.read(8)
    images = []

    for i in range(n):
        image = [ord(l.read(1))]
        for j in range(28 * 28):
            image.append(ord(f.read(1)))
        images.append(image)

    for image in images:
        o.write(",".join(str(pix) for pix in image) + "\n")
    f.close()
    o.close()
    l.close()

Koden ovan definierar en komponent med visningsnamn Prep Data med hjälp av dekoratören @command_component :

• name är komponentens unika identifierare

• version är den aktuella versionen av komponenten. En komponent kan ha flera versioner

• display_name är ett vänligt visningsnamn för komponenten för UI

• description beskriver uppgiften som komponenten kan slutföra

• environment anger körningsmiljön för komponenten med hjälp av en conda.yaml-fil

  Filen conda.yaml innehåller alla paket som används för komponenten:

  name: imagekeras_prep_conda_env
  channels:
    - defaults
  dependencies:
    - python=3.7.11
    - pip=20.0
    - pip:
      - mldesigner==0.1.0b4
  

• Funktionen prepare_data_component definierar en indata för input_data och två utdata för training_data och test_data

  • input_data är indatasökvägen
  • training_data och test_data är utdatasökvägar för träningsdata och testdata

• Komponenten konverterar data från input_data till en training_data .csv fil för träningsdata och en test_data .csv fil för testdata

I studiogränssnittet visas en komponent som:

• Ett block i en pipelinegraf
• input_data, training_dataoch test_data är portar för komponenten som ansluter till andra komponenter för dataströmning

Nu har du förberett alla källfiler för komponenten Prep Data .

Skapa modellträningskomponenten

I det här avsnittet skapar du en komponent för att träna bildklassificeringsmodellen med hjälp av en Python-funktion, som du gjorde med komponenten Prep Data .

Eftersom träningslogik är mer komplex placerar du träningskoden i en separat Python-fil.

Källfilerna för den här komponenten train finns i mappen i lagringsplatsen för Azure Machine Learning-exempel. Den här mappen innehåller tre filer för att konstruera komponenten:

• train.py innehåller logiken för att träna modellen
• train_component.py definierar komponentens gränssnitt och importerar funktionen från train.py
• conda.yaml definierar körningsmiljön för komponenten

Hämta ett skript som innehåller logiken

Filen train.py innehåller en vanlig Python-funktion som utför logiken för att träna ett Keras neuralt nätverk för bildklassificering. Information om hur du visar koden finns i filen train.py på GitHub.

Definiera komponenten med hjälp av en Python-funktion

När du har definierat träningsfunktionen kan du använda @command_component i Azure Machine Learning SDK v2 för att omsluta funktionen som en komponent för användning i Azure Machine Learning-pipelines:

import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="train_image_classification_keras",
    version="1",
    display_name="Train Image Classification Keras",
    description="train image classification with keras",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def keras_train_component(
    input_data: Input(type="uri_folder"),
    output_model: Output(type="uri_folder"),
    epochs=10,
):
    # avoid dependency issue, execution logic is in train() func in train.py file
    from train import train

    train(input_data, output_model, epochs)

Föregående kod definierar en komponent med visningsnamn Train Image Classification Keras med hjälp av @command_component.

Funktionen keras_train_component definierar:

• En indata, input_data, för källträningsdata
• En indata, epochs, som anger antalet epoker som ska användas under träningen
• En utdata, output_model, som anger utdatasökvägen för modellfilen

Standardvärdet epochs för är 10. Logiken för den här komponenten train() kommer från funktionen i train.py.

Träningsmodellkomponenten har en mer komplex konfiguration än förberedelsedatakomponenten. Ser conda.yaml ut så här:

name: imagekeras_train_conda_env
channels:
  - defaults
dependencies:
  - python=3.8
  - pip=20.2
  - pip:
    - mldesigner==0.1.0b12
    - azureml-mlflow==1.50.0
    - tensorflow==2.7.0
    - numpy==1.21.4
    - scikit-learn==1.0.1
    - pandas==1.3.4
    - matplotlib==3.2.2
    - protobuf==3.20.0

Nu har du förberett alla källfiler för komponenten Train Image Classification Keras .

Skapa modellbedömningskomponenten

I det här avsnittet skapar du en komponent för att poängsätta den tränade modellen med yaml-specifikationen och skriptet.

Om du följer exemplet i lagringsplatsen för Azure Machine Learning-exempel är källfilerna redan tillgängliga i score mappen. Den här mappen innehåller tre filer för att konstruera komponenten:

• score.py innehåller källkoden för komponenten
• score.yaml definierar gränssnittet och annan information om komponenten
• conda.yaml definierar körningsmiljön för komponenten

Hämta ett skript som innehåller logiken

Filen score.py innehåller en vanlig Python-funktion som utför modellbedömningslogik:

from tensorflow import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.utils import to_categorical
from keras.callbacks import Callback
from keras.models import load_model

import argparse
from pathlib import Path
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import mlflow


def get_file(f):

    f = Path(f)
    if f.is_file():
        return f
    else:
        files = list(f.iterdir())
        if len(files) == 1:
            return files[0]
        else:
            raise Exception("********This path contains more than one file*******")


def parse_args():
    # setup argparse
    parser = argparse.ArgumentParser()

    # add arguments
    parser.add_argument(
        "--input_data", type=str, help="path containing data for scoring"
    )
    parser.add_argument(
        "--input_model", type=str, default="./", help="input path for model"
    )

    parser.add_argument(
        "--output_result", type=str, default="./", help="output path for model"
    )

    # parse args
    args = parser.parse_args()

    # return args
    return args


def score(input_data, input_model, output_result):

    test_file = get_file(input_data)
    data_test = pd.read_csv(test_file, header=None)

    img_rows, img_cols = 28, 28
    input_shape = (img_rows, img_cols, 1)

    # Read test data
    X_test = np.array(data_test.iloc[:, 1:])
    y_test = to_categorical(np.array(data_test.iloc[:, 0]))
    X_test = (
        X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).astype("float32") / 255
    )

    # Load model
    files = [f for f in os.listdir(input_model) if f.endswith(".h5")]
    model = load_model(input_model + "/" + files[0])

    # Log metrics of the model
    eval = model.evaluate(X_test, y_test, verbose=0)

    mlflow.log_metric("Final test loss", eval[0])
    print("Test loss:", eval[0])

    mlflow.log_metric("Final test accuracy", eval[1])
    print("Test accuracy:", eval[1])

    # Score model using test data
    y_predict = model.predict(X_test)
    y_result = np.argmax(y_predict, axis=1)

    # Output result
    np.savetxt(output_result + "/predict_result.csv", y_result, delimiter=",")


def main(args):
    score(args.input_data, args.input_model, args.output_result)


# run script
if __name__ == "__main__":
    # parse args
    args = parse_args()

    # call main function
    main(args)

Koden i score.py tar tre kommandoradsargument: input_data, input_modeloch output_result. Programmet poängsätter indatamodellen med hjälp av indata och matar sedan ut resultatet.

Definiera komponenten med YAML

I det här avsnittet får du lära dig hur du skapar en komponentspecifikation i ett giltigt YAML-komponentspecifikationsformat. Den här filen anger följande information:

• Metadata: Namn, visningsnamn, version, typ och så vidare
• Gränssnitt: Indata och utdata
• Kommando, kod och miljö: Kommandot, koden och miljön som används för att köra komponenten

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

name: score_image_classification_keras
display_name: Score Image Classification Keras
inputs:
  input_data: 
    type: uri_folder
  input_model:
    type: uri_folder
outputs:
  output_result:
    type: uri_folder
code: ./
command: python score.py --input_data ${{inputs.input_data}} --input_model ${{inputs.input_model}} --output_result ${{outputs.output_result}}
environment:
  conda_file: ./conda.yaml
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04

• name är komponentens unika identifierare. Dess visningsnamn är Score Image Classification Keras
• Den här komponenten har två indata och en utdata
• Källkodssökvägen definieras i avsnittet code . När komponenten körs i molnet laddas alla filer från den sökvägen upp som ögonblicksbild av komponenten
• Avsnittet command anger kommandot som ska köras när komponenten körs
• Avsnittet environment innehåller en Docker-avbildning och en conda YAML-fil. Källfilen finns på exempellagringsplatsen

Nu har du alla källfiler för modellbedömningskomponenten.

Läs in komponenterna för att skapa en pipeline

Du kan importera komponenten för förberedelse av data och modellträningskomponenten, som definieras av Python-funktioner, precis som vanliga Python-funktioner.

Följande kod importerar prepare_data_component() funktionerna och keras_train_component() från prep_component.py filen i prep mappen respektive train_component filen i train mappen.

%load_ext autoreload
%autoreload 2

# load component function from component python file
from prep.prep_component import prepare_data_component
from train.train_component import keras_train_component

# print hint of components
help(prepare_data_component)
help(keras_train_component)

Du kan använda load_component() funktionen för att läsa in poängkomponenten, som definieras av YAML.

# load component function from yaml
keras_score_component = load_component(source="./score/score.yaml")

Läsa in registrerade komponenter från arbetsytan

Om du har komponenter som redan är registrerade på din arbetsyta kan du läsa in dem direkt med hjälp av ml_client.components.get() metoden . Den här metoden är användbar när du vill återanvända komponenter som tidigare har registrerats av dig eller delats av andra teammedlemmar.

# Load a registered component by name and version
registered_component = ml_client.components.get(
    name="my_registered_component", 
    version="1.0.0"
)

# Load the latest version of a registered component
latest_component = ml_client.components.get(
    name="my_registered_component"
)

Du kan visa en lista över alla tillgängliga komponenter på arbetsytan för att hitta de du behöver:

# List all components in the workspace
components = ml_client.components.list()
for component in components:
    print(f"Name: {component.name}, Version: {component.version}")

När du har läst in kan du använda registrerade komponenter i din pipeline precis som komponenter som lästs in från lokala filer eller Python-funktioner.

Skapa din pipeline

Du har skapat och läst in alla komponenter och indata för att skapa pipelinen. Nu kan du sätta samman dem i en pipeline.

# define a pipeline containing 3 nodes: Prepare data node, train node, and score node
@pipeline(
    default_compute=cpu_compute_target,
)
def image_classification_keras_minist_convnet(pipeline_input_data):
    """E2E image classification pipeline with keras using python sdk."""
    prepare_data_node = prepare_data_component(input_data=pipeline_input_data)

    train_node = keras_train_component(
        input_data=prepare_data_node.outputs.training_data
    )
    train_node.compute = gpu_compute_target

    score_node = keras_score_component(
        input_data=prepare_data_node.outputs.test_data,
        input_model=train_node.outputs.output_model,
    )


# create a pipeline
pipeline_job = image_classification_keras_minist_convnet(pipeline_input_data=mnist_ds)

Processen har en standardinställning för beräkning cpu_compute_target. Om du inte anger beräkning för en specifik nod körs den noden på standardberäkningen.

Pipelinen har indata på pipelinenivå, pipeline_input_data. Du kan tilldela ett värde till pipelineindata när du skickar ett pipelinejobb.

Pipelinen innehåller tre noder: prepare_data_node, train_nodeoch score_node:

• Den input_data av prepare_data_node använder värdet av pipeline_input_data
• input_data av train_node är training_data utdata av prepare_data_node
• input_data på score_node är test_data-utdata från prepare_data_node, och input_model är output_model av train_node
• Eftersom du train_node tränar en CNN-modell kan du ange dess beräkningsresurs som gpu_compute_target för att förbättra träningsprestandan.

Lämna in ditt pipelinejobb

Nu när du har byggt pipelinen kan du skicka jobbet till din arbetsyta. Om du vill skicka ett jobb måste du först ansluta till en arbetsyta.

Få åtkomst till din arbetsyta

Konfigurera autentiseringsuppgifter

Du använder DefaultAzureCredential för att få åtkomst till arbetsytan. DefaultAzureCredential ska kunna hantera de flesta autentiseringsscenarier i Azure SDK.

Om DefaultAzureCredential det inte fungerar för dig kan du se det här exemplet på konfiguration av autentiseringsuppgifter och identitetspaketet.

try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

Hämta åtkomst till en arbetsyta med beräkningsresurser

Skapa ett MLClient objekt för att hantera Azure Machine Learning-tjänster. Om du använder serverlös beräkning behöver du inte skapa dessa beräkningar.

# Get a handle to workspace
ml_client = MLClient.from_config(credential=credential)

# Retrieve an already attached Azure Machine Learning Compute.
cpu_compute_target = "cpu-cluster"
print(ml_client.compute.get(cpu_compute_target))
gpu_compute_target = "gpu-cluster"
print(ml_client.compute.get(gpu_compute_target))

Skicka pipelinejobbet till arbetsytan

Nu när du har koll på din arbetsyta kan du lämna in ditt pipeline-jobb:

pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="pipeline_samples"
)
pipeline_job

Föregående kod skickar det här pipelinejobbet för bildklassificering till ett experiment med namnet pipeline_samples. Experimentet skapas automatiskt om det inte finns. pipeline_input_data använder fashion_ds.

Anropet för att skicka experimentet slutförs snabbt och genererar utdata som liknar följande:

Du kan övervaka pipelinekörningen genom att välja länken. Eller så kan du vänta tills den har slutförts genom att köra den här koden:

# wait until the job completes
ml_client.jobs.stream(pipeline_job.name)

Kontrollera utdata och felsöka din pipeline i användargränssnittet

Du kan välja Link to Azure Machine Learning studio, som är jobbinformationssidan för din pipeline. Du ser pipelinediagrammet:

Du kan kontrollera loggarna och utdata för varje komponent genom att högerklicka på komponenten eller välja komponenten för att öppna dess informationsfönster. Mer information om hur du felsöker din pipeline i användargränssnittet finns i Använda Azure Machine Learning Studio för att felsöka pipelinefel.

(Valfritt) Registrera komponenter i arbetsytan

I föregående avsnitt skapade du en pipeline med tre komponenter för att slutföra en bildklassificeringsuppgift. Du kan också registrera komponenter till din arbetsyta så att de kan delas och återanvändas på arbetsytan. I följande exempel visas hur du registrerar komponenten för förberedelse av data:

try:
    # try get back the component
    prep = ml_client.components.get(name="prep_data", version="1")
except:
    # if not exists, register component using following code
    prep = ml_client.components.create_or_update(prepare_data_component)

# list all components registered in workspace
for c in ml_client.components.list():
    print(c)

Du kan använda ml_client.components.get() för att hämta en registrerad komponent efter namn och version. Du kan använda ml_client.components.create_or_update() för att registrera en komponent som tidigare lästes in från en Python-funktion eller YAML.

Nästa steg

• Fler exempel på hur du skapar pipelines med hjälp av SDK:t för maskininlärning finns i exempellagringsplatsen
• Information om hur du använder studiogränssnittet för att skicka och felsöka en pipeline finns i Skapa och köra maskininlärningspipelines med hjälp av komponenter med Azure Machine Learning Studio
• Information om hur du använder Azure Machine Learning CLI för att skapa komponenter och pipelines finns i Skapa och köra maskininlärningspipelines med hjälp av komponenter med Azure Machine Learning CLI
• Information om hur du distribuerar pipelines till produktion med batchslutpunkter finns i Distribuera pipelines med batchslutpunkter