Tworzenie i uruchamianie potoków uczenia maszynowego przy użyciu składników za pomocą zestawu Azure Machine Learning SDK w wersji 2

DOTYCZY: Zestaw PYTHON SDK azure-ai-ml w wersji 2 (bieżąca)

Z tego artykułu dowiesz się, jak utworzyć potok usługi Azure Machine Learning przy użyciu zestawu SDK języka Python w wersji 2, aby ukończyć zadanie klasyfikacji obrazów zawierające trzy kroki: przygotowywanie danych, trenowanie modelu klasyfikacji obrazów i ocenianie modelu. Potoki uczenia maszynowego optymalizują przepływ pracy z szybkością, przenośnością i ponownym użyciem, dzięki czemu można skupić się na uczeniu maszynowym zamiast infrastruktury i automatyzacji.

W tym przykładzie wytrenuje małą sieć neuronową Keras w celu klasyfikowania obrazów w zestawie danych Fashion MNIST . Potok wygląda następująco.

W tym artykule wykonasz następujące zadania:

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto. Wypróbuj bezpłatną lub płatną wersję usługi Azure Machine Learning już dziś.

Wymagania wstępne

• Obszar roboczy usługi Azure Machine Learning — jeśli go nie masz, ukończ samouczek Tworzenie zasobów.

• Środowisko języka Python, w którym zainstalowano zestaw SDK języka Python usługi Azure Machine Learning w wersji 2 — instrukcje instalacji — zapoznaj się z sekcją wprowadzenie. To środowisko służy do definiowania i kontrolowania zasobów usługi Azure Machine Learning i jest oddzielone od środowiska używanego w czasie wykonywania trenowania.

• Klonowanie repozytorium przykładów

  Aby uruchomić przykłady trenowania, najpierw sklonuj repozytorium przykładów i przejdź do sdk katalogu:

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

Uruchamianie interakcyjnej sesji języka Python

W tym artykule użyto zestawu SDK języka Python dla usługi Azure Machine Learning do tworzenia i kontrolowania potoku usługi Azure Machine Learning. W tym artykule założono, że będziesz uruchamiać fragmenty kodu interaktywnie w środowisku REPL języka Python lub notesie Jupyter.

Ten artykuł jest oparty na notesie image_classification_keras_minist_convnet.ipynb znajdującym się w sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet katalogu repozytorium Przykłady usługi Azure Machine Learning.

Importowanie wymaganych bibliotek

Zaimportuj wszystkie wymagane biblioteki usługi Azure Machine Learning, które będą potrzebne w tym artykule:

# 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

Przygotowywanie danych wejściowych do zadania potoku

Musisz przygotować dane wejściowe dla tego potoku klasyfikacji obrazów.

Fashion-MNIST to zestaw danych obrazów mody podzielonych na 10 klas. Każdy obraz jest obrazem o skali szarości 28x28 i 60 000 treningów i 10 000 obrazów testowych. Jako problem z klasyfikacją obrazów moda-MNIST jest trudniejsza niż klasyczna baza danych cyfr odręcznych MNIST. Jest on dystrybuowany w tej samej skompresowanej postaci binarnej co oryginalna baza danych cyfr odręcznych.

Zaimportuj wszystkie wymagane biblioteki usługi Azure Machine Learning.

Definiując element Input, należy utworzyć odwołanie do lokalizacji źródła danych. Dane pozostają w istniejącej lokalizacji, więc nie są naliczane żadne dodatkowe koszty magazynowania.

Tworzenie składników na potrzeby potoku kompilacji

Zadanie klasyfikacji obrazów można podzielić na trzy kroki: przygotowywanie danych, trenowanie modelu i generowanie wyników.

Składnik usługi Azure Machine Learning to samodzielny fragment kodu, który wykonuje jeden krok w potoku uczenia maszynowego. W tym artykule utworzysz trzy składniki zadania klasyfikacji obrazów:

• Przygotowywanie danych do trenowania i testowania
• Trenowanie sieci neuronowej na potrzeby klasyfikacji obrazów przy użyciu danych treningowych
• Ocenianie modelu przy użyciu danych testowych

Dla każdego składnika należy przygotować następujące elementy:

1. Przygotowywanie skryptu języka Python zawierającego logikę wykonywania

2. Definiowanie interfejsu składnika

3. Dodaj inne metadane składnika, w tym środowisko czasu wykonywania, polecenie, aby uruchomić składnik itd.

W następnej sekcji zostaną wyświetlone składniki tworzenia na dwa różne sposoby: pierwsze dwa składniki korzystające z funkcji języka Python i trzeci składnik przy użyciu definicji YAML.

Tworzenie składnika przygotowywania danych

Pierwszy składnik w tym potoku przekonwertuje skompresowane pliki fashion_ds danych na dwa pliki CSV, jeden na potrzeby trenowania, a drugi do oceniania. Użyjesz funkcji języka Python do zdefiniowania tego składnika.

Jeśli korzystasz z przykładu w repozytorium przykładów usługi Azure Machine Learning, pliki źródłowe są już dostępne w prep/ folderze. Ten folder zawiera dwa pliki do konstruowania składnika: prep_component.py, który definiuje składnik i conda.yaml, który definiuje środowisko czasu wykonywania składnika.

Definiowanie składnika przy użyciu funkcji języka Python

Korzystając z command_component() funkcji jako dekoratora, można łatwo zdefiniować interfejs, metadane i kod składnika do wykonania z funkcji języka Python. Każda ozdobiona funkcja języka Python zostanie przekształcona w pojedynczą specyfikację statyczną (YAML), którą może przetworzyć usługa potoku.

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

Powyższy kod definiuje składnik o nazwie Prep Data wyświetlanej przy użyciu @command_component dekoratora:

• name jest unikatowym identyfikatorem składnika.

• version jest bieżącą wersją składnika. Składnik może mieć wiele wersji.

• display_name to przyjazna nazwa wyświetlana składnika w interfejsie użytkownika, który nie jest unikatowy.

• description zazwyczaj opisuje, jakie zadanie może wykonać ten składnik.

• environment określa środowisko uruchomieniowe dla tego składnika. Środowisko tego składnika określa obraz platformy Docker i odwołuje się do conda.yaml pliku.

  Plik conda.yaml zawiera wszystkie pakiety używane dla składnika w następujący sposób:

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

• Funkcja prepare_data_component definiuje jedno dane wejściowe dla input_data i dwa dane wyjściowe dla training_data i test_data. input_data to ścieżka danych wejściowych. training_data ścieżki test_data danych wyjściowych dla danych treningowych i danych testowych.

• Ten składnik konwertuje dane z input_data pliku CSV na dane szkoleniowe i training_data plik csv danych testowych na test_data.

Poniżej przedstawiono wygląd składnika w interfejsie użytkownika programu Studio.

• Składnik jest blokiem na grafie potoku.
• training_data Element input_datai test_data to porty składnika, który łączy się z innymi składnikami na potrzeby przesyłania strumieniowego danych.

Teraz przygotowano wszystkie pliki źródłowe dla Prep Data składnika.

Tworzenie składnika train-model

W tej sekcji utworzysz składnik do trenowania modelu klasyfikacji obrazów w funkcji języka Python, takiej jak Prep Data składnik.

Różnica polega na tym, że ponieważ logika trenowania jest bardziej skomplikowana, można umieścić oryginalny kod szkoleniowy w osobnym pliku języka Python.

Pliki źródłowe tego składnika znajdują się train/ w folderze w repozytorium przykładów usługi Azure Machine Learning. Ten folder zawiera trzy pliki do skonstruowania składnika:

• train.py: zawiera rzeczywistą logikę trenowania modelu.
• train_component.py: definiuje interfejs składnika i importuje funkcję w pliku train.py.
• conda.yaml: definiuje środowisko uruchomieniowe składnika.

Pobieranie skryptu zawierającego logikę wykonywania

Plik train.py zawiera normalną funkcję języka Python, która wykonuje logikę modelu trenowania w celu wytrenowania sieci neuronowej Keras na potrzeby klasyfikacji obrazów. Aby wyświetlić kod, zobacz plik train.py w witrynie GitHub.

Definiowanie składnika przy użyciu funkcji języka Python

Po pomyślnym zdefiniowaniu funkcji trenowania można użyć @command_component zestawu SDK usługi Azure Machine Learning w wersji 2 do opakowania funkcji jako składnika, który może być używany w potokach usługi Azure Machine Learning.

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)

Powyższy kod definiuje składnik o nazwie Train Image Classification Keras wyświetlanej przy użyciu polecenia @command_component:

• Funkcja keras_train_component definiuje jedno dane wejściowe input_data , z których pochodzą dane treningowe, jedno wejście epochs określające epoki podczas trenowania, a jedno dane wyjściowe, z których wynika output_model plik modelu. Wartość domyślna to epochs 10. Logika wykonywania tego składnika pochodzi z train() funkcji powyżej train.py .

Składnik train-model ma nieco bardziej złożoną konfigurację niż składnik prep-data. Element conda.yaml jest podobny do następującego:

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

Teraz przygotowano wszystkie pliki źródłowe dla Train Image Classification Keras składnika.

Tworzenie składnika score-model

W tej sekcji, poza poprzednimi składnikami, utworzysz składnik do oceniania wytrenowanego modelu za pomocą specyfikacji i skryptu Yaml.

Jeśli korzystasz z przykładu w repozytorium przykładów usługi Azure Machine Learning, pliki źródłowe są już dostępne w score/ folderze. Ten folder zawiera trzy pliki do skonstruowania składnika:

• score.py: zawiera kod źródłowy składnika.
• score.yaml: definiuje interfejs i inne szczegóły składnika.
• conda.yaml: definiuje środowisko uruchomieniowe składnika.

Pobieranie skryptu zawierającego logikę wykonywania

Plik score.py zawiera normalną funkcję języka Python, która wykonuje logikę modelu trenowania.

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)

Kod w score.py przyjmuje trzy argumenty wiersza polecenia: input_data, input_model i output_result. Program ocenia model wejściowy przy użyciu danych wejściowych, a następnie generuje wynik oceniania.

Definiowanie składnika za pomocą języka Yaml

W tej sekcji dowiesz się, jak utworzyć specyfikację składnika w prawidłowym formacie specyfikacji składnika YAML. Ten plik określa następujące informacje:

• Metadane: nazwa, display_name, wersja, typ itd.
• Interfejs: dane wejściowe i wyjściowe
• Polecenie, kod i środowisko: polecenie, kod i środowisko używane do uruchamiania składnika

$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 jest unikatowym identyfikatorem składnika. Jego nazwa wyświetlana to Score Image Classification Keras.
• Ten składnik ma dwa dane wejściowe i jedno dane wyjściowe.
• Ścieżka kodu źródłowego jest zdefiniowana w code sekcji i po uruchomieniu składnika w chmurze wszystkie pliki z tej ścieżki zostaną przekazane jako migawka tego składnika.
• Sekcja command określa polecenie do wykonania podczas uruchamiania tego składnika.
• Sekcja environment zawiera obraz platformy Docker i plik yaml conda. Plik źródłowy znajduje się w przykładowym repozytorium.

Teraz masz wszystkie pliki źródłowe dla składnika score-model.

Ładowanie składników do potoku kompilacji

W przypadku składnika prep-data i składnika train-model zdefiniowanego przez funkcję języka Python można zaimportować składniki tak samo jak normalne funkcje języka Python.

W poniższym kodzie importujesz prepare_data_component() i keras_train_component() działasz z prep_component.py pliku w prep folderze i train_component w folderze w train folderze odpowiednio w folderze.

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

W przypadku składnika score zdefiniowanego przez yaml można użyć load_component() funkcji do załadowania.

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

Tworzenie potoku

Po utworzeniu i załadowaniu wszystkich składników i danych wejściowych do skompilowania potoku. Możesz utworzyć je w potoku:

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

Potok ma domyślne środowisko obliczeniowe cpu_compute_target, co oznacza, że jeśli nie określisz obliczeń dla określonego węzła, ten węzeł będzie uruchamiany w domyślnym środowisku obliczeniowym.

Potok ma dane wejściowe pipeline_input_datana poziomie potoku. Wartość można przypisać do danych wejściowych potoku podczas przesyłania zadania potoku.

Potok zawiera trzy węzły, prepare_data_node, train_node i score_node.

• Wartość input_data parametru prepare_data_node używa wartości pipeline_input_data.

• train_node Wartość input_data jest pochodzi z training_data danych wyjściowych prepare_data_node.

• Wartość input_data score_node pochodzi z test_data danych wyjściowych prepare_data_node, a element input_model pochodzi z output_model train_node.

• Ponieważ train_node wytrenuje model CNN, możesz określić jego obliczenia jako gpu_compute_target, co może poprawić wydajność trenowania.

Przesyłanie zadania potoku

Po utworzeniu potoku możesz przesłać go do obszaru roboczego. Aby przesłać zadanie, musisz najpierw połączyć się z obszarem roboczym.

Uzyskiwanie dostępu do obszaru roboczego

Konfigurowanie poświadczeń

Użyjemy DefaultAzureCredential polecenia , aby uzyskać dostęp do obszaru roboczego. DefaultAzureCredential powinna obsługiwać większość scenariuszy uwierzytelniania zestawu Azure SDK.

Dokumentacja dotycząca dodatkowych dostępnych poświadczeń, jeśli nie zadziała: skonfiguruj przykład poświadczeń, dokumentację referencyjną azure-identity.

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

Uzyskiwanie dojścia do obszaru roboczego za pomocą obliczeń

Utwórz MLClient obiekt do zarządzania usługami Azure Machine Learning. Jeśli używasz bezserwerowych obliczeń , nie ma potrzeby tworzenia tych obliczeń.

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

Przesyłanie zadania potoku do obszaru roboczego

Teraz masz dojście do obszaru roboczego, możesz przesłać zadanie potoku.

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

Powyższy kod przesyła to zadanie potoku klasyfikacji obrazów do eksperymentu o nazwie pipeline_samples. Spowoduje to automatyczne utworzenie eksperymentu, jeśli nie istnieje. Używa metody pipeline_input_data fashion_ds.

Wywołanie metody w celu pipeline_jobwygenerowania danych wyjściowych podobnych do:

Wywołanie metody submit Experiment do wykonania jest szybkie i generuje dane wyjściowe podobne do następujących:

Uruchomienie potoku można monitorować, otwierając link lub blokując je do momentu jego zakończenia, uruchamiając polecenie:

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

Wyewidencjonowanie danych wyjściowych i debugowanie potoku w interfejsie użytkownika

Możesz otworzyć Link to Azure Machine Learning studiostronę szczegółów zadania potoku. Zobaczysz wykres potoku, jak pokazano poniżej.

Możesz sprawdzić dzienniki i dane wyjściowe każdego składnika, klikając go prawym przyciskiem myszy lub wybierając składnik, aby otworzyć okienko szczegółów. Aby dowiedzieć się więcej na temat debugowania potoku w interfejsie użytkownika, zobacz Jak używać błędu potoku debugowania.

(Opcjonalnie) Rejestrowanie składników w obszarze roboczym

W poprzedniej sekcji utworzono potok przy użyciu trzech składników do ukończenia zadania klasyfikacji obrazów przez E2E. Możesz również zarejestrować składniki w obszarze roboczym, aby można je było udostępniać i ponownie udostępniać w obszarze roboczym. Poniżej przedstawiono przykład rejestrowania składnika prep-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)

Za pomocą programu ml_client.components.get()można uzyskać zarejestrowany składnik według nazwy i wersji. Za pomocą polecenia ml_client.components.create_or_update()można zarejestrować składnik wcześniej załadowany z funkcji języka Python lub yaml.

Następne kroki

• Aby uzyskać więcej przykładów tworzenia potoków przy użyciu zestawu SDK uczenia maszynowego, zobacz przykładowe repozytorium.
• Aby dowiedzieć się, jak używać interfejsu użytkownika programu Studio do przesyłania i debugowania potoku, zobacz jak tworzyć potoki przy użyciu składnika w interfejsie użytkownika.
• Aby uzyskać informacje na temat tworzenia składników i potoków przy użyciu interfejsu wiersza polecenia usługi Azure Machine Learning, zobacz tworzenie potoków przy użyciu składnika za pomocą interfejsu wiersza polecenia.
• Aby dowiedzieć się, jak wdrażać potoki w środowisku produkcyjnym przy użyciu punktów końcowych usługi Batch, zobacz jak wdrażać potoki z punktami końcowymi wsadowymi.