Gépi tanulási folyamatok létrehozása és futtatása összetevők használatával az Azure Machine Tanulás SDK 2-vel

A KÖVETKEZŐKRE VONATKOZIK: Python SDK azure-ai-ml v2 (aktuális)

Ebben a cikkben megtudhatja, hogyan hozhat létre Egy Azure Machine Tanulás-folyamatot a Python SDK v2 használatával egy három lépést tartalmazó képbesorolási feladat elvégzéséhez: adatok előkészítése, képbesorolási modell betanítása és a modell pontszáma. A gépi tanulási folyamatok gyorsasággal, hordozhatósággal és újrafelhasználással optimalizálják a munkafolyamatot, így az infrastruktúra és az automatizálás helyett a gépi tanulásra összpontosíthat.

A példa betanít egy kis Keras konvolúciós neurális hálózatot a képek Fashion MNIST-adathalmazba való besorolásához. A folyamat a következőhöz hasonlóan néz ki.

Ebben a cikkben a következő feladatokat hajtja végre:

• Bemeneti adatok előkészítése a folyamatfeladathoz
• Három összetevő létrehozása az adatok előkészítéséhez, betanítása és pontszáma
• Folyamat összeállítása az összetevőkből
• A munkaterülethez való hozzáférés lekérése számítással
• A folyamatfeladat elküldése
• Az összetevők és a betanított neurális hálózat kimenetének áttekintése
• (Nem kötelező) Az összetevő regisztrálása további újrafelhasználáshoz és megosztáshoz a munkaterületen belül

Ha még nincs Azure-előfizetése, kezdés előtt hozzon létre egy ingyenes fiókot. Próbálja ki ma az Azure Machine ingyenes vagy fizetős verzióját Tanulás.

Előfeltételek

• Azure Machine Tanulás munkaterület – ha nincs ilyenje, végezze el az Erőforrások létrehozása oktatóanyagot.

• Egy Python-környezet, amelyben telepítette az Azure Machine Tanulás Python SDK v2 - telepítési utasítások - tekintse meg az első lépéseket ismertető szakaszt. Ez a környezet az Azure Machine Tanulás-erőforrások meghatározására és szabályozására szolgál, és elkülönül a futásidőben a betanításhoz használt környezettől.

• Példák klónozása adattár

  A betanítási példák futtatásához először klónozza a példák adattárát, és váltson a sdk könyvtárra:

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

Interaktív Python-munkamenet indítása

Ez a cikk az Azure Machine-hez készült Python SDK Tanulás használatával hoz létre és vezérel egy Azure Machine Tanulás-folyamatot. A cikk feltételezi, hogy a kódrészleteket interaktív módon fogja futtatni Python REPL-környezetben vagy Jupyter-jegyzetfüzetben.

Ez a cikk az Azure Machine Tanulás Examples adattár könyvtárában sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnettalálható image_classification_keras_minist_convnet.ipynb jegyzetfüzeten alapul.

Szükséges kódtárak importálása

Importálja a cikkhez szükséges összes Azure Machine-Tanulás szükséges kódtárat:

# 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

Bemeneti adatok előkészítése a folyamatfeladathoz

A képbesorolási folyamat bemeneti adatait elő kell készítenie.

A Fashion-MNIST egy 10 osztályra osztott divatképek adathalmaza. Minden kép 28x28 szürkeárnyalatos kép, és 60 000 betanítás és 10 000 tesztkép található. Képbesorolási problémaként a Fashion-MNIST nehezebb, mint a klasszikus MNIST kézzel írt számjegyadatbázis. Az eredeti kézzel írt számjegyadatbázissal megegyező tömörített bináris formában van elosztva.

Importálja az összes szükséges Azure Machine-Tanulás szükséges kódtárat.

Az adatforrás helyére mutató hivatkozás definiálásával létrehozhat Inputegy hivatkozást. Az adatok a meglévő helyen maradnak, így nincs többlet tárolási költség.

Összetevők létrehozása folyamat létrehozásához

A képbesorolási feladat három lépésre osztható: adatok előkészítése, modell betanítása és pontozási modell.

Az Azure Machine Tanulás összetevő egy önálló kódrészlet, amely egy lépést hajt végre egy gépi tanulási folyamatban. Ebben a cikkben három összetevőt fog létrehozni a képbesorolási feladathoz:

• Adatok előkészítése betanításra és tesztelésre
• Neurális hálózat betanítása képosztályozáshoz betanítási adatokkal
• A modell pontozása tesztadatokkal

Minden összetevőhöz a következőket kell előkészítenie:

1. A végrehajtási logikát tartalmazó Python-szkript előkészítése

2. Az összetevő felületének meghatározása

3. Adja hozzá az összetevő egyéb metaadatait, például a futásidejű környezetet, az összetevő futtatására szolgáló parancsot stb.

A következő szakaszban a létrehozási összetevők két különböző módon jelennek meg: az első két összetevő Python-függvényt használó, a harmadik pedig YAML-definíciót használó összetevő.

Az adat-előkészítési összetevő létrehozása

A folyamat első összetevője két csv-fájllá alakítja a tömörített adatfájlokat fashion_ds , az egyiket betanításra, a másikat pedig pontozásra. Ezt az összetevőt Python-függvény használatával fogja definiálni.

Ha az Azure Machine Tanulás példák adattárában szereplő példával együtt követi, a forrásfájlok már elérhetők a mappábanprep/. Ez a mappa két fájlt tartalmaz az összetevő létrehozásához: prep_component.pyaz összetevőt meghatározó és conda.yamlaz összetevő futásidejű környezetét meghatározó fájlt.

Összetevő definiálása Python-függvény használatával

A függvény dekorátorként való használatával command_component() egyszerűen meghatározhatja az összetevő felületét, metaadatait és kódját a Python-függvényből való végrehajtáshoz. Minden kitüntetett Python-függvény egyetlen statikus specifikációvá (YAML) alakul át, amelyet a folyamatszolgáltatás feldolgozhat.

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

A fenti kód egy megjelenítési névvel Prep Data rendelkező összetevőt határoz meg dekorátor használatával @command_component :

• name az összetevő egyedi azonosítója.

• version az összetevő aktuális verziója. Egy összetevő több verzióval is rendelkezhet.

• display_name az összetevő rövid megjelenítendő neve a felhasználói felületen, amely nem egyedi.

• description általában azt írja le, hogy az összetevő milyen feladatot hajthat végre.

• environment az összetevő futásidejű környezetét adja meg. Az összetevő környezete egy docker-rendszerképet határoz meg, és a conda.yaml fájlra hivatkozik.

  A conda.yaml fájl az összetevőhöz használt összes csomagot tartalmazza, például a következőket:

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

• A prepare_data_component függvény egy bemenetet input_data és két kimenetet határoz meg az és test_dataa training_data . input_data bemeneti adatútvonal. training_data és test_data kimeneti adatútvonalak a betanítási és tesztelési adatokhoz.

• Ez az összetevő átalakítja az adatokat betanítási adat csv-ből input_data betanítási adat csv-vé training_data , és egy teszt adat csv-ből test_data.

Az alábbi módon néz ki egy összetevő a studio felhasználói felületén.

• Az összetevő egy folyamatdiagram blokkja.
• training_datatest_data Az input_dataösszetevő portjai és portjai, amelyek más összetevőkhöz csatlakoznak az adatstreameléshez.

Most előkészítette az összetevő összes forrásfájlját Prep Data .

A betanítottmodell-összetevő létrehozása

Ebben a szakaszban egy összetevőt fog létrehozni a képosztályozási modell betanításához a Python-függvényben, például az Prep Data összetevőben.

A különbség az, hogy mivel a betanítási logika bonyolultabb, az eredeti betanítási kódot külön Python-fájlba helyezheti.

Az összetevő forrásfájljai az Azure Machine Tanulás példák adattárában találhatóktrain/. Ez a mappa három fájlt tartalmaz az összetevő létrehozásához:

• train.py: a modell betanítására vonatkozó tényleges logikát tartalmazza.
• train_component.py: meghatározza az összetevő interfészét, és importálja a függvényt a következőben train.py: .
• conda.yaml: az összetevő futásidejű környezetét határozza meg.

Végrehajtási logikát tartalmazó szkript lekérése

A train.py fájl egy normál Python-függvényt tartalmaz, amely végrehajtja a betanítási modell logikáját egy Keras neurális hálózat képbesoroláshoz való betanításához. A kód megtekintéséhez tekintse meg a GitHubon található train.py fájlt.

Összetevő definiálása Python-függvény használatával

A betanítási függvény sikeres @command_component definiálása után az Azure Machine Tanulás SDK v2-ben használhatja a függvény összetevőként való burkolásához, amely az Azure Machine Tanulás-folyamatokban használható.

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)

A fenti kód egy megjelenítendő nevű Train Image Classification Keras összetevőt határoz meg a következő használatával @command_component:

• A keras_train_component függvény egy bemenetet input_data határoz meg, amelyből a betanítási adatok származnak, egy bemenetet epochs a betanítás során, egy kimenetet output_model pedig a modellfájl kimeneteként. Az alapértelmezett érték epochs 10. Az összetevő végrehajtási logikája a fenti függvényből származik train()train.py .

A betanítási modell összetevő valamivel összetettebb konfigurációval rendelkezik, mint az prep-data összetevő. Az conda.yaml alábbiakhoz hasonló:

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

Most előkészítette az összetevő összes forrásfájlját Train Image Classification Keras .

A score-model összetevő létrehozása

Ebben a szakaszban az előző összetevőkön kívül egy összetevőt fog létrehozni a betanított modell yaml-specifikáción és szkripten keresztüli pontozásához.

Ha az Azure Machine Tanulás példák adattárában szereplő példával együtt követi, a forrásfájlok már elérhetők a mappábanscore/. Ez a mappa három fájlt tartalmaz az összetevő létrehozásához:

• score.py: az összetevő forráskódját tartalmazza.
• score.yaml: meghatározza az összetevő felületét és egyéb részleteit.
• conda.yaml: az összetevő futásidejű környezetét határozza meg.

Végrehajtási logikát tartalmazó szkript lekérése

A score.py fájl egy normál Python-függvényt tartalmaz, amely végrehajtja a betanítási modell logikáját.

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)

A score.py kódjának három parancssori argumentuma van: input_dataés input_modeloutput_result. A program bemeneti adatokkal pontozza a bemeneti modellt, majd kimeneteli a pontozási eredményt.

Összetevő definiálása a Yaml használatával

Ebben a szakaszban megtanulhatja, hogyan hozhat létre egy összetevő-specifikációt érvényes YAML-összetevő-specifikáció formátumban. Ez a fájl a következő információkat adja meg:

• Metaadatok: név, display_name, verzió, típus stb.
• Interfész: bemenetek és kimenetek
• Parancs, kód, > környezet: Az összetevő futtatásához használt parancs, kód és környezet

$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 az összetevő egyedi azonosítója. Megjelenítendő neve .Score Image Classification Keras
• Ez az összetevő két bemenettel és egy kimenettel rendelkezik.
• A forráskód elérési útja a code szakaszban van definiálva, és amikor az összetevő felhőben fut, az elérési út összes fájlja az összetevő pillanatképeként lesz feltöltve.
• A command szakasz megadja az összetevő futtatása közben végrehajtandó parancsot.
• A environment szakasz egy Docker-képet és egy conda yaml-fájlt tartalmaz. A forrásfájl a mintaadattárban található.

Most már minden forrásfájlt tartalmaz a score-model összetevőhöz.

Összetevők betöltése a folyamat létrehozásához

A Python-függvény által definiált prep-data összetevő és betanítási modell összetevő esetében ugyanúgy importálhatja az összetevőket, mint a normál Python-függvényeket.

A következő kódban importálja prepare_data_component() és keras_train_component() a fájlból a mappa train_component alattprep, illetve a prep_component.py mappában lévő fájlból train a függvényt.

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

A yaml által definiált pontozási összetevő betöltéséhez függvényt load_component() használhat.

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

A folyamat létrehozása

Most, hogy létrehozta és betöltötte az összes összetevőt és bemeneti adatot a folyamat létrehozásához. Ezeket egy folyamatba írhatja:

Feljegyzés

A kiszolgáló nélküli számítás használatához adja hozzá from azure.ai.ml.entities import ResourceConfiguration a tetejéhez. Ezután cserélje le a következőt:

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

A folyamat alapértelmezett számítással cpu_compute_targetrendelkezik, ami azt jelenti, hogy ha nem ad meg számítást egy adott csomóponthoz, akkor a csomópont az alapértelmezett számításon fog futni.

A folyamat folyamatszintű bemenettel pipeline_input_datarendelkezik. Folyamatfeladat elküldésekor értéket rendelhet a folyamatbemenethez.

A folyamat három csomópontot, prepare_data_node, train_node és score_node tartalmaz.

• A input_data függvény prepare_data_node a következő értéket pipeline_input_datahasználja: .

• Az input_data érték train_node a training_data prepare_data_node kimenetéből származik.

• A input_data score_node a test_data prepare_data_node kimenetéből származikoutput_model, a input_model train_node.

• Mivel train_node betanít egy CNN-modellt, megadhatja a számítását gpu_compute_target, ami javíthatja a betanítási teljesítményt.

A folyamatfeladat elküldése

Most, hogy elkészült a folyamat, beküldheti a munkaterületre. Feladat elküldéséhez először csatlakoznia kell egy munkaterülethez.

Hozzáférés kérése a munkaterülethez

Hitelesítő adatok konfigurálása

A munkaterülethez való hozzáférést fogjuk használni DefaultAzureCredential . DefaultAzureCredential képesnek kell lennie a legtöbb Azure SDK-hitelesítési forgatókönyv kezelésére.

További elérhető hitelesítő adatokra vonatkozó hivatkozás, ha az nem működik: konfigurálja a hitelesítő adatokat tartalmazó példát, az Azure-Identity referencia-dokumentumát.

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

Fogópont lekérése egy számítási feladattal rendelkező munkaterületre

Hozzon létre egy objektumot MLClient az Azure Machine Tanulás-szolgáltatások kezeléséhez. Ha kiszolgáló nélküli számítást használ, akkor nem kell létrehoznia ezeket a számításokat.

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

Fontos

Ez a kódrészlet azt várja, hogy a munkaterület konfigurációs json-fájlja az aktuális könyvtárba vagy annak szülőjébe legyen mentve. A munkaterület létrehozásával kapcsolatos további információkért tekintse meg a munkaterület erőforrásainak létrehozását ismertető témakört. A konfiguráció fájlba mentéséről további információt a munkaterület konfigurációs fájljának létrehozása című témakörben talál.

Folyamatfeladat elküldése a munkaterületre

Most már kap egy leírót a munkaterülethez, elküldheti a folyamatfeladatot.

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

A fenti kód elküldi ezt a képbesorolási folyamatfeladatot a kísérlethez.pipeline_samples Automatikusan létrehozza a kísérletet, ha nem létezik. A pipeline_input_data felhasználások fashion_ds.

A hívás a következőhöz pipeline_jobhasonló kimenetet hoz létre:

A hívás submitExperiment gyorsan befejeződik, és a következőhöz hasonló kimenetet hoz létre:

Experiment	Név	Típus	Állapot	Részletek oldal
pipeline_samples	sharp_pipe_4gvqx6h1fb	Csővezeték	Előkészítése	Hivatkozás az Azure Machine Tanulás Studióhoz.

A folyamat futtatását a hivatkozás megnyitásával figyelheti, vagy letilthatja, amíg a folyamat befejeződik a következő futtatásával:

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

Fontos

Az első folyamatfuttatás körülbelül 15 percet vesz igénybe. Minden függőséget le kell tölteni, létre kell hozni egy Docker-lemezképet, és létre kell hozni a Python-környezetet. A folyamat ismételt futtatása jelentősen kevesebb időt vesz igénybe, mert ezeket az erőforrásokat a rendszer a létrehozás helyett újra felhasználja. A folyamat teljes futási ideje azonban a szkriptek számítási feladataitól és az egyes folyamatlépésekben futó folyamatoktól függ.

Kimenetek kivétele és a folyamat hibakeresése a felhasználói felületen

Megnyithatja a Link to Azure Machine Learning studiofolyamat feladatinformációs oldalát. A folyamatdiagram az alábbihoz hasonlóan jelenik meg.

Az egyes összetevők naplóinak és kimeneteinek ellenőrzéséhez kattintson a jobb gombbal az összetevőre, vagy válassza ki az összetevőt a részletpanel megnyitásához. A folyamat felhasználói felületen történő hibakeresésével kapcsolatos további információkért lásd a hibakeresési folyamat hibáinak használatát ismertető témakört.

(Nem kötelező) Összetevők regisztrálása a munkaterületre

Az előző szakaszban egy három összetevőt használó folyamatot készített az E2E-nek egy képbesorolási feladat elvégzéséhez. Az összetevőket regisztrálhatja a munkaterületen is, hogy megoszthassák és újra el tudják őket adni a munkaterületen belül. Az alábbiakban egy példa látható az prep-data összetevő regisztrálására.

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)

A használatával ml_client.components.get()név és verzió alapján szerezhet be egy regisztrált összetevőt. A használatával ml_client.components.create_or_update()regisztrálhat egy korábban Python-függvényből vagy yamlből betöltött összetevőt.

Következő lépések

• A folyamatokat a Machine Learning SDK használatával történő buildelésére a példaadattárban talál.
• A studio felhasználói felületének használatával a folyamat elküldéséhez és hibakereséséhez tekintse meg , hogyan hozhat létre folyamatokat összetevő használatával a felhasználói felületen.
• Ha az Azure Machine Tanulás CLI használatával szeretne összetevőket és folyamatokat létrehozni, tekintse meg, hogyan hozhat létre folyamatokat összetevő használatával a parancssori felülettel.
• A folyamatok éles környezetben a Batch-végpontok használatával történő üzembe helyezéséhez tekintse meg , hogyan helyezhet üzembe folyamatokat kötegelt végpontokkal.