Vytváření a spouštění kanálů strojového učení pomocí komponent se sadou Azure Machine Learning SDK v2

PLATÍ PRO: Python SDK azure-ai-ml v2 (aktuální)

V tomto článku se dozvíte, jak vytvořit kanál Azure Machine Learning pomocí sady Azure Machine Learning Python SDK v2 k dokončení úlohy klasifikace obrázků. Tento kanál obsahuje tři kroky: přípravu dat, trénování modelu klasifikace obrázků a určení skóre modelu. Kanály Machine Learning optimalizují váš pracovní postup rychlostí, přenositelností a opětovným použitím, abyste se mohli soustředit na strojové učení místo infrastruktury a automatizace.

Příkladní řetězec trénuje malou konvoluční neurální síť Keras pro klasifikaci obrázků v datovém souboru Fashion MNIST. Potrubí vypadá takto:

V tomto článku dokončíte následující úlohy:

• Připravte vstupní data pro úlohu pipeline
• Vytvoření tří komponent pro přípravu dat, trénování modelu a určení skóre modelu
• Sestavte potrubí z komponent
• Získejte přístup k pracovnímu prostoru s výpočetními prostředky
• Odeslat úlohu potrubí
• Kontrola výstupu komponent a natrénované neurální sítě
• (Volitelné) Registrace komponenty pro další použití a sdílení v rámci pracovního prostoru

Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet. Vyzkoušejte si bezplatnou nebo placenou verzi služby Azure Machine Learning ještě dnes.

Požadavky

• Pracovní prostor služby Azure Machine Learning. Pokud žádný nemáte, dokončete tutoriál vytváření prostředků.
• Prostředí Pythonu s nainstalovanou sadou Azure Machine Learning Python SDK v2 Pokyny k instalaci najdete v tématu Začínáme. Toto prostředí slouží k definování a řízení prostředků azure Machine Learning a je oddělené od prostředí používaného za běhu pro trénování.
• Klon úložiště příkladů.

Pokud chcete spustit trénovací příklady, nejprve naklonujte úložiště příkladů a přejděte do sdk adresáře:

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

Spuštění interaktivní relace Pythonu

Tento článek používá Azure Machine Learning Python SDK k vytvoření a řízení datového toku služby Azure Machine Learning. V článku se předpokládá, že fragmenty kódu spouštíte interaktivně v prostředí Python REPL nebo v poznámkovém bloku Jupyter.

Tento článek je založený na poznámkovém bloku image_classification_keras_minist_convnet.ipynb v sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet adresáři úložiště příkladů služby Azure Machine Learning .

Import požadovaných knihoven

Naimportujte všechny knihovny Azure Machine Learning, které potřebujete pro tento článek:

# 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

Připravte vstupní data pro úlohu v zpracovatelském řetězci.

Potřebujete připravit vstupní data pro kanál klasifikace obrázků.

Fashion MNIST je datová sada módních obrázků rozdělených do 10 tříd. Každý obraz je 28 x 28 obraz ve stupních šedi. K dispozici je 60 000 trénovacích obrázků a 10 000 testovacích obrázků.

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

Definováním objektu Inputvytvoříte odkaz na umístění zdroje dat. Data zůstávají v existujícím umístění, takže se neúčtují žádné další náklady na úložiště.

Vytvoření komponent pro sestavení "pipeline"

Úkol klasifikace obrázků je možné rozdělit do tří kroků: příprava dat, trénování modelu a určení skóre modelu.

Komponenta Azure Machine Learning je samostatná část kódu, která dokončí jeden krok v kanálu strojového učení. V tomto článku vytvoříte tři komponenty pro úlohu klasifikace obrázků:

• Příprava dat pro trénování a testování
• Trénování neurální sítě pro klasifikaci obrázků pomocí trénovacích dat
• Určení skóre modelu pomocí testovacích dat

Pro každou komponentu provedete tyto kroky:

1. Příprava skriptu Pythonu, který obsahuje logiku spouštění
2. Definování rozhraní komponenty
3. Přidejte další metadata komponenty, včetně prostředí runtime a příkazu pro spuštění komponenty.

Další části ukazují, jak vytvořit komponenty dvěma způsoby. Pro první dvě komponenty použijete funkci Pythonu. Pro třetí komponentu použijete definici YAML.

Vytvoření komponenty pro přípravu dat

První komponenta v tomto potrubí převede komprimované datové soubory fashion_ds do dvou .csv souborů, jeden pro trénování a druhý pro hodnocení. K definování této komponenty použijete funkci Pythonu.

Pokud sledujete společně s příkladem v úložišti příkladů služby Azure Machine Learning, zdrojové soubory už jsou ve prep složce k dispozici. Tato složka obsahuje dva soubory pro vytvoření komponenty: prep_component.py, která definuje komponentu, a conda.yaml, která definuje běhové prostředí komponenty.

Definování komponenty pomocí funkce Pythonu

command_component() Pomocí funkce jako dekorátoru můžete snadno definovat rozhraní komponenty, jeho metadata a kód, který se má spustit z funkce Pythonu. Každá zdobená funkce Pythonu se transformuje na jednu statickou specifikaci (YAML), kterou může služba kanálu zpracovat.

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

Předchozí kód definuje komponentu se zobrazovaným názvem Prep Data pomocí dekorátoru @command_component :

• name je jedinečný identifikátor komponenty.

• version je aktuální verze komponenty. Komponenta může mít více verzí.

• display_name je přátelský zobrazovací název komponenty pro uživatelské rozhraní.

• description popisuje úlohu, která může komponenta dokončit.

• environment určuje běhové prostředí pro komponentu pomocí souboru conda.yaml.

  Soubor conda.yaml obsahuje všechny balíčky používané pro komponentu:

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

• Funkce prepare_data_component definuje jeden vstup pro a dva výstupy pro input_datatraining_data a test_data

  • input_data je vstupní cesta k datům.
  • training_data a test_data jsou výstupními datovými cestami pro trénovací data a testovací data.

• Komponenta převede data z input_data do training_data souboru .csv pro trénovací data a test_data soubor .csv pro testovací data.

V uživatelském rozhraní studia se komponenta zobrazí takto:

• Blok v grafu potrubí
• input_data, training_dataa test_data jsou porty komponenty, které se připojují k dalším komponentám pro streamování dat.

Teď jste připravili všechny zdrojové soubory pro danou komponentu Prep Data .

Vytvoření komponenty trénování modelu

V této části vytvoříte komponentu pro trénování modelu klasifikace obrázků pomocí funkce Pythonu, jak jste to udělali s komponentou Prep Data .

Vzhledem k tomu, že je trénovací logika složitější, vložíte trénovací kód do samostatného souboru Pythonu.

Zdrojové soubory pro tuto komponentu train jsou ve složce v úložišti příkladů služby Azure Machine Learning. Tato složka obsahuje tři soubory pro vytvoření komponenty:

• train.py obsahuje logiku pro trénování modelu.
• train_component.py definuje rozhraní komponenty a importuje funkci z train.py
• conda.yaml definuje běhové prostředí komponenty.

Získání skriptu, který obsahuje logiku

Soubor train.py obsahuje normální funkci Pythonu, která provádí logiku pro trénování neurální sítě Keras pro klasifikaci obrázků. Pokud chcete kód zobrazit, podívejte se na soubor train.py na GitHubu.

Definování komponenty pomocí funkce Pythonu

Po definování trénovací funkce můžete v sadě Azure Machine Learning SDK v2 zabalit tuto funkci jako komponentu pro použití v 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)

Předchozí kód definuje komponentu se zobrazovaným názvem Train Image Classification Keras pomocí @command_component.

Funkce keras_train_component definuje:

• Jeden vstup, input_data, pro zdrojová trénovací data
• Jeden vstup , epochskterý určuje počet epoch, které se mají použít během trénování
• Jeden výstup, output_modelkterý určuje výstupní cestu pro soubor modelu

Výchozí hodnota epochs je 10. Logika této komponenty pochází z train() funkce v train.py.

Komponenta modelu trénování má složitější konfiguraci než komponenta přípravy dat. Vypadá conda.yaml takto:

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

Teď jste připravili všechny zdrojové soubory pro komponentu Train Image Classification Keras .

Vytvoření komponenty bodování modelu

V této části vytvoříte komponentu pro určení skóre natrénovaného modelu pomocí specifikace a skriptu YAML.

Pokud sledujete společně s příkladem v úložišti příkladů služby Azure Machine Learning, zdrojové soubory už jsou ve score složce k dispozici. Tato složka obsahuje tři soubory pro vytvoření komponenty:

• score.py obsahuje zdrojový kód komponenty.
• score.yaml definuje rozhraní a další podrobnosti komponenty.
• conda.yaml definuje běhové prostředí komponenty.

Získání skriptu, který obsahuje logiku

Soubor score.py obsahuje normální funkci Pythonu, která provádí logiku vyhodnocování 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)

Kód v score.py bere tři argumenty příkazového řádku: input_data, input_model a output_result. Program vyhodnocí vstupní model pomocí vstupních dat a výsledek pak vypíše.

Definování komponenty pomocí YAML

V této části se dozvíte, jak vytvořit specifikaci komponenty v platném formátu specifikace komponenty YAML. Tento soubor určuje následující informace:

• Metadata: Název, zobrazovaný název, verze, typ atd.
• Rozhraní: Vstupy a výstupy
• Příkaz, kód a prostředí: Příkaz, kód a prostředí použité ke spuštění komponenty

$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 je jedinečný identifikátor komponenty. Jeho zobrazovaný název je Score Image Classification Keras
• Tato komponenta má dva vstupy a jeden výstup.
• Cesta ke zdrojovému kódu je definována v části code. Když se komponenta spustí v cloudu, všechny soubory z této cesty se nahrají jako snímek komponenty.
• Oddíl command určuje příkaz, který se má spustit při spuštění komponenty.
• Tato environment část obsahuje image Dockeru a soubor conda YAML. Zdrojový soubor je v ukázkovém úložišti.

Teď máte všechny zdrojové soubory pro komponentu bodování modelu.

Načtení komponent pro sestavení kanálu

Komponentu pro přípravu dat a trénovací komponentu modelu, které jsou definované funkcemi Pythonu, můžete importovat stejně jako běžné funkce Pythonu.

Následující kód naimportuje prepare_data_component() a keras_train_component() funkce ze prep_component.py souboru ve prep složce a train_component souboru ve train složce.

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

Funkci můžete použít load_component() k načtení komponenty skóre, která je definována YAML.

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

Načtení registrovaných komponent z pracovního prostoru

Poznámka:

Pokud chcete načíst registrované součásti z pracovního prostoru, musíte nejprve nakonfigurovat připojení pracovního prostoru, jak je popsáno v části Získat přístup k vašemu pracovnímu prostoru . Objekt ml_client je vyžadován pro následující operace.

Pokud máte komponenty, které už jsou ve vašem pracovním prostoru zaregistrované, můžete je načíst přímo pomocí ml_client.components.get() metody. Tento přístup je užitečný, pokud chcete znovu použít součásti, které jste předtím zaregistrovali nebo které sdíleli jiní členové týmu.

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

Seznam všech dostupných komponent v pracovním prostoru vám umožní najít ty, které potřebujete:

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

Po načtení můžete v rámci pipeline použít registrované komponenty stejně jako komponenty načtené z místních souborů nebo Python funkcí.

Vytvořte si potrubí

Vytvořili jste a načetli jste všechny komponenty a vstupní data pro sestavení kanálu. Teď je můžete zkombinovat do potrubí.

Poznámka:

Pokud chcete používat bezserverové výpočetní prostředky, přidejte from azure.ai.ml.entities import ResourceConfiguration do horní části souboru. Potom nahraďte:

• default_compute=cpu_compute_target s default_compute="serverless"
• train_node.compute = gpu_compute_target s 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)

Potrubí má výchozí výpočetní prostředek cpu_compute_target. Pokud pro konkrétní uzel nezadáte výpočetní výkon, běží tento uzel na výchozím výpočetním výkonu.

Potrubí má vstup na úrovni potrubí, pipeline_input_data. Při odesílání úlohy v kanálu můžete nastavit hodnotu vstupu kanálu.

Kanál obsahuje tři uzly: prepare_data_node, train_nodea score_node:

• input_data z prepare_data_node využívá hodnotu pipeline_input_data
• Výsledek input_datatrain_node je training_data výstupem prepare_data_node
• Je input_datascore_node výstupem test_data pro prepare_data_node, a input_model je output_model pro train_node
• Vzhledem k tomu, že train_node trénuje model CNN, můžete specifikovat jeho výpočetní zdroje jako gpu_compute_target, abyste zlepšili výkon trénování.

Odeslání úlohy kanálu

Teď, když jste vytvořili kanál, můžete úlohu odeslat do svého pracovního prostoru. Pokud chcete odeslat úlohu, musíte se nejprve připojit k pracovnímu prostoru.

Získání přístupu k pracovnímu prostoru

Konfigurace přihlašovacích údajů

Používáte DefaultAzureCredential k získání přístupu k pracovnímu prostoru. DefaultAzureCredential měla by být schopná zpracovat většinu scénářů ověřování sady Azure SDK.

Pokud DefaultAzureCredential vám to nepomůže, podívejte se na tento příklad konfigurace přihlašovacích údajů a balíčku 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()

Získejte popisovač pracovního prostoru s výpočetními prostředky

Vytvořte MLClient objekt pro správu služeb Azure Machine Learning. Pokud používáte bezserverové výpočetní prostředky, nemusíte tyto výpočty vytvářet.

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

Důležité

Tento fragment kódu očekává, že konfigurační soubor JSON pracovního prostoru se uloží do aktuálního adresáře nebo nadřazeného souboru. Další informace o vytvoření pracovního prostoru najdete v tématu Vytvoření prostředků pracovního prostoru. Další informace o uložení konfigurace do souboru najdete v tématu Vytvoření konfiguračního souboru pracovního prostoru.

Odeslání úlohy kanálu do pracovního prostoru

Teď, když máte přístup k pracovnímu prostoru, můžete odeslat úlohu datového kanálu:

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

Předchozí kód odešle tuto úlohu kanálu klasifikace obrázků do experimentu s názvem pipeline_samples. Pokud experiment neexistuje, vytvoří ho automaticky. pipeline_input_data používá fashion_ds.

Volání k odeslání experimentu se dokončí rychle a vytvoří výstup podobný tomuto:

Pokus	Název	Typ	Stav	Stránka podrobností
pipeline_samples	sharp_pipe_4gvqx6h1fb	kanál	Připravování	Odkaz na Azure Machine Learning Studio

Spuštění kanálu můžete sledovat výběrem odkazu. Nebo můžete počkat na dokončení spuštěním tohoto kódu:

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

Důležité

První spuštění kanálu trvá přibližně 15 minut. Stáhnou se všechny závislosti, vytvoří se image Dockeru a prostředí Pythonu se zřídí a vytvoří. Opětovné spuštění pipeline trvá méně času, protože se tyto prostředky znovu používají namísto jejich vytvoření. Celkový běh kanálu ale závisí na úloze vašich skriptů a procesech, které se spouští v jednotlivých krocích kanálu.

Zkontrolujte výstupy a ladění datového kanálu v uživatelském rozhraní

Můžete vybrat Link to Azure Machine Learning studio, což je stránka s podrobnostmi o úlohách vašeho kanálu. Zobrazí se graf kanálu:

Protokoly a výstupy jednotlivých komponent můžete zkontrolovat tak, že kliknete pravým tlačítkem na komponentu nebo vyberete komponentu a otevřete její podokno podrobností. Další informace o ladění datového toku v uživatelském rozhraní najdete v tématu Použití Azure Machine Learning Studio k řešení problémů datového toku.

(Volitelné) Registrace komponent do pracovního prostoru

V předchozích částech jste vytvořili kanál pomocí tří komponent pro dokončení úlohy klasifikace obrázků. Do pracovního prostoru můžete také zaregistrovat komponenty, aby je bylo možné sdílet a opakovaně používat v rámci pracovního prostoru. Následující příklad ukazuje, jak zaregistrovat komponentu pro přípravu dat:

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)

Pomocí ml_client.components.get() můžete získat registrovanou komponentu podle názvu a verze. Můžete použít ml_client.components.create_or_update() k registraci komponenty, která byla dříve načtena z funkce Pythonu nebo YAML.

Další kroky

• Další příklady sestavení kanálů pomocí sady SDK strojového učení najdete v ukázkovém úložišti.
• Informace o odesílání a ladění kanálu pomocí uživatelského rozhraní studia najdete v tématu Vytvoření a spuštění kanálů strojového učení pomocí komponent se sadou Azure Machine Learning Studio.
• Informace o vytváření komponent a kanálů pomocí rozhraní příkazového řádku služby Azure Machine Learning najdete v tématu Vytváření a spouštění kanálů strojového učení pomocí komponent pomocí rozhraní příkazového řádku služby Azure Machine Learning.
• Informace o nasazení kanálů do produkčního prostředí pomocí koncových bodů služby Batch najdete v tématu Nasazení kanálů s využitím koncových bodů služby Batch.