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

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

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 kullanımla iyileştirerek altyapı ve otomasyon yerine makine öğrenmesine odaklanabilmenizi 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:

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-core azureml-pipeline paketlerini yüklediğiniz bir Python ortamı. Bu ortam, Azure Machine Learning kaynaklarınızı tanımlamaya ve denetlemeye yöneliktir ve eğitim için çalışma zamanında kullanılan ortamdan ayrıdır.

Etkileşimli 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()

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

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

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

İşlem hattınızın ç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_gpu True. İş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())

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ı basamak 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ı eğitimde kullanıma hazır CSV dosyalarından fashion_ds oluşan kendi çalışma alanınızdaki bir veri kümesine dönüştürür. Çalışma alanına kaydolan ortak çalışanlarınız 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ümesi belirtir. Temel alınan işlenen dosyalar, çalışma alanının varsayılan veri deposunun blob depolama alanına içinde destinationbelirtilen yola yerleştirilecektir. 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ında ilk adımı atacak kodu yazmanın zamanı geldi.

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

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ı ' mounted_output_patha dönüştürür.

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

İşlem hattını belirtmek için kullandığınız Python ortamına dönün, hazırlık kodunuz için bir PythonScriptStep oluşturmak üzere şu kodu çalıştırın:

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ğlanır ve dizin olarak görünür
• 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_reuse True, 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 temel 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_reuse Trueadımları yeniden çalıştırmadan yeniden kullanılır. Bir adım, Azure Machine Learning dışında değişebilecek bir veri kaynağına (örneğin, satış verilerini içeren bir URL) dayanırsa, işlem hattı her çalıştırıldığında olarak ayarlanır allow_reuse False 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ı 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ıyla, her adımın kaynak kodunu ayrı bir dizine (src/prepare/, src/train/vb.) koymak iyi bir uygulamadır, ancak bu öğreticide dosyayı train.py aynı keras-mnist-fashion/ kaynak dizinde kullanmanız veya oluşturmanız yeterlidir.

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ılı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 açılır menü ile birlikte üç konvolüsyon 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 mimarisinin outputs/model/model.json yazıldı ve 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 (veri kümesini betik bağımsız değişkenleri dizisi aracılığıyla alan kodun prepare.py argv 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ılmıştır. 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 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.

çağrısı submit Experiment hızla tamamlanıp şuna benzer bir çıkış oluşturur:

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 şu komutu çalıştırarak tamamlanana kadar engelleyebilirsiniz:

run.wait_for_completion(show_output=True)

İş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ızda 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, herhangi bir ücret ödememek için bunları silin:

1. Azure portalının sol menüsünde 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 koruyabilir, 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 yanlışlıkla 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 işleminden memnun olduktan sonra kaydettiğiniz

nesnesi, Workspace 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ı nedir?

, ScriptRunConfig a ComputeTarget ve öğesini 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 hattı oluşturma hakkında daha fazla örnek için örnek depoya bakın.