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

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

Ebből a cikkből megtudhatja, hogyan hozhat létre Azure Machine Learning-folyamatot az Azure Machine Learning Python SDK v2 használatával egy képbesorolási feladat elvégzéséhez. Ez a folyamat három lépést tartalmaz: adatok előkészítését, képbesorolási modell betanítása és a modell pontozása. A Machine Learning-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éldafolyamat betanít egy kis Keras konvolúciós neurális hálózatot, hogy képeket soroljon be a Fashion MNIST adatkészletbe. A folyamat a következőképpen 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, a modell betanítása és a modell pontozásához
• Folyamat létrehozása az összetevőkből
• Hozzáférés egy számítási kapacitással rendelkező munkaterülethez
• 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

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 Learning ingyenes vagy fizetős verzióját.

Előfeltételek

• Egy Azure Machine Learning-munkaterület. Ha nincs ilyenje, végezze el az Erőforrások létrehozása oktatóanyagot.
• Egy Python-környezet, amelyen telepítve van az Azure Machine Learning Python SDK v2. A telepítési utasításokért tekintse meg az Első lépések című témakört. Ez a környezet az Azure Machine Learning-erőforrások definiálá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.
• A példák adattárának klónja.

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

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 Learning Python SDK használatával hoz létre és vezérel egy Azure Machine Learning-folyamatot. A cikk feltételezi, hogy a kódrészleteket interaktívan futtatja Python REPL-környezetben vagy Jupyter-jegyzetfüzetben.

Ez a cikk az Azure Machine Learning-példák adattárának könyvtárában található sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnetimage_classification_keras_minist_convnet.ipynb jegyzetfüzeten alapul.

Szükséges könyvtárak importálása

Importálja a cikkhez szükséges összes Azure Machine Learning-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

Elő kell készítenie a bemeneti adatokat a képbesorolási folyamathoz.

A Fashion MNIST egy 10 osztályra osztott divatképek adathalmaza. Minden kép egy 28 x 28 szürkeárnyalatos kép. 60 000 betanítási kép és 10 000 tesztkép található.

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

Egy Input definiálásával létrehoz egy hivatkozást az adatforrás helyére. Az adatok a meglévő helyen maradnak, így nincs többlet tárolási költség.

Összetevők létrehozása a folyamatlánc építéséhez

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

Az Azure Machine Learning-összetevők olyan önálló kódrészletek, amelyek egy lépéssel egy gépi tanulási folyamatot hajtanak végre. Ebben a cikkben három összetevőt hoz létre 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 értékelése tesztadatokkal

Minden összetevő esetében hajtsa végre az alábbi lépéseket:

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. Az összetevő egyéb metaadatainak hozzáadása, beleértve a futtatókörnyezetet és az összetevő futtatására szolgáló parancsot

A következő szakaszok bemutatják, hogyan hozhatja létre az összetevőket kétféleképpen. Az első két összetevőhöz egy Python-függvényt kell használnia. A harmadik összetevő esetében YAML-definíciót használ.

Az adatelőkészítési összetevő létrehozása

Ennek a folyamatnak az első összetevője átalakítja a fashion_ds tömörített adatfájlokat két .csv fájllá, az egyik betanításhoz, a másik pedig pontozáshoz. Ezt az összetevőt Python-függvény használatával definiálhatja.

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

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

command_component() A függvényt dekorátorként használva egyszerűen meghatározhatja az összetevő felületét, metaadatait és a Python-függvényből futtatandó kódot. 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()

Az előző kód egy megjelenítendő nevű Prep Data összetevőt határoz meg a @command_component dekoratőr használatával:

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

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

• display_name a felhasználói felület összetevőjének barátságos megjelenítési neve

• description az összetevő által elvégezhető feladat leírása

• environment az összetevő futtatókörnyezetét adja meg conda.yaml fájl használatával

  A conda.yaml fájl tartalmazza az összetevőhöz használt összes csomagot:

  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 a training_datatest_data

  • input_data a bemeneti adat elérési útja
  • training_data és test_data kimeneti adatútvonalak a betanítási és tesztelési adatokhoz

• Az összetevő az adatokat input_data .csv fájllá alakítja, amely betanítási adatokhoz szükséges, és training_data .csv fájllá alakítja tesztelési adatokhoz.

A studio felhasználói felületén egy összetevő a következőképpen jelenik meg:

• Blokk egy csővezeték gráfban
• input_data, training_dataés test_data az összetevő portjai, amelyek más összetevőkhöz csatlakoznak az adatstreameléshez

Mostanra előkészítette az összes forrásfájlt a Prep Data komponenshez.

A modell betanítási összetevőjének létrehozása

Ebben a szakaszban létrehoz egy összetevőt a képosztályozási modell betanításához egy Python-függvény használatával, ahogyan az Prep Data összetevővel is tette.

Mivel a betanítási logika összetettebb, a betanítási kódot egy külön Python-fájlba kell helyeznie.

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

• train.py tartalmazza a modell betanítása logikáját
• train_component.py meghatározza az összetevő interfészét, és importálja a függvényt train.py
• conda.yaml meghatározza az összetevő futtatókörnyezetét

A logikát tartalmazó szkript lekérése

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

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

A betanítási függvény definiálása után az Azure Machine Learning SDK v2-ben az Azure Machine Learning-folyamatokban használható összetevőként csomagolhatja @command_component be a függvényt:

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)

Az előző kód egy megjelenítendő nevet Train Image Classification Keras használó @command_componentösszetevőt határoz meg.

A keras_train_component függvény a következőket határozza meg:

• Egy bemenet a input_dataforrás betanítási adataihoz
• Egy bemenet, epochsamely megadja a betanítás során használni kívánt korszakok számát
• Egy kimenet, output_modelamely megadja a modellfájl kimeneti elérési útját

Az alapértelmezett érték epochs 10. Az összetevő logikája a train()train.py függvényéből származik.

A betanítási modul komponens összetettebb konfigurációval rendelkezik, mint az adatelőkészítő komponens. A conda.yaml következőképpen néz ki:

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

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

A modell pontozási összetevőjének létrehozása

Ebben a szakaszban létrehoz egy komponenst a betanított modell YAML-specifikáció és szkript segítségével történő pontozásához.

Ha az Azure Machine Learning-példák adattárában szereplő példával együtt követi, a forrásfájlok már elérhetők a score mappában. 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 meghatározza az összetevő futtatókörnyezetét

A logikát tartalmazó szkript lekérése

A score.py fájl egy normál Python-függvényt tartalmaz, amely végrehajtja a modell pontozási 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 beszedett score.py kód három parancssori argumentumot vesz fel: input_data, input_modelés output_result. A program bemeneti adatokkal pontozza a bemeneti modellt, majd kiírja az eredményt.

Az összetevő definiálása YAML használatával

Ebben a szakaszban megtudhatja, 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, megjelenítendő név, verzió, típus stb.
• Interfész: Bemenetek és kimenetek
• Parancs, kód és 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. Amikor az összetevő a felhőben fut, a rendszer az adott útvonal összes fájlját feltölti az összetevő pillanatképeként
• A command szakasz megadja az összetevő futtatásakor végrehajtandó parancsot
• A environment szakasz egy Docker-lemezképet és egy conda YAML-fájlt tartalmaz. A forrásfájl a mintaadattárban található

Most már rendelkezik a modell pontozási összetevőjének összes forrásfájljával.

Töltse be az összetevőket, hogy pipelinet építsen

Importálhatja az adatelőkészítési összetevőt és a modell betanítási összetevőjét, amelyet a Python-függvények határoznak meg, csakúgy, mint a normál Python-függvények.

Az alábbi kód importálja az prepare_data_component() és keras_train_component() a függvényeket a prep_component.pyprep mappában lévő fájlból, illetve a train_component mappában lévő train fájlból.

%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 load_component() függvénnyel betöltheti a YAML által definiált pontszám-összetevőt.

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

Regisztrált összetevők betöltése a munkaterületről

Megjegyzés

A regisztrált összetevők munkaterületről való betöltéséhez először konfigurálnia kell a munkaterület kapcsolatát a Munkaterülethez való hozzáférés kérése szakaszban leírtak szerint. Az ml_client objektum a következő műveletekhez szükséges.

Ha a munkaterületen már vannak regisztrált összetevők, közvetlenül betöltheti őket a ml_client.components.get() metódussal. Ez a módszer akkor hasznos, ha újra szeretné használni azokat az összetevőket, amelyeket korábban ön regisztrált, vagy amelyeket más csapattagok osztottak meg.

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

A munkaterület összes elérhető összetevőjét listázhatja, hogy megtalálja a szükséges összetevőket:

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

Miután betöltötte, a folyamat regisztrált összetevőit pontosan ugyanúgy használhatja, mint a helyi fájlokból vagy Python-függvényekből betöltött összetevőket.

Építsd ki a saját folyamatláncodat

Létrehozta és betöltötte az összes összetevőt és bemeneti adatot a rendszer összeállításához. Most már összeállíthatja őket egy folyamatláncba:

Megjegyzés

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

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

A csővezeték alapértelmezett számítással rendelkezik cpu_compute_target. Ha nem ad meg számítást egy adott csomóponthoz, az az alapértelmezett számításon fut.

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

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

• input_data prepare_data_node a pipeline_input_data értékét használja
• A input_datatrain_node a training_data kimenetét adja prepare_data_node
• Az input_data értéke score_node a test_data kimeneteprepare_data_node, a input_model kimenete pedig a output_modeltrain_node
• Mivel a train_node egy CNN modellt tanít be, megadhatja számítási kapacitását a gpu_compute_target betanítási teljesítményének javítása érdekében

A folyamatfeladat elküldése

Most, hogy elkészült a pipeline, elküldheti a feladatot a munkaterületére. 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(z) DefaultAzureCredential segítségével hozzáférhet a munkaterülethez. DefaultAzureCredential képesnek kell lennie a legtöbb Azure SDK-hitelesítési forgatókönyv kezelésére.

Ha DefaultAzureCredential nem működik Önnél, tekintse meg ezt a hitelesítőadat-példát és identitáscsomagot.

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

Szerezzen fogópontot egy számítókapacitással rendelkező munkaterülethez.

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

# 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őkönyvtárába 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.

A folyamatfeladat elküldése a munkaterületre

Most, hogy már hozzáférése van a munkaterülethez, elküldheti a folyamat feladatát.

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

Az előző kód elküldi ezt a képosztályozási folyamatfeladatot egy úgynevezett pipeline_sampleskísérletnek. Automatikusan létrehozza a kísérletet, ha nem létezik. pipeline_input_data fashion_ds-t használ.

A kísérlet elküldésére irányuló hívás gyorsan befejeződik, és a következőhöz hasonló kimenetet hoz létre:

Kísérlet	Név	Típus	Állapot	Részletek lap
pipeline_samples	sharp_pipe_4gvqx6h1fb	értékesítési prognózis	Előkészítés	Hivatkozás az Azure Machine Learning Studióra

A folyamat futását a hivatkozás kiválasztásával követheti nyomon. Vagy megvárhatja, amíg befejeződik a kód futtatásával:

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

Fontos

Az első csővezeték futás körülbelül 15 percet tart. Minden függőség letöltődik, létrejön egy Docker-rendszerkép, és a Python-környezet ki van építve és létrehozva. A folyamat ismételt futtatása 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ásideje azonban a szkriptek számítási feladataitól és az egyes folyamatlépésekben futó folyamatoktól függ.

Kimenetek ellenőrzése és a folyamat hibakeresése a felhasználói felületen

Kiválaszthatja a Link to Azure Machine Learning studio, amely a kivitelezési folyamat feladatrészletező oldalát jelenti. Megjelenik a folyamatdiagram:

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éről további információt az Azure Machine Learning Studio használatával a folyamathibák hibakeresésével kapcsolatban talál.

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

Az előző szakaszokban egy három összetevőt használó folyamatot készített egy képbesorolási feladat elvégzéséhez. Az összetevőket regisztrálhatja a munkaterületen is, így azok megoszthatók és újra felhasználhatók a munkaterületen belül. Az alábbi példa bemutatja, hogyan regisztrálhatja az adat-előkészítési összetevőt:

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 regisztrált összetevőket név és verzió alapján is lekérheti ml_client.components.get() . A korábban Python-függvényből vagy YAML-ből betöltött összetevő regisztrálható a ml_client.components.create_or_update() használatával.

Következő lépések

• További példákért a folyamatoknak a Machine Learning SDK használatával történő kialakításához, lásd a példaadattárat.
• További információ a studio felhasználói felületének a folyamatok elküldéséhez és hibakereséséhez való használatával kapcsolatban: Gépi tanulási folyamatok létrehozása és futtatása összetevők használatával az Azure Machine Learning Studióval
• További információ arról, hogy az Azure Machine Learning CLI-vel összetevőket és folyamatokat hozhat létre, lásd : Gépi tanulási folyamatok létrehozása és futtatása összetevők használatával az Azure Machine Learning CLI-vel
• A pipeline-ek kötegelt végpontok használatával történő telepítéséhez szükséges információkért lásd: Pipeline-ek telepítése kötegelt végpontokkal