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

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

Megjegyzés

A folyamat létrehozásához az SDK v2-t használó oktatóanyagért lásd: Oktatóanyag: Ml-folyamatok használata éles gépi tanulási munkafolyamatokhoz Python SDK v2-vel egy Jupyter Notebook.

Ebben az oktatóanyagban megtudhatja, hogyan hozhat létre Azure Machine Learning-folyamatot az adatok előkészítéséhez és 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, hogy a képeket a Fashion MNIST adatkészletbe sorolja.

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 definiálásához és a betanítás végrehajtásához
• Folyamat írása a folyamat lépéseiből
• A folyamat futtatása a kísérletben
• Tekintse át a lépések kimenetét és a betanított neurális hálózatot
• 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 ma az Azure Machine Learning ingyenes vagy fizetős verzióját .

Előfeltételek

• Ha még nem rendelkezik Azure Machine Learning-munkaterületpel, végezze el az Erőforrások létrehozása elemet az első lépésekhez .
• Egy Python-környezet, amelyben a és azureml-pipeline a azureml-core csomagokat is telepítette. 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.

Fontos

Jelenleg a Legújabb Python-kiadás kompatibilis a Python 3.8-tal azureml-pipeline . Ha nehézséget okozott a azureml-pipeline csomag telepítése, 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 (venvstb conda.).

Interaktív Python-munkamenet indítása

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

• Ez az oktatóanyag az image-classification.ipynbAzure Machine Learning 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 Machine Learning SDK Version: ", azureml.core.VERSION)

Az Azure Machine Learning SDK-verziónak 1.37-es vagy újabbnak kell lennie. Ha nem, frissítsen a használatával 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ület létrehozásával kapcsolatos további információkért lásd: Munkaterület-erőforrások létrehozása. 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 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, amely azt a gépi erőforrást jelöli, amelyen a folyamat futni fog. Az oktatóanyagban használt egyszerű neurális hálózat néhány perc alatt leképezést nyújt még egy CPU-alapú gépen is. Ha GPU-t szeretne használni a betanításhoz, állítsa a következőre use_gpu : 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: Az erőforráskvóták kezelése és növelése az Azure Machine Learninggel.

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

Fashion-MNIST egy adatkészlet a divat képek osztva 10 osztályok. 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, kézzel írt MNIST számjegyadatbázis. Ugyanazon tömörített bináris formában van elosztva, mint az eredeti kézzel írt számjegyadatbázis .

A webalapú adatokra hivatkozó létrehozáshoz Dataset 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 tömörített adatfájlok fashion_ds egy saját munkaterületen lévő adatkészletté alakítja át, amely a betanításhoz használatra kész CSV-fájlokat tartalmaz. Miután regisztrált a munkaterületen, a közreműködők hozzáférhetnek ezekhez az adatokhoz a saját elemzésük, betanításuk stb. érdekében.

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 adathalmaz regisztrálva lesz a munkaterületen a következő néven prepared_fashion_ds: .

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

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

Ha az Azure Machine Learning Examples adattárban található példával együtt követi a műveletet, a forrásfájl már elérhető a következő néven keras-mnist-fashion/prepare.py: .

Ha az alapoktól dolgozik, hozzon létre egy nevű 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 benne lévő prepare.py kód két parancssori argumentumot vesz fel: az elsőhöz, mounted_input_path a másodikhoz pedig.mounted_output_path Ha ez az alkönyvtár nem létezik, a hívás os.makedirs hozza létre. Ezután a program átalakítja a betanítási és tesztelési adatokat, és a vesszővel tagolt fájlokat a mounted_output_pathkövetkezőre alakítja: .

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 határozza 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ájlt prepare.py a rendszer futtatja
• A fashion_ds és prepared_fashion_ds az adatkészletek a könyvtárban compute_target lesznek csatlakoztatva, és címtárként jelennek meg
• A fájlok elérési fashion_ds útja a következő első argumentuma lesz: prepare.py. A fájlban prepare.pyez az argumentum a következőhöz van rendelve: mounted_input_path
• A elérési út a prepared_fashion_ds második argumentuma lesz a következőnek prepare.py: . A fájlban prepare.pyez az argumentum a következőhöz van rendelve: mounted_output_path
• Mivel allow_reuse az , Truenem fut újra, amíg a forrásfájlok vagy a bemenetek nem változnak
• Ez PythonScriptStep lesz a neve prepare step

A modularitás és az újrafelhasználás a folyamatok fő előnyei. Az Azure Machine Learning automatikusan képes meghatározni a forráskódot vagy az adatkészlet módosításait. A nem érintett lépés kimenete a lépések újrafuttatása nélkül lesz újra felhasználva, ha allow_reuse az .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 beállítás értéke allow_reuseFalse és a folyamatlépés a folyamat minden futtatásakor futni fog.

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

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

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

Nagyobb folyamatokkal célszerű minden lépés forráskódját külön könyvtárba helyezni (src/prepare/, src/train/stb.), de ebben az oktatóanyagban 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 ismernie kell az ML-fejlesztőket:

• Az adatok betanítási és érvényesítési készletekbe lesznek particionálva a betanításhoz, valamint egy külön tesztrészkészlet a végső pontozáshoz
• A bemeneti alakzat 28x28x1 (csak 1, mert a bemenet szürkeárnyalatos), 256 bemenet lesz egy kötegben, é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 beállítva, majd kiértékelésre kerül
• A modellarchitektúra a következőre 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() egy objektumot Run kér le, amely az aktuális szolgáltatáskörnyezetet tartalmazza. A train.py forrás ezzel az run objektummal kéri le a bemeneti adathalmazt a nevével (az adathalmazt argv szkriptargumentumok tömbjében lekért kód prepare.py helyett).

Az run objektumot arra is használják, hogy minden alapidőszak végén naplózza a betanítási folyamatot, é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 azt 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ővel:

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át fájljá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áfot tartalmaz: 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, egy korai lépésben a forráskód módosítása messzemenő következményekkel járhat, és így tovább. Az Azure Machine Learning nyomon követi ezeket az aggályokat. 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 hoz létre:

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 befejeződik a következő parancs 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-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.

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ése érdekében.

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

2. A listában 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:

• A Workspace az Azure Machine Learning-munkaterületet jelöli. A következőket 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 folyamatlépések futnak
  • Ez Environment az a futtatókörnyezet, amelyben a folyamat lépései futnak
  • Az Pipeline , amely a PythonScriptStep lépéseket egy egészbe írja
  • A Model betanítási folyamattal való elégedettség után regisztrált

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

A OutputFileDatasetConfig előlépteti egy futtatás kimenetét egy fájlalapú adathalmazba. További információ az adatkészletekről és az adatok használatáról: Adatok elérése.

További információ a számítási célokról és környezetekről: Mik azok a számítási célok az Azure Machine Learningben? és Mik azok az Azure Machine Learning-környezetek?

Az ScriptRunConfig és a-t EnvironmentComputeTarget társítja a Python-forrásfájlokhoz. Az PythonScriptStep ezt veszi fel ScriptRunConfig , és meghatározza a bemeneteit és kimeneteit, amelyek ebben a folyamatban a által létrehozott fájladatkészletet eredményezték OutputFileDatasetConfig.

További példák arra, hogyan hozhat létre folyamatokat a Machine Learning SDK használatával, tekintse meg a példaadattárat.