Öğretici: Görüntü sınıflandırması için Azure Machine Learning işlem hattı oluşturma

ŞUNLAR IÇIN GEÇERLIDIR:Python SDK azureml v1

Not

İşlem hattı oluşturmak için SDK v2 kullanan bir öğretici için bkz. Öğretici: Jupyter Notebook Python SDK v2 ile üretim ML iş akışları için ML işlem hatlarını kullanma.

Bu öğreticide, verileri hazırlamak ve makine öğrenmesi modelini eğitmek için Azure Machine Learning işlem hattı oluşturmayı öğreneceksiniz. Makine öğrenmesi işlem hatları iş akışınızı hız, taşınabilirlik ve yeniden kullanma ile iyileştirerek altyapı ve otomasyon yerine makine öğrenmesine odaklanmanızı sağlar.

Örnek, Fashion MNIST veri kümesindeki görüntüleri sınıflandırmak için küçük bir Keras kıvrımlı sinir ağını eğitmektedir.

Bu öğreticide, aşağıdaki görevleri tamamlayacaksınız:

• Çalışma alanını yapılandırma
• Çalışmanızı tutmak için Deneme oluşturma
• İşi yapmak için bir ComputeTarget sağlama
• Sıkıştırılmış verilerin depolandığı bir Veri Kümesi oluşturma
• Verileri eğitime hazırlamak için işlem hattı adımı oluşturma
• Eğitimin gerçekleştirildiği bir çalışma zamanı ortamı tanımlama
• Sinir ağını tanımlamak ve eğitimi gerçekleştirmek için işlem hattı adımı oluşturma
• İşlem hattı adımlarından bir İşlem Hattı oluşturma
• Denemede işlem hattını çalıştırma
• Adımların ve eğitilen sinir ağının çıkışını gözden geçirin
• Modeli daha fazla kullanım için kaydetme

Azure aboneliğiniz yoksa başlamadan önce ücretsiz bir hesap oluşturun. Azure Machine Learning'in ücretsiz veya ücretli sürümünü bugün deneyin.

Önkoşullar

• Azure Machine Learning çalışma alanınız yoksa başlamak için kaynak oluşturma bölümünü tamamlayın.
• hem hem de azureml-coreazureml-pipeline paketlerini yüklediğiniz bir Python ortamı. Bu ortam, Azure Machine Learning kaynaklarınızı tanımlamaya ve denetlemeye yöneliktir ve çalışma zamanında eğitim için kullanılan ortamdan ayrıdır.

Önemli

Şu anda ile azureml-pipeline uyumlu en son Python sürümü Python 3.8'dir. Paketi yüklemekte azureml-pipeline güçlük çekiyorsanız uyumlu bir sürüm olduğundan python --version emin olun. Yönergeler için Python sanal ortam yöneticinizin (venv, condavb.) belgelerine bakın.

Etkileşimli bir Python oturumu başlatma

Bu öğreticide Azure Machine Learning işlem hattı oluşturmak ve denetlemek için Azure Machine Learning için Python SDK'sı kullanılır. Öğreticide kod parçacıklarını python REPL ortamında veya Jupyter not defterinde etkileşimli olarak çalıştırabileceğiniz varsayılır.

• Bu öğretici, Azure Machine Learning Örnekleri deposunun python-sdk/tutorial/using-pipelines dizininde bulunan not defterini temel alırimage-classification.ipynb. Adımların kaynak kodu alt dizindedir keras-mnist-fashion .

İçeri aktarma türleri

Bu öğretici için ihtiyacınız olan tüm Azure Machine Learning türlerini içeri aktarın:

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)

Azure Machine Learning SDK sürümü 1.37 veya üzeri olmalıdır. Değilse, ile pip install --upgrade azureml-coreyükseltin.

Çalışma alanını yapılandırma

Mevcut Azure Machine Learning çalışma alanından bir çalışma alanı nesnesi oluşturun.

workspace = Workspace.from_config()

Önemli

Bu kod parçacığı, çalışma alanı yapılandırmasının geçerli dizine veya üst dizinine kaydedilmesini bekler. Çalışma alanı oluşturma hakkında daha fazla bilgi için bkz. Çalışma alanı kaynakları oluşturma. Yapılandırmayı dosyaya kaydetme hakkında daha fazla bilgi için bkz. Çalışma alanı yapılandırma dosyası oluşturma.

İşlem hattınızın altyapısını oluşturma

İşlem hattı çalıştırmalarınızın sonuçlarını tutacak bir Experiment nesne oluşturun:

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

İşlem hattınızın üzerinde çalıştırılacağı makine kaynağını temsil eden bir ComputeTarget oluşturun. Bu öğreticide kullanılan basit sinir ağı, CPU tabanlı bir makinede bile yalnızca birkaç dakika içinde eğitildi. Eğitim için bir GPU kullanmak istiyorsanız olarak ayarlayın use_gpuTrue. İşlem hedefinin sağlanması genellikle yaklaşık beş dakika sürer.

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

Not

GPU kullanılabilirliği, Azure aboneliğinizin kotalarına ve Azure kapasitesine bağlıdır. Bkz. Azure Machine Learning ile kaynaklar için kotaları yönetme ve artırma.

Azure'da depolanan veriler için veri kümesi oluşturma

Fashion-MNIST, moda görüntülerinin 10 sınıfa ayrılmış bir veri kümesidir. Her görüntü 28x28 gri tonlamalı bir görüntüdür ve 60.000 eğitim ve 10.000 test görüntüsü vardır. Görüntü sınıflandırma sorunu olarak Fashion-MNIST, klasik MNIST el yazısı dijital veritabanından daha zordur. Özgün el yazısı basamak veritabanıyla aynı sıkıştırılmış ikili biçimde dağıtılır.

Web tabanlı verilere başvuran bir Dataset oluşturmak için şunu çalıştırın:

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

Bu kod hızlı bir şekilde tamamlar. Temel alınan veriler dizide belirtilen Azure depolama kaynağında data_urls kalır.

Veri hazırlama işlem hattı adımı oluşturma

Bu işlem hattının ilk adımı, sıkıştırılmış veri dosyalarını fashion_ds eğitimde kullanıma hazır CSV dosyalarından oluşan kendi çalışma alanınızdaki bir veri kümesine dönüştürür. Çalışma alanına kaydolan işbirlikçileriniz bu verilere kendi çözümlemeleri, eğitimleri vb. için erişebilir

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

Yukarıdaki kod, işlem hattı adımının çıktısını temel alan bir veri kümesini belirtir. Temel alınan işlenen dosyalar, çalışma alanının varsayılan veri deposunun blob depolama alanına içinde destinationbelirtilen yola konur. Veri kümesi çalışma alanına adıyla prepared_fashion_dskaydedilir.

İşlem hattı adımının kaynağını oluşturma

Şimdiye kadar yürüttüğüniz kod, Azure kaynaklarını oluşturup denetledi. Şimdi etki alanındaki ilk adımı oluşturan kodu yazma zamanı geldi.

Azure Machine Learning Örnekleri deposundaki örnekle birlikte takip ediyorsanız, kaynak dosya olarak zaten kullanılabilirkeras-mnist-fashion/prepare.py.

Sıfırdan çalışıyorsanız adlı keras-mnist-fashion/bir alt dizin oluşturun. Yeni bir dosya oluşturun, aşağıdaki kodu ekleyin ve dosyayı prepare.pyolarak adlandırın.

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

içindeki prepare.py kod iki komut satırı bağımsız değişkeni alır: birincisi öğesine mounted_input_path , ikincisi ise öğesine mounted_output_pathatanır. Bu alt dizin yoksa, çağrısı os.makedirs onu oluşturur. Ardından program, eğitim ve test verilerini dönüştürür ve virgülle ayrılmış dosyaları 'ye dönüştürür mounted_output_path.

İşlem hattı adımını belirtme

İşlem hattını belirtmek için kullandığınız Python ortamına geri döndüğünüzde bu kodu çalıştırarak hazırlık kodunuz için bir PythonScriptStep oluşturun:

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ğrısı PythonScriptStep , işlem hattı adımı çalıştırıldığında şunları belirtir:

• Dizindeki script_folder tüm dosyalar compute_target
• Karşıya yüklenen kaynak dosyalar arasında dosya prepare.py çalıştırılır
• fashion_ds ve prepared_fashion_ds veri kümeleri üzerine compute_target bağlanacak ve dizin olarak görünecektir
• Dosyaların yolu fashion_ds , için ilk bağımsız değişken prepare.pyolacaktır. içinde prepare.py, bu bağımsız değişken öğesine atanır mounted_input_path
• yolunun prepared_fashion_ds yolu, için ikinci bağımsız değişken prepare.pyolacaktır. içinde prepare.py, bu bağımsız değişken öğesine atanır mounted_output_path
• olduğundan allow_reuseTrue, kaynak dosyaları veya girişleri değişene kadar yeniden çalıştırılamaz
• Bu PythonScriptStep ad verilecektir prepare step

Modülerlik ve yeniden kullanım, işlem hatlarının önemli avantajlarıdır. Azure Machine Learning, kaynak kodu veya Veri kümesi değişikliklerini otomatik olarak belirleyebilir. Etkilenmemiş bir adımın çıktısı ise allow_reuseTrue, adımlar yeniden çalıştırılmadan yeniden kullanılır. Bir adım, Azure Machine Learning dışındaki bir veri kaynağının değişmesine (örneğin, satış verilerini içeren bir URL) dayanırsa, işlem hattı her çalıştırıldığında işlem hattı adımı olarak ayarlanır allow_reuseFalse ve işlem hattı adımı çalışır.

Eğitim adımını oluşturma

Veriler sıkıştırılmış biçimden CSV dosyalarına dönüştürüldükten sonra, kıvrımlı bir sinir ağını eğitmek için kullanılabilir.

Eğitim adımının kaynağını oluşturma

Daha büyük işlem hatlarında, her adımın kaynak kodunu ayrı bir dizine (src/prepare/, src/train/vb.) koymak iyi bir uygulamadır, ancak bu öğretici için dosyayı train.py aynı keras-mnist-fashion/ kaynak dizinde kullanmanız veya oluşturmanız gerekir.

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

Bu kodun çoğu ML geliştiricilerine tanıdık gelmelidir:

• Veriler eğitim için eğitim ve doğrulama kümelerine ve son puanlama için ayrı bir test alt kümesine ayrılmıştır
• Giriş şekli 28x28x1'dir (giriş gri tonlamalı olduğundan yalnızca 1), toplu işte 256 giriş olur ve 10 sınıf vardır
• Eğitim dönemlerinin sayısı 10 olacaktır
• Modelde maksimum havuz ve bırakma ile birlikte üç kıvrımlı katman ve ardından yoğun bir katman ve softmax başlığı vardır
• Model 10 dönem için uydurulur ve ardından değerlendirilir
• Model mimarisi için ve outputs/model/model.json ağırlıkları outputs/model/model.h5

Ancak kodlardan bazıları Azure Machine Learning'e özgüdür. run = Run.get_context() geçerli hizmet bağlamını içeren bir Run nesnesi alır. Kaynak, train.py giriş veri kümesini adıyla almak için bu run nesneyi kullanır (betik bağımsız değişkenleri dizisi aracılığıyla veri kümesini alan kodun prepare.pyargv alternatifi).

run nesnesi ayrıca her dönem sonunda eğitim ilerleme durumunu günlüğe kaydetmek ve eğitimin sonunda zaman içindeki kayıp ve doğruluk grafiğini günlüğe kaydetmek için kullanılır.

Eğitim işlem hattı adımı oluşturma

Eğitim adımı, hazırlık adımından biraz daha karmaşık bir yapılandırmaya sahiptir. Hazırlık adımında yalnızca standart Python kitaplıkları kullanıldı. Daha yaygın olarak, kaynak kodunuzun çalıştığı çalışma zamanı ortamını değiştirmeniz gerekir.

Aşağıdaki içeriklere sahip bir dosya conda_dependencies.yml oluşturun:

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

sınıfı, Environment bir makine öğrenmesi görevinin çalıştığı çalışma zamanı ortamını temsil eder. Yukarıdaki belirtimi eğitim koduyla ilişkilendirin:

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

Eğitim adımının kendisi oluşturulurken, hazırlık adımı oluşturmak için kullanılan koda benzer bir kod kullanılır:

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

İşlem hattını oluşturma ve çalıştırma

Artık veri girişlerini ve çıkışlarını belirttiğinize ve işlem hattınızın adımlarını oluşturduğunuza göre, bunları bir işlem hattında oluşturup çalıştırabilirsiniz:

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

Pipeline Oluşturduğunuz nesne, içinde workspace çalışır ve belirttiğiniz hazırlık ve eğitim adımlarından oluşur.

Not

Bu işlem hattının basit bir bağımlılık grafiği vardır: eğitim adımı hazırlık adımına dayanır ve hazırlık adımı veri kümesine fashion_ds dayanır. Üretim işlem hatlarının genellikle çok daha karmaşık bağımlılıkları olacaktır. Adımlar birden çok yukarı akış adımına dayanabilir, erken bir adımda yapılan kaynak kodu değişikliğinin çok çeşitli sonuçları olabilir ve bu şekilde devam edebilir. Azure Machine Learning bu endişeleri sizin için izler. Yalnızca dizisini steps geçirmeniz gerekir ve Azure Machine Learning yürütme grafını hesaplamayı üstlenir.

çağrısı submitExperiment hızla tamamlanıp şuna benzer bir çıkış üretir:

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

Bağlantıyı açarak işlem hattı çalıştırmasını izleyebilir veya çalıştırarak tamamlanana kadar engelleyebilirsiniz:

run.wait_for_completion(show_output=True)

Önemli

İlk işlem hattı çalıştırması yaklaşık 15 dakika sürer. Tüm bağımlılıkların indirilmesi, bir Docker görüntüsü oluşturulması ve Python ortamının sağlanıp oluşturulması gerekir. İşlem hattının yeniden çalıştırılması önemli ölçüde daha az zaman alır çünkü bu kaynaklar oluşturulmak yerine yeniden kullanılır. Ancak, işlem hattının toplam çalışma süresi betiklerinizin iş yüküne ve her işlem hattı adımında çalışan işlemlere bağlıdır.

İşlem hattı tamamlandıktan sonra eğitim adımında günlüğe kaydettiğiniz ölçümleri alabilirsiniz:

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

Ölçümlerden memnunsanız modeli çalışma alanınıza kaydedebilirsiniz:

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

Kaynakları temizleme

Diğer Azure Machine Learning öğreticilerini çalıştırmayı planlıyorsanız bu bölümü tamamlamayın.

İşlem örneğini durdurma

İşlem örneği kullandıysanız, maliyeti azaltmak için vm'yi kullanmadığınız zamanlarda durdurun.

1. Çalışma alanınızda İşlem'i seçin.

2. Listeden işlem örneğinin adını seçin.

3. Durdur'u seçin.

4. Sunucuyu yeniden kullanmaya hazır olduğunuzda Başlat'ı seçin.

Her şeyi sil

Oluşturduğunuz kaynakları kullanmayı planlamıyorsanız, ücret ödememek için bunları silin:

1. Azure portal soldaki menüden Kaynak grupları'nı seçin.
2. Kaynak grupları listesinde, oluşturduğunuz kaynak grubunu seçin.
3. Kaynak grubunu sil'i seçin.
4. Kaynak grubu adını girin. Ardından Sil'i seçin.

Ayrıca kaynak grubunu tutabilir ancak tek bir çalışma alanını silebilirsiniz. Çalışma alanı özelliklerini görüntüleyin ve sil'i seçin.

Sonraki adımlar

Bu öğreticide aşağıdaki türleri kullandınız:

• , Workspace Azure Machine Learning çalışma alanınızı temsil eder. İçeren:
  • İşlem Experiment hattınızın eğitim çalıştırmalarının sonuçlarını içeren
  • Dataset Fashion-MNIST veri deposunda tutulan verileri gizlice yükleyen
  • İşlem ComputeTarget hattı adımlarının üzerinde çalıştığı makineleri temsil eden
  • İşlem Environment hattı adımlarının çalıştırıldığı çalışma zamanı ortamıdır
  • Adımları Pipeline bir bütün halinde PythonScriptStep oluşturan
  • Model Eğitim sürecinden memnun olduktan sonra kaydettiğiniz

Workspace nesnesi, bu öğreticide kullanılmayan diğer kaynaklara (not defterleri, uç noktalar vb.) başvurular içerir. Daha fazla bilgi için bkz. Azure Machine Learning çalışma alanı nedir?.

, OutputFileDatasetConfig bir çalıştırmanın çıkışını dosya tabanlı bir veri kümesine yükselter. Veri kümeleri ve verilerle çalışma hakkında daha fazla bilgi için bkz. Verilere erişme.

İşlem hedefleri ve ortamları hakkında daha fazla bilgi için bkz. Azure Machine Learning'de işlem hedefleri nelerdir? ve Azure Machine Learning ortamları nelerdir?

, ScriptRunConfig bir ComputeTarget ve'yi Environment Python kaynak dosyalarıyla ilişkilendirir. A PythonScriptStep bunu ScriptRunConfig alır ve girişlerini ve çıkışlarını tanımlar; bu işlem hattında tarafından OutputFileDatasetConfigoluşturulan dosya veri kümesidir.

Makine öğrenmesi SDK'sını kullanarak işlem hatları oluşturma hakkında daha fazla örnek için örnek depoya bakın.