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

DOTYCZY: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 usługi Azure Machine Learning w wersji 2 w celu ukończenia zadania klasyfikacji obrazów. Ten pipeline zawiera 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.

Przykładowy pipeline trenuje małą konwolucyjną sieć neuronową Keras w celu klasyfikacji obrazów w zestawie danych Fashion MNIST. Przepływ wygląda następująco:

W tym artykule wykonasz następujące zadania:

• Przygotowywanie danych wejściowych do zadania przebiegu
• Tworzenie trzech składników w celu przygotowania danych, wytrenowania modelu i oceny modelu
• Zbuduj rurociąg ze składników
• Uzyskaj dostęp do obszaru roboczego z zasobami obliczeniowymi
• Zleć zadanie w potoku danych
• Przejrzyj wyniki komponentów i wytrenowanej sieci neuronowej
• (Opcjonalnie) Rejestrowanie składnika w celu dalszego ponownego użycia i udostępniania w obszarze roboczym

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.
• Zainstalowane środowisko języka Python z zestawem SDK języka Python usługi Azure Machine Learning w wersji 2. Aby uzyskać instrukcje dotyczące instalacji, zobacz 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.
• Klon repozytorium przykładów.

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

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 usługi Azure Machine Learning do tworzenia i kontrolowania potoku Azure Machine Learning. W tym artykule założono, że uruchamiasz fragmenty kodu interaktywnie w środowisku REPL języka Python lub notesie Jupyter.

Ten artykuł jest oparty na notesie image_classification_keras_minist_convnet.ipynb w sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet katalogu repozytorium przykładów usługi Azure Machine Learning .

Importowanie wymaganych bibliotek

Zaimportuj wszystkie biblioteki usługi Azure Machine Learning 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

Przygotuj dane wejściowe do zadania przepływu

Musisz przygotować dane wejściowe do procesu klasyfikacji obrazów.

Fashion MNIST to zestaw danych obrazów mody podzielonych na 10 klas. Każdy obraz jest obrazem o skali szarości 28 x 28. Istnieje 60 000 obrazów treningowych i 10 000 obrazów testowych.

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

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.

Tworzyć komponenty do budowy rurociągu

Zadanie klasyfikacji obrazów można podzielić na trzy kroki: przygotować dane, wytrenować model i ocenić model.

Składnik usługi Azure Machine Learning to samodzielny fragment kodu, który kończy 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 wykonać następujące kroki:

1. Przygotowywanie skryptu języka Python zawierającego logikę wykonywania
2. Definiowanie interfejsu składnika
3. Dodaj inne metadane składnika, w tym środowisko uruchomieniowe i polecenie , aby uruchomić składnik

W następnych sekcjach pokazano, jak utworzyć składniki na dwa sposoby. W przypadku dwóch pierwszych składników należy użyć funkcji języka Python. W przypadku trzeciego składnika należy użyć definicji YAML.

Tworzenie składnika przygotowywania danych

Pierwszy składnik w tym przepływie danych konwertuje skompresowane pliki fashion_ds danych na dwa pliki .csv, jeden do trenowania, a drugi do testowania. Aby zdefiniować ten składnik, należy użyć funkcji języka Python.

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 folderze prep . Ten folder zawiera dwa pliki do konstruowania składnika: prep_component.py, który definiuje składnik i conda.yaml, który definiuje środowisko uruchomieniowe składnika.

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

command_component() Korzystając z funkcji jako dekoratora, można łatwo zdefiniować interfejs składnika, jego metadane i kod do uruchomienia z funkcji języka Python. Każda udekorowana funkcja w języku Python jest przekształcana w jedną specyfikację statyczną (YAML), którą może przetworzyć usługa pipeline'u.

# 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 dekoratora @command_component :

• 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 interfejsu użytkownika

• description opisuje zadanie, które może wykonać składnik

• environment określa środowisko uruchomieniowe składnika przy użyciu pliku conda.yaml

  Plik conda.yaml zawiera wszystkie pakiety używane dla składnika:

  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 i test_data to ścieżki danych wyjściowych dla danych treningowych i testowych

• Składnik konwertuje dane z input_data na training_data plik .csv na dane szkoleniowe i test_data plik .csv na potrzeby danych testowych

W interfejsie użytkownika programu Studio składnik jest wyświetlany jako:

• Blok w grafie potoku
• input_data, training_datai test_data są portami składnika, które łączą się z innymi składnikami na potrzeby przesyłania strumieniowego danych

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

Utwórz składnik trenowania modelu

W tej sekcji utworzysz składnik do trenowania modelu klasyfikacji obrazów przy użyciu funkcji języka Python, tak jak w przypadku Prep Data składnika.

Ponieważ logika trenowania jest bardziej złożona, kod trenowania należy umieścić w osobnym pliku języka Python.

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

• train.py zawiera logikę trenowania modelu
• train_component.py definiuje interfejs składnika i importuje funkcję z train.py
• conda.yaml definiuje środowisko uruchomieniowe składnika

Pobieranie skryptu zawierającego logikę

Plik train.py zawiera normalną funkcję języka Python, która wykonuje logikę trenowania 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 zdefiniowaniu funkcji trenowania możesz użyć @command_component zestawu SDK usługi Azure Machine Learning w wersji 2 do opakowania funkcji jako składnika do użycia 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:

• Jedne dane wejściowe input_data do danych treningowych źródłowych
• Jedno dane wejściowe , epochsktóre określa liczbę epok do użycia podczas trenowania
• Jedno wyjście , output_modelktóre określa ścieżkę wyjściową pliku modelu

Wartość domyślna to epochs 10. Logika tego składnika pochodzi z train() funkcji w train.py.

Składnik trenowania modelu ma bardziej złożoną konfigurację niż składnik przygotowywania danych. Element conda.yaml wygląda następująco:

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 oceniania modelu

W tej sekcji utworzysz składnik do oceny wytrenowanego modelu przy użyciu specyfikacji YAML i skryptu.

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 folderze score . 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ę

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

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 pliku score.py przyjmuje trzy argumenty wiersza polecenia: input_data, input_modeli output_result. Program ocenia model wejściowy przy użyciu danych wejściowych, a następnie zwraca wynik.

Definiowanie składnika przy użyciu kodu 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, nazwa wyświetlana, 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 sekcji code. Gdy składnik działa w chmurze, wszystkie pliki z tej ścieżki są przekazywane jako migawka składnika
• Sekcja command określa polecenie do wykonania po uruchomieniu składnika
• Sekcja environment zawiera obraz Docker i plik YAML conda. Plik źródłowy znajduje się w przykładowym repozytorium

Masz teraz wszystkie pliki źródłowe składnika oceniania modelu.

Załaduj składniki, aby zbudować potok

Możesz zaimportować składnik przygotowywania danych i składnik trenowania modelu, który jest definiowany przez funkcje języka Python, podobnie jak normalne funkcje języka Python.

Kod poniżej importuje funkcje prepare_data_component() i keras_train_component() odpowiednio z pliku prep_component.py w folderze prep oraz z pliku train_component w folderze train.

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

Możesz użyć funkcji load_component(), aby załadować komponent wyniku, który jest zdefiniowany za pomocą YAML.

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

Załaduj zarejestrowane składniki z obszaru roboczego

Uwaga

Aby załadować zarejestrowane składniki z obszaru roboczego, należy najpierw skonfigurować połączenie obszaru roboczego zgodnie z opisem w sekcji Uzyskiwanie dostępu do obszaru roboczego . Obiekt ml_client jest wymagany w przypadku następujących operacji.

Jeśli masz składniki, które są już zarejestrowane w obszarze roboczym, możesz załadować je bezpośrednio przy użyciu ml_client.components.get() metody . Takie podejście jest przydatne, gdy chcesz ponownie użyć składników, które zostały wcześniej zarejestrowane przez Ciebie lub udostępnione przez innych członków zespołu.

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

Możesz wyświetlić listę wszystkich dostępnych składników w obszarze roboczym, aby znaleźć potrzebne składniki:

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

Po załadowaniu można używać zarejestrowanych składników w potoku dokładnie tak jak składniki ładowane z lokalnych plików lub funkcji języka Python.

Zbuduj swoją linię produkcyjną

Utworzono i załadowano wszystkie składniki i dane wejściowe w celu zbudowania potoku. Teraz możesz je połączyć w ciąg:

Uwaga

Aby użyć obliczeń bezserwerowych, dodaj from azure.ai.ml.entities import ResourceConfiguration na początku pliku. Następnie zastąp:

• default_compute=cpu_compute_target z default_compute="serverless"
• train_node.compute = gpu_compute_target z train_node.resources = ResourceConfiguration(instance_type="Standard_NC6s_v3", instance_count=2)

# 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 przetwarzania posiada domyślne zasoby obliczeniowe cpu_compute_target. Jeśli nie określisz zasobów obliczeniowych dla określonego węzła, ten węzeł jest uruchamiany w domyślnym środowisku obliczeniowym.

Rurociąg ma dane wejściowe na poziomie rurociągu. pipeline_input_data Wartość można przypisać do danych wejściowych potoku podczas przesyłania zadania potoku.

Potok zawiera trzy węzły: prepare_data_node, train_nodei score_node:

• Wartość input_data z prepare_data_node używa wartości pipeline_input_data
• input_data train_node to wyjściowe dane elementu training_data
• Parametr input_data jest wynikiem score_nodetest_data, a prepare_data_node jest wartością input_modeloutput_model.
• Ponieważ train_node trenuje model CNN, możesz określić jego zasoby obliczeniowe jako gpu_compute_target w celu poprawy wydajności trenowania.

Prześlij swoje zadanie potoku

Po utworzeniu potoku możesz przesłać zadanie do obszaru roboczego. Aby przesłać zadanie, najpierw musisz nawiązać połączenie z obszarem roboczym.

Uzyskiwanie dostępu do obszaru roboczego

Konfigurowanie poświadczeń

DefaultAzureCredential Służy do uzyskiwania dostępu do obszaru roboczego. DefaultAzureCredential powinna obsługiwać większość scenariuszy uwierzytelniania zestawu Azure SDK.

Jeśli DefaultAzureCredential nie zadziała, zobacz ten przykład konfigurowania poświadczeń i pakiet tożsamości.

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

Uzyskaj dostęp do obszaru roboczego z zasobami obliczeniowymi

MLClient Utwórz obiekt do zarządzania usługami Azure Machine Learning. Jeśli używasz bezserwerowych obliczeń, nie musisz tworzyć 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))

Ważne

Ten fragment kodu oczekuje, że plik JSON konfiguracji obszaru roboczego zostanie zapisany w bieżącym katalogu lub jego katalogu nadrzędnym. Aby uzyskać więcej informacji na temat tworzenia obszaru roboczego, zobacz Tworzenie zasobów obszaru roboczego. Aby uzyskać więcej informacji na temat zapisywania konfiguracji w pliku, zobacz Tworzenie pliku konfiguracji obszaru roboczego.

Prześlij zadanie pipelinowe do obszaru roboczego

Teraz, gdy masz dostęp do swojego obszaru roboczego, możesz przesłać zadanie przepływu pracy.

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. Automatycznie tworzy eksperyment, jeśli nie istnieje. pipeline_input_data używa metody fashion_ds.

Wywołanie przesyłania eksperymentu zostanie ukończone szybko i spowoduje wygenerowanie danych wyjściowych podobnych do następujących:

Eksperyment	Nazwisko	Typ	Stan	Strona szczegółów
pipeline_samples	sharp_pipe_4gvqx6h1fb	potok	Przygotowanie	Link do usługi Azure Machine Learning Studio

Można monitorować przebieg potoku, wybierając link. Możesz też poczekać na jego ukończenie, uruchamiając następujący kod:

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

Ważne

Pierwsze uruchomienie przepływu danych trwa około 15 minut. Wszystkie zależności są pobierane, tworzony jest obraz platformy Docker, a środowisko Python jest przygotowywane i tworzone. Ponowne uruchomienie potoku zajmuje mniej czasu, ponieważ te zasoby są wykorzystywane ponownie, zamiast być tworzonymi. Jednak całkowity czas działania potoku zależy od obciążenia skryptów i procesów uruchamianych w każdym kroku potoku.

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

Możesz wybrać Link to Azure Machine Learning studiostronę , która jest stroną szczegółów zadania potoku. Widzisz wykres rurociągu:

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 o tym, jak rozwiązywać problemy z potokiem w interfejsie użytkownika, zobacz Jak używać Azure Machine Learning Studio do debugowania błędów potoku.

(Opcjonalnie) Zarejestruj składniki w obszarze roboczym

W poprzednich sekcjach utworzono pipeline przy użyciu trzech komponentów w celu ukończenia zadania klasyfikacji obrazów. Możesz również zarejestrować składniki w obszarze roboczym, aby mogły być współużytkowane i ponownie używane w obszarze roboczym. W poniższym przykładzie pokazano, jak zarejestrować składnik przygotowywania danych:

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)

Możesz użyć ml_client.components.get(), aby uzyskać zarejestrowany składnik według nazwy i wersji. Można użyć ml_client.components.create_or_update() polecenia , aby zarejestrować składnik, który został 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 uzyskać informacje na temat przesyłania i debugowania potoku przy użyciu interfejsu użytkownika programu Studio, zobacz Tworzenie i uruchamianie potoków uczenia maszynowego przy użyciu składników w usłudze Azure Machine Learning Studio
• 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 i uruchamianie potoków uczenia maszynowego przy użyciu składników za pomocą interfejsu wiersza polecenia usługi Azure Machine Learning
• Aby uzyskać informacje na temat wdrażania potoków w środowisku produkcyjnym z użyciem wsadowych punktów końcowych, zobacz Jak wdrażać potoki z wsadowymi punktami końcowymi