Oktatóanyag: Azure Machine Learning-folyamat létrehozása képosztályozáshoz

A KÖVETKEZŐKRE VONATKOZIK:Python SDK azureml v1

Megjegyzés

Az SDK v2-t egy folyamat létrehozásához használó oktatóanyagért tekintse meg a következő oktatóanyagot: Gépi tanulási folyamatok használata éles gépi tanulási munkafolyamatokhoz Python SDK v2-vel egy Jupyter Notebook.

Ebből az oktatóanyagból megtudhatja, hogyan hozhat létre egy Azure Machine Learning-folyamatot az adatok előkészítéséhez és egy gépi tanulási modell betanítása érdekében. 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.

Az oktatóanyagban az alábbi feladatokat fogja végrehajtani:

  • Munkaterület konfigurálása
  • Kísérlet létrehozása a munka megtartásához
  • ComputeTarget kiépítése a munka elvégzésére
  • Tömörített adatok tárolására szolgáló adatkészlet létrehozása
  • Folyamatlépés létrehozása az adatok betanításhoz való előkészítéséhez
  • Futtatókörnyezet definiálása, amelyben betanítást kell végezni
  • Folyamatlépés létrehozása a neurális hálózat meghatározásához és a betanítás végrehajtásához
  • Folyamat összeállítása a folyamat lépéseiből
  • A folyamat futtatása a kísérletben
  • A lépések kimenetének és a betanított neurális hálózatnak a áttekintése
  • A modell regisztrálása további használatra

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

Előfeltételek

  • Végezze el a rövid útmutatót: Ismerkedés az Azure Machine Learning szolgáltatással , ha még nem rendelkezik Azure Machine Learning-munkaterülettel.
  • Egy Python-környezet, amelyben a csomagokat és azureml-pipeline a azureml-core csomagokat is telepítette. Ez a környezet az Azure Machine Learning-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.

Fontos

Jelenleg a Legújabb Python-kiadás kompatibilis a Python 3.8-tal azureml-pipeline . Ha nem sikerül telepítenie a azureml-pipeline csomagot, győződjön meg arról, hogy python --version kompatibilis kiadásról van szó. Útmutatásért tekintse meg a Python virtuális környezet kezelőjének dokumentációját (venvcondaés így tovább).

Interaktív Python-munkamenet indítása

Ez az oktatóanyag az Azure ML-hez készült Python SDK-t használja egy Azure Machine Learning-folyamat létrehozásához és vezérléséhez. Az oktatóanyag feltételezi, hogy a kódrészleteket interaktív módon fogja futtatni Egy Python REPL-környezetben vagy egy Jupyter-notebookban.

  • Ez az oktatóanyag az image-classification.ipynbAzureML Examples-adattár könyvtárában python-sdk/tutorial/using-pipelines található jegyzetfüzeten alapul. Maguk a lépések forráskódja az keras-mnist-fashion alkönyvtárban található.

Importálási típusok

Importálja az oktatóanyaghoz szükséges összes Azure Machine Learning-típust:

import os
import azureml.core
from azureml.core import (
    Workspace,
    Experiment,
    Dataset,
    Datastore,
    ComputeTarget,
    Environment,
    ScriptRunConfig
)
from azureml.data import OutputFileDatasetConfig
from azureml.core.compute import AmlCompute
from azureml.core.compute_target import ComputeTargetException
from azureml.pipeline.steps import PythonScriptStep
from azureml.pipeline.core import Pipeline

# check core SDK version number
print("Azure ML SDK Version: ", azureml.core.VERSION)

Az Azure ML SDK-nak 1.37-es vagy újabb verziónak kell lennie. Ha nem, frissítsen a pip install --upgrade azureml-core.

Munkaterület konfigurálása

Hozzon létre egy munkaterület-objektumot a meglévő Azure Machine Learning-munkaterületről.

workspace = Workspace.from_config()

Fontos

Ez a kódrészlet elvárja, hogy a munkaterület konfigurációja az aktuális könyvtárba vagy annak szülőkönyvtárába legyen mentve. A munkaterületek létrehozásáról további információt a Munkaterület erőforrásainak létrehozása című témakörben talál. A konfiguráció fájlba való 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 folyamat infrastruktúrájának létrehozása

Hozzon létre egy Experiment objektumot a folyamatfuttatások eredményeinek tárolásához:

exp = Experiment(workspace=workspace, name="keras-mnist-fashion")

Hozzon létre egy ComputeTarget olyan gépet, amelyen a folyamat futni fog. Az ebben az oktatóanyagban használt egyszerű neurális hálózat mindössze néhány perc alatt beiktat egy CPU-alapú gépen is. Ha GPU-t szeretne használni a betanításhoz, állítsa a use_gpu következőre: True. A számítási cél üzembe helyezése általában körülbelül öt percet vesz igénybe.

use_gpu = False

# choose a name for your cluster
cluster_name = "gpu-cluster" if use_gpu else "cpu-cluster"

found = False
# Check if this compute target already exists in the workspace.
cts = workspace.compute_targets
if cluster_name in cts and cts[cluster_name].type == "AmlCompute":
    found = True
    print("Found existing compute target.")
    compute_target = cts[cluster_name]
if not found:
    print("Creating a new compute target...")
    compute_config = AmlCompute.provisioning_configuration(
        vm_size= "STANDARD_NC6" if use_gpu else "STANDARD_D2_V2"
        # vm_priority = 'lowpriority', # optional
        max_nodes=4,
    )

    # Create the cluster.
    compute_target = ComputeTarget.create(workspace, cluster_name, compute_config)

    # Can poll for a minimum number of nodes and for a specific timeout.
    # If no min_node_count is provided, it will use the scale settings for the cluster.
    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=10
    )
# For a more detailed view of current AmlCompute status, use get_status().print(compute_target.get_status().serialize())

Megjegyzés

A GPU rendelkezésre állása az Azure-előfizetés kvótájától és az Azure-kapacitástól függ. Lásd: Erőforrások kvótáinak kezelése és növelése az Azure Machine Learning használatával.

Adatkészlet létrehozása az Azure-ban tárolt adatokhoz

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

A webalapú adatokra hivatkozó Dataset adatok létrehozásához futtassa a következőt:

data_urls = ["https://data4mldemo6150520719.blob.core.windows.net/demo/mnist-fashion"]
fashion_ds = Dataset.File.from_files(data_urls)

# list the files referenced by fashion_ds
print(fashion_ds.to_path())

Ez a kód gyorsan befejeződik. A mögöttes adatok a tömbben megadott Azure Storage-erőforrásban data_urls maradnak.

Az adat-előkészítési folyamat lépésének létrehozása

A folyamat első lépése a saját munkaterületén lévő adatkészletbe konvertálja a tömörített adatfájlokat fashion_ds , amely a betanításhoz használatra kész CSV-fájlokat tartalmaz. Miután regisztrálták a munkaterületet, a közreműködők hozzáférhetnek ezekhez az adatokhoz a saját elemzésükhöz, betanításukhoz stb.

datastore = workspace.get_default_datastore()
prepared_fashion_ds = OutputFileDatasetConfig(
    destination=(datastore, "outputdataset/{run-id}")
).register_on_complete(name="prepared_fashion_ds")

A fenti kód egy folyamatlépés kimenetén alapuló adatkészletet határoz meg. A mögöttes feldolgozott fájlok a munkaterület alapértelmezett adattárának blobtárolójában lesznek elhelyezve a megadott destinationelérési úton. Az adatkészlet a munkaterületen lesz regisztrálva a névvel prepared_fashion_ds.

A folyamatlépés forrásának létrehozása

Az eddig végrehajtott kód Azure-erőforrásokat hoz létre és szabályoz. Itt az ideje, hogy olyan kódot írjon, amely elvégzi a tartomány első lépését.

Ha az AzureML-példák adattárában található példával együtt követi a műveletet, a forrásfájl már elérhető.keras-mnist-fashion/prepare.py

Ha az alapoktól dolgozik, hozzon létre egy alkönyvtárat .keras-mnist-fashion/ Hozzon létre egy új fájlt, adja hozzá a következő kódot, és nevezze el a fájlt prepare.py.

# prepare.py
# Converts MNIST-formatted files at the passed-in input path to a passed-in output path
import os
import sys

# Conversion routine for MNIST binary format
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()

# The MNIST-formatted source
mounted_input_path = sys.argv[1]
# The output directory at which the outputs will be written
mounted_output_path = sys.argv[2]

# Create the output directory
os.makedirs(mounted_output_path, exist_ok=True)

# Convert the training data
convert(
    os.path.join(mounted_input_path, "mnist-fashion/train-images-idx3-ubyte"),
    os.path.join(mounted_input_path, "mnist-fashion/train-labels-idx1-ubyte"),
    os.path.join(mounted_output_path, "mnist_train.csv"),
    60000,
)

# Convert the test data
convert(
    os.path.join(mounted_input_path, "mnist-fashion/t10k-images-idx3-ubyte"),
    os.path.join(mounted_input_path, "mnist-fashion/t10k-labels-idx1-ubyte"),
    os.path.join(mounted_output_path, "mnist_test.csv"),
    10000,
)

A beküldött prepare.py kód két parancssori argumentumot vesz fel: az elsőhöz, mounted_input_path a másodikhoz mounted_output_pathpedig a . Ha ez az alkönyvtár nem létezik, az azt létrehozó hívás os.makedirs . Ezután a program átalakítja a betanítási és tesztelési adatokat, és a vesszővel tagolt fájlokat a mounted_output_path.

A folyamat lépésének megadása

A folyamat megadásához használt Python-környezetben futtassa ezt a kódot az előkészítési kód létrehozásához PythonScriptStep :

script_folder = "./keras-mnist-fashion"

prep_step = PythonScriptStep(
    name="prepare step",
    script_name="prepare.py",
    # On the compute target, mount fashion_ds dataset as input, prepared_fashion_ds as output
    arguments=[fashion_ds.as_named_input("fashion_ds").as_mount(), prepared_fashion_ds],
    source_directory=script_folder,
    compute_target=compute_target,
    allow_reuse=True,
)

A hívás PythonScriptStep azt adja meg, hogy a folyamatlépés futtatásakor:

  • A könyvtárban lévő script_folder összes fájl fel lesz töltve a compute_target
  • A feltöltött forrásfájlok közül a fájl prepare.py futni fog
  • A fashion_ds rendszer csatlakoztatja az prepared_fashion_ds adatkészleteket, compute_target és címtárként jelenik meg
  • A fájlok elérési fashion_ds útja lesz a fájl első argumentuma prepare.py. Ebben prepare.pyaz argumentum a következőhöz van rendelve: mounted_input_path
  • Az elérési út a prepared_fashion_ds második argumentum a következőhöz prepare.py: . Ebben prepare.pyaz argumentum a következőhöz van rendelve: mounted_output_path
  • Mivel allow_reuse a Trueforrásfájlok vagy bemenetek megváltoznak, a rendszer nem futtatja újra.
  • Ez PythonScriptStep lesz a neve prepare step

A modularitás és az újrafelhasználás a folyamatok fő előnyei. Az Azure Machine Learning képes automatikusan meghatározni a forráskód- vagy adatkészlet-módosításokat. A nem érintett lépések kimenetét a rendszer a lépések újrafuttatása nélkül újra felhasználja, ha allow_reuse igen True. Ha egy lépés olyan, az Azure Machine Learningen kívüli adatforrásra támaszkodik, amely megváltozhat (például egy értékesítési adatokat tartalmazó URL-cím), akkor a folyamat minden futtatásakor be van állítva allow_reuseFalse , és a folyamatlépés is futni fog.

A betanítási lépés létrehozása

Miután az adatok a tömörített formátumból CSV-fájlokká lettek konvertálva, használhatók konvolúciós neurális hálózat betanítására.

A betanítási lépés forrásának létrehozása

Nagyobb folyamatok esetén célszerű az egyes lépések forráskódját külön könyvtárba helyezni (src/prepare/src/train/és így tovább), de ehhez az oktatóanyaghoz csak használja vagy hozza létre a fájlt train.py ugyanabban keras-mnist-fashion/ a forráskönyvtárban.

import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.layers.normalization import BatchNormalization
from keras.utils import to_categorical
from keras.callbacks import Callback

import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from azureml.core import Run

# dataset object from the run
run = Run.get_context()
dataset = run.input_datasets["prepared_fashion_ds"]

# split dataset into train and test set
(train_dataset, test_dataset) = dataset.random_split(percentage=0.8, seed=111)

# load dataset into pandas dataframe
data_train = train_dataset.to_pandas_dataframe()
data_test = test_dataset.to_pandas_dataframe()

img_rows, img_cols = 28, 28
input_shape = (img_rows, img_cols, 1)

X = np.array(data_train.iloc[:, 1:])
y = to_categorical(np.array(data_train.iloc[:, 0]))

# here we split validation data to optimiza classifier during training
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=13)

# test data
X_test = np.array(data_test.iloc[:, 1:])
y_test = to_categorical(np.array(data_test.iloc[:, 0]))


X_train = (
    X_train.reshape(X_train.shape[0], img_rows, img_cols, 1).astype("float32") / 255
)
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).astype("float32") / 255
X_val = X_val.reshape(X_val.shape[0], img_rows, img_cols, 1).astype("float32") / 255

batch_size = 256
num_classes = 10
epochs = 10

# construct neuron network
model = Sequential()
model.add(
    Conv2D(
        32,
        kernel_size=(3, 3),
        activation="relu",
        kernel_initializer="he_normal",
        input_shape=input_shape,
    )
)
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, (3, 3), activation="relu"))
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(128, activation="relu"))
model.add(Dropout(0.3))
model.add(Dense(num_classes, activation="softmax"))

model.compile(
    loss=keras.losses.categorical_crossentropy,
    optimizer=keras.optimizers.Adam(),
    metrics=["accuracy"],
)

# start an Azure ML run
run = Run.get_context()


class LogRunMetrics(Callback):
    # callback at the end of every epoch
    def on_epoch_end(self, epoch, log):
        # log a value repeated which creates a list
        run.log("Loss", log["loss"])
        run.log("Accuracy", log["accuracy"])


history = model.fit(
    X_train,
    y_train,
    batch_size=batch_size,
    epochs=epochs,
    verbose=1,
    validation_data=(X_val, y_val),
    callbacks=[LogRunMetrics()],
)

score = model.evaluate(X_test, y_test, verbose=0)

# log a single value
run.log("Final test loss", score[0])
print("Test loss:", score[0])

run.log("Final test accuracy", score[1])
print("Test accuracy:", score[1])

plt.figure(figsize=(6, 3))
plt.title("Fashion MNIST with Keras ({} epochs)".format(epochs), fontsize=14)
plt.plot(history.history["accuracy"], "b-", label="Accuracy", lw=4, alpha=0.5)
plt.plot(history.history["loss"], "r--", label="Loss", lw=4, alpha=0.5)
plt.legend(fontsize=12)
plt.grid(True)

# log an image
run.log_image("Loss v.s. Accuracy", plot=plt)

# create a ./outputs/model folder in the compute target
# files saved in the "./outputs" folder are automatically uploaded into run history
os.makedirs("./outputs/model", exist_ok=True)

# serialize NN architecture to JSON
model_json = model.to_json()
# save model JSON
with open("./outputs/model/model.json", "w") as f:
    f.write(model_json)
# save model weights
model.save_weights("./outputs/model/model.h5")
print("model saved in ./outputs/model folder")

A kód nagy részének ismerősnek kell lennie az ML-fejlesztők számára:

  • Az adatok betanítási és érvényesítési készletekre, a végső pontozáshoz pedig egy külön teszt részhalmazra lesznek felosztva
  • A bemeneti alakzat 28x28x1 (csak 1, mert a bemenet szürkeárnyalatos), egy kötegben 256 bemenet lesz, és 10 osztály van
  • A betanítási alapidőszakok száma 10 lesz
  • A modell három konvolúciós réteggel rendelkezik, a maximális készletezéssel és a dropouttal, amelyet egy sűrű réteg és egy softmax fej követ
  • A modell 10 alapidőszakra van illesztve, majd kiértékelésre kerül
  • A modellarchitektúra meg van írva, outputs/model/model.json és a súlyozása outputs/model/model.h5

A kód egy része azonban az Azure Machine Learningre jellemző. run = Run.get_context() A lekéri az Run aktuális szolgáltatáskörnyezetet tartalmazó objektumot. A train.py forrás ezzel az run objektummal kéri le a bemeneti adathalmazt a nevével (az adathalmazt argv a szkriptargumentumok tömbjében lekért kód prepare.py helyett).

Az run objektum arra is használható, hogy naplózza a betanítási folyamatot minden alapidőszak végén, és a betanítás végén naplózza a veszteség és a pontosság grafikonját az idő függvényében.

A betanítási folyamat lépésének létrehozása

A betanítási lépés valamivel összetettebb konfigurációval rendelkezik, mint az előkészítési lépés. Az előkészítési lépés csak standard Python-kódtárakat használt. Általában módosítania kell a futtatókörnyezetet, amelyben a forráskód fut.

Hozzon létre egy fájlt conda_dependencies.yml a következő tartalommal:

dependencies:
- python=3.7
- pip:
  - azureml-core
  - azureml-dataset-runtime
  - keras==2.4.3
  - tensorflow==2.4.3
  - numpy
  - scikit-learn
  - pandas
  - matplotlib

Az Environment osztály azt a futtatókörnyezetet jelöli, amelyben egy gépi tanulási feladat fut. Társítsa a fenti specifikációt a betanítási kódhoz a következőkkel:

keras_env = Environment.from_conda_specification(
    name="keras-env", file_path="./conda_dependencies.yml"
)

train_cfg = ScriptRunConfig(
    source_directory=script_folder,
    script="train.py",
    compute_target=compute_target,
    environment=keras_env,
)

Maga a betanítási lépés létrehozása az előkészítési lépés létrehozásához használt kódhoz hasonló kódot használ:

train_step = PythonScriptStep(
    name="train step",
    arguments=[
        prepared_fashion_ds.read_delimited_files().as_input(name="prepared_fashion_ds")
    ],
    source_directory=train_cfg.source_directory,
    script_name=train_cfg.script,
    runconfig=train_cfg.run_config,
)

A folyamat létrehozása és futtatása

Most, hogy megadta az adatbemeneteket és -kimeneteket, és létrehozta a folyamat lépéseit, összeállíthatja őket egy folyamatba, és futtathatja azt:

pipeline = Pipeline(workspace, steps=[prep_step, train_step])
run = exp.submit(pipeline)

A Pipeline létrehozott objektum a sajátjában workspace fut, és a megadott előkészítési és betanítási lépésekből áll.

Megjegyzés

Ez a folyamat egy egyszerű függőségi gráftal rendelkezik: a betanítási lépés az előkészítési lépésre, az előkészítési lépés pedig az fashion_ds adathalmazra támaszkodik. Az éles folyamatok gyakran sokkal összetettebb függőségekkel rendelkeznek. A lépések több felsőbb rétegbeli lépésre is támaszkodhatnak, a forráskód egy korai lépésben történő módosítása messzemenő következményekkel járhat, és így tovább. Az Azure Machine Learning nyomon követi ezeket az aggodalmakat. Csak a tömböt kell megadnia steps , és az Azure Machine Learning gondoskodik a végrehajtási gráf kiszámításáról.

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

Submitted PipelineRun 5968530a-abcd-1234-9cc1-46168951b5eb
Link to Azure Machine Learning Portal: https://ml.azure.com/runs/abc-xyz...

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

run.wait_for_completion(show_output=True)

Fontos

Az első folyamatfuttatás nagyjából 15 percet vesz igénybe. Minden függőséget le kell tölteni, létre kell hozni egy Docker-rendszerképet, és létre kell hozni a Python-környezetet. A folyamat újbóli 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.

A folyamat befejezése után lekérheti a betanítási lépésben naplózott metrikákat:

run.find_step_run("train step")[0].get_metrics()

Ha elégedett a metrikákkal, regisztrálhatja a modellt a munkaterületen:

run.find_step_run("train step")[0].register_model(
    model_name="keras-model",
    model_path="outputs/model/",
    datasets=[("train test data", fashion_ds)],
)

Az erőforrások eltávolítása

Ne fejezze be ezt a szakaszt, ha más Azure Machine Learning-oktatóanyagokat szeretne futtatni.

A számítási példány leállítása

Ha számítási példányt használt, állítsa le a virtuális gépet, ha nem használja a költségek csökkentésére.

  1. A munkaterületen válassza a Számítás lehetőséget.

  2. A listából válassza ki a számítási példány nevét.

  3. Válassza a Leállítás lehetőséget.

  4. Ha készen áll a kiszolgáló újbóli használatára, válassza a Start gombot.

Minden törlése

Ha nem tervezi használni a létrehozott erőforrásokat, törölje őket, így nem kell fizetnie:

  1. A Azure Portal bal oldali menüjében válassza az Erőforráscsoportok lehetőséget.
  2. Az erőforráscsoportok listájában válassza ki a létrehozott erőforráscsoportot.
  3. Válassza az Erőforráscsoport törlése elemet.
  4. Írja be az erőforráscsoport nevét. Ezután válassza a Törlés lehetőséget.

Megtarthatja az erőforráscsoportot is, de egyetlen munkaterületet törölhet. Jelenítse meg a munkaterület tulajdonságait, majd válassza a Törlés lehetőséget.

Következő lépések

Ebben az oktatóanyagban a következő típusokat használta:

  • Az Workspace Azure Machine Learning-munkaterületet jelöli. Tartalmazta:
    • A Experiment folyamat betanítási futtatásainak eredményeit tartalmazó fájl
    • A Dataset Fashion-MNIST adattárban tárolt adatok lusta betöltése
    • Az ComputeTarget a gép(ek), amelyen a folyamat lépései futnak
    • Az Environment a futtatókörnyezet, amelyben a folyamatlépések futnak
    • A Pipeline lépések összeírása egy PythonScriptStep egészbe
    • A Model betanítási folyamattal való elégedettség után regisztrált

Az Workspace objektum más erőforrásokra (jegyzetfüzetekre, végpontokra stb.) mutató hivatkozásokat tartalmaz, amelyeket az oktatóanyag nem használt. További információ: Mi az az Azure Machine Learning-munkaterület?

A OutputFileDatasetConfig futtatás kimenetét fájlalapú adathalmazra előlépteti. Az adathalmazokról és az adatok használatáról az Adatok elérése című témakörben talál további információt.

A számítási célokkal és környezetekkel kapcsolatos további információkért lásd: Mik azok a számítási célok az Azure Machine Learningben? és mik azok az Azure Machine Learning-környezetek?

Az ScriptRunConfig a ComputeTarget és Environment a Python-forrásfájlokat társítja. Az A PythonScriptStep ezt ScriptRunConfig veszi, és meghatározza a bemeneteit és kimeneteit, amelyek ebben a folyamatban a fájl adatkészlete, amelyet a OutputFileDatasetConfig.

További példák a folyamatok gépi tanulási SDK-val történő létrehozására: a példaadattár.