Azure Machine Learning SDK v2 ile bileşenleri kullanarak makine öğrenmesi işlem hatları oluşturma ve çalıştırma

UYGULANANLAR: Python SDK'sı azure-ai-ml v2 (geçerli)

Bu makalede, görüntü sınıflandırma görevini tamamlamak için Azure Machine Learning Python SDK v2 kullanarak Azure Machine Learning işlem hattı oluşturmayı öğreneceksiniz. Bu işlem hattı üç adım içerir: verileri hazırlama, görüntü sınıflandırma modelini eğitme ve modeli puanlama. Machine Learning işlem hatları iş akışınızı hız, taşınabilirlik ve yeniden kullanım ile iyileştirerek altyapı ve otomasyon yerine makine öğrenmesine odaklanmanızı sağlar.

Örnek işlem hattı, 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. İşlem hattı şu şekilde görünür:

Bu makalede aşağıdaki görevleri tamamlaacaksınız:

• İşlem hattı işi için giriş verilerini hazırlama
• Verileri hazırlamak, modeli eğitmek ve modeli puanlayan üç bileşen oluşturma
• Bileşenlerden bir işlem hattı oluşturun
• İşlem içeren bir çalışma alanına erişim elde etme
• İşlem hattı işini gönderme
• Bileşenlerin ve eğitilen sinir ağının çıkışını gözden geçirin
• (İsteğe bağlı) Çalışma alanı içinde daha fazla yeniden kullanım ve paylaşım için bileşeni 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ı. Kaynağınız yoksa Kaynak oluşturma öğreticisini tamamlayın.
• Azure Machine Learning Python SDK v2 yüklü bir Python ortamı. Yükleme yönergeleri için bkz. Başlarken. 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.
• Örnek deposunun bir kopyası.

Eğitim örneklerini çalıştırmak için önce örnek deposunu kopyalayın ve dizinine sdk gidin:

git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/sdk

Etkileşimli python oturumu başlatma

Bu makalede, Azure Machine Learning işlem hattı oluşturmak ve denetlemek için Azure Machine Learning Python SDK'sı kullanılmaktadır. Makalede kod parçacıklarını python REPL ortamında veya Jupyter not defterinde etkileşimli olarak çalıştırdığınız varsayılır.

Bu makale, Azure Machine Learning örnekleri deposunun dizinindeki sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnetimage_classification_keras_minist_convnet.ipynb not defterini temel alır.

Gerekli kitaplıkları içeri aktarma

Bu makale için ihtiyacınız olan tüm Azure Machine Learning kitaplıklarını içeri aktarın:

# 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

İşlem hattı işiniz için giriş verilerini hazırlama

Görüntü sınıflandırma işlem hattı için giriş verilerini hazırlamanız gerekir.

Fashion MNIST, moda görüntülerinin 10 sınıfa ayrılmış bir veri kümesidir. Her görüntü 28 x 28 gri tonlamalı bir görüntüdür. 60.000 eğitim görüntüsü ve 10.000 test görüntüsü vardır.

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

bir Inputtanımlayarak, veri kaynağı konumuna bir başvuru oluşturursunuz. Veriler mevcut konumunda kalır, bu nedenle ek depolama maliyeti uygulanmaz.

İşlem hattını oluşturmak için bileşenler oluşturma

Görüntü sınıflandırma görevi üç adıma ayrılabilir: verileri hazırlama, modeli eğitme ve modeli puanlama.

Azure Machine Learning bileşeni, makine öğrenmesi işlem hattındaki bir adımı tamamlayan, bağımsız bir kod parçasıdır. Bu makalede, görüntü sınıflandırma görevi için üç bileşen oluşturacaksınız:

• Eğitim ve test için veri hazırlama
• Eğitim verilerini kullanarak bir sinir ağını görüntü sınıflandırması için eğitin
• Test verilerini kullanarak modeli puanla

Her bileşen için şu adımları tamamlarsınız:

1. Yürütme mantığını içeren Python betiğini hazırlama
2. Bileşenin arabirimini tanımlama
3. Bileşeni çalıştırmak için çalışma zamanı ortamı ve komutu da dahil olmak üzere bileşenin diğer meta verilerini ekleyin

Sonraki bölümlerde, bileşenlerin iki şekilde nasıl oluşturulacağı gösterilmektedir. İlk iki bileşen için bir Python işlevi kullanırsınız. Üçüncü bileşen için YAML tanımını kullanırsınız.

Veri hazırlama bileşenini oluşturma

Bu işlem hattındaki ilk bileşen, sıkıştırılmış veri dosyalarını fashion_ds biri eğitim, diğeri puanlama için iki .csv dosyaya dönüştürür. Bu bileşeni tanımlamak için bir Python işlevi kullanırsınız.

Azure Machine Learning örnekleri deposundaki örnekle birlikte takip ediyorsanız, kaynak dosyalar zaten prep klasöründe mevcuttur. Bu klasör, bileşeni oluşturmak için iki dosya içerir: prep_component.pybileşeni tanımlayan ve conda.yamlbileşenin çalışma zamanı ortamını tanımlayan .

Python işlevi kullanarak bileşen tanımlama

İşlevi command_component() dekoratör olarak kullanarak bileşenin arabirimini, meta verilerini ve python işlevinden çalıştırılacak kodu kolayca tanımlayabilirsiniz. Dekore edilmiş her Python işlevi, işlem hattı hizmetinin işleyebileceği tek bir statik belirtime (YAML) dönüştürülür.

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

Yukarıdaki kod, dekoratör kullanarak Prep Data görünen ada @command_component sahip bir bileşeni tanımlar:

• name bileşenin benzersiz tanımlayıcısı

• version bileşenin geçerli sürümüdür. Bir bileşenin birden çok sürümü olabilir

• display_name kullanıcı arabirimi için bileşenin kolay görünen adıdır

• description bileşenin tamamlayabildiği görevi açıklar

• environment conda.yaml dosyası kullanan bileşenin çalışma zamanı ortamını belirtir

  Dosya, conda.yaml bileşen için kullanılan tüm paketleri içerir:

  name: imagekeras_prep_conda_env
  channels:
    - defaults
  dependencies:
    - python=3.7.11
    - pip=20.0
    - pip:
      - mldesigner==0.1.0b4
  

• prepare_data_component işlevi, input_data için bir giriş ve training_data ve test_data için iki çıkış tanımlar.

  • input_data giriş veri yoludur
  • training_data ve test_data eğitim verileri ve test verileri için çıkış veri yollarıdır

• Bileşen, verileri eğitim verileri input_data için bir training_data .csv dosyasına ve test verileri için .csv test_data dosyasına dönüştürür

Stüdyo kullanıcı arabiriminde bir bileşen şöyle görünür:

• İşlem hattı grafiğindeki bir blok
• input_data, training_datave test_data , veri akışı için diğer bileşenlere bağlanan bileşenin bağlantı noktalarıdır

Şimdi bileşen için tüm kaynak dosyaları hazırladınız Prep Data .

Model eğitim bileşenini oluşturma

Bu bölümde, daha önce Prep Data bileşeninde yaptığınız gibi, bir Python işlevi kullanarak görüntü sınıflandırma modelini eğiten bir bileşen oluşturacaksınız.

Eğitim mantığı daha karmaşık olduğundan, eğitim kodunu ayrı bir Python dosyasına koyarsınız.

Bu bileşenin kaynak dosyaları train klasörde yer alır. Bu klasör, bileşeni oluşturmak için üç dosya içerir:

• train.py modeli eğitmek için mantığı içerir
• train_component.py bileşenin arabirimini tanımlar ve işlevi train.py içe aktarır
• conda.yaml bileşenin çalışma zamanı ortamını tanımlar

Bir mantık içeren betiği al

Dosya, train.py görüntü sınıflandırması için Keras sinir ağını eğiten mantığı gerçekleştiren normal bir Python işlevi içerir. Kodu görüntülemek için GitHub'da train.py dosyasına bakın.

Python işlevi kullanarak bileşeni tanımlama

Eğitim işlevini tanımladıktan sonra, işlevinizi Azure Machine Learning işlem hatlarında kullanılmak üzere bir bileşen olarak sarmak için Azure Machine Learning SDK v2'de kullanabilirsiniz @command_component :

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)

Yukarıdaki kod, Train Image Classification Keras kullanarak @command_component görünen adına sahip bir bileşen tanımlar.

keras_train_component işlevi şunu tanımlar:

• Kaynak eğitim verileri için input_data tek bir giriştir.
• Eğitim sırasında kullanılacak dönem sayısını belirten bir giriş, epochs
• Model dosyasının çıkış yolunu belirten bir çıkış, output_model.

varsayılan değeri epochs 10'dur. Bu bileşenin mantığı train() işlevinden gelir.

Eğitim modeli bileşeni, veri hazırlama bileşeninden daha karmaşık bir yapılandırmaya sahiptir. şuna conda.yaml benzer:

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

Şimdi bileşen için tüm kaynak dosyaları hazırladınız Train Image Classification Keras .

Model puanlama bileşenini oluşturma

Bu bölümde, YAML belirtimini ve betiğini kullanarak eğitilen modeli puanlandıracak bir bileşen oluşturacaksınız.

Azure Machine Learning örnekleri deposundaki örnekle birlikte takip ediyorsanız, kaynak dosyalar zaten score klasöründe mevcuttur. Bu klasör, bileşeni oluşturmak için üç dosya içerir:

• score.py bileşenin kaynak kodunu içerir
• score.yaml bileşenin arabirimini ve diğer ayrıntılarını tanımlar
• conda.yaml bileşenin çalışma zamanı ortamını tanımlar

Bir mantık içeren betiği al

Dosya, score.py model puanlama mantığını gerçekleştiren normal bir Python işlevi içerir:

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)

score.py içindeki kod üç komut satırı bağımsız değişkeni alır: input_data, input_model ve output_result. Program giriş modelini giriş verilerini kullanarak puanlar ve ardından sonucu döndürür.

YAML kullanarak bileşeni tanımlama

Bu bölümde, geçerli YAML bileşen belirtimi biçiminde bir bileşen belirtimi oluşturmayı öğreneceksiniz. Bu dosya aşağıdaki bilgileri belirtir:

• Meta veriler: Ad, görünen ad, sürüm, tür vb.
• Arabirim: Girişler ve çıkışlar
• Komut, kod ve ortam: Bileşeni çalıştırmak için kullanılan komut, kod ve ortam

$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 , bileşenin benzersiz tanımlayıcısıdır. Görünen adı şudur: Score Image Classification Keras
• Bu bileşenin iki girişi ve bir çıkışı vardır
• Kaynak kod yolu bölümünde tanımlanır code . Bileşen bulutta çalıştırıldığında, bu yoldan gelen tüm dosyalar bileşenin anlık görüntüsü olarak karşıya yüklenir
• bölümü, command bileşen çalıştırıldığında yürütülecek komutu belirtir
• bölümü environment bir Docker görüntüsü ve conda YAML dosyası içerir. Kaynak dosya örnek depoda

Artık model puanlama bileşeni için tüm kaynak dosyalara sahipsiniz.

İşlem hattı oluşturmak için bileşenleri yükleyin

Veri hazırlama bileşenini ve normal Python işlevleri gibi Python işlevleri tarafından tanımlanan model eğitim bileşenini içeri aktarabilirsiniz.

Aşağıdaki kod, prepare_data_component() klasöründeki keras_train_component() dosyasından prep_component.py ve prep işlevlerini, sırasıyla train_component klasöründeki train dosyasından içeri aktarır.

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

yaml tarafından tanımlanan puan bileşenini yüklemek için işlevini kullanabilirsiniz load_component() .

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

Kayıtlı bileşenleri çalışma alanından yükleme

Not

Kayıtlı bileşenleri çalışma alanınızdan yüklemek için önce Çalışma alanınıza erişim alma bölümünde açıklandığı gibi çalışma alanı bağlantınızı yapılandırmanız gerekir. ml_client Nesnesi aşağıdaki işlemler için gereklidir.

Çalışma alanınızda zaten kayıtlı olan bileşenleriniz varsa, doğrudan yöntemini kullanarak ml_client.components.get() bunları yükleyebilirsiniz. Bu yaklaşım, daha önce sizin tarafınızdan kaydedilmiş veya diğer ekip üyeleri tarafından paylaşılan bileşenleri yeniden kullanmak istediğinizde kullanışlıdır.

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

İhtiyacınız olanları bulmak için çalışma alanınızdaki tüm kullanılabilir bileşenleri listeleyebilirsiniz:

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

Yüklendikten sonra, yerel dosyalardan veya Python işlevlerinden yüklenen bileşenler gibi işlem hattınızda kayıtlı bileşenleri kullanabilirsiniz.

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

İşlem hattını oluşturmak için tüm bileşenleri ve giriş verilerini oluşturdunuz ve yüklediniz. Artık bunları bir işlem hattında oluşturabilirsiniz:

Not

Sunucusuz işlem kullanmak için dosyanın en üstüne ekleyinfrom azure.ai.ml.entities import ResourceConfiguration. Ardından şunu değiştirin:

• default_compute=cpu_compute_target ile default_compute="serverless"
• train_node.compute = gpu_compute_target ile 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)

İşlem hattının varsayılan bir işlem vardır cpu_compute_target. Belirli bir düğüm için işlem belirtmezseniz, bu düğüm varsayılan işlemde çalışır.

İşlem hattının işlem hattı düzeyinde girişi vardır. pipeline_input_data İşlem hattı işini gönderirken, işlem hattı girdisine bir değer atayabilirsiniz.

İşlem hattı üç düğüm içerir: prepare_data_node, train_nodeve score_node:

• input_data, prepare_data_node değerini kullanırpipeline_input_data
• input_data öğesinin train_node öğesindeki training_data çıktısı prepare_data_node'dur
• input_data, score_node öğesinin test_data çıktısıdır ve prepare_data_node, input_model öğesinin output_model değeridir.
• train_node Bir CNN modelini eğittiğiniz için, eğitim performansını geliştirmek için bu modelin işlemini olarak gpu_compute_target belirtebilirsiniz

İşlem hattı işinizi gönderme

artık işlem hattını oluşturduğunuza göre, işi çalışma alanınıza gönderebilirsiniz. bir iş göndermek için önce bir çalışma alanına bağlanmanız gerekir.

Çalışma alanınıza erişim elde etme

Kimlik bilgilerini yapılandırma

Çalışma alanına erişmek için DefaultAzureCredential öğesini kullanırsınız. DefaultAzureCredential Azure SDK kimlik doğrulama senaryolarının çoğunu işleyebilmeli.

Sizin için işe yaramazsa DefaultAzureCredentialbu kimlik bilgisi yapılandırma örneğine ve kimlik Paketi'ne bakın.

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

Hesaplama gücüne sahip bir çalışma alanına erişim noktası alma

Azure Machine Learning hizmetlerini yönetmek için bir MLClient nesne oluşturun. Sunucusuz işlem kullanıyorsanız bu işlemleri oluşturmanız gerekmez.

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

Önemli

Bu kod parçacığı, çalışma alanı yapılandırma JSON dosyası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ı bir dosyaya kaydetme hakkında daha fazla bilgi için bkz. Çalışma alanı yapılandırma dosyası oluşturma.

İşlem hattı işini çalışma alanına gönderme

Artık çalışma alanınızı kontrol altına aldığınıza göre işlem hattı görevinizi gönderebilirsiniz.

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

Yukarıdaki kod, bu görüntü sınıflandırma işlem hattı işini adlı pipeline_samplesbir denemeye gönderir. Sistem deneme mevcut değilse, otomatik olarak oluşturur. pipeline_input_data kullanır fashion_ds.

Denemeyi gönderme çağrısı hızla tamamlanıp şuna benzer bir çıkış oluşturur:

Deneme	Adı	Tip	Durum	Ayrıntılar sayfası
pipeline_samples	sharp_pipe_4gvqx6h1fb	ardışık düzen	Hazırlanıyor	Azure Machine Learning studio bağlantısı

Bağlantıyı seçerek işlem hattı çalışmasını izleyebilirsiniz. Ya da bu kodu çalıştırarak tamamlanmasını bekleyebilirsiniz:

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

Önemli

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

Kullanıcı arabiriminde çıkışları denetleme ve işlem hattınızda hata ayıklama

İşlem hattınızın iş ayrıntı sayfası olan Link to Azure Machine Learning studio'yi seçebilirsiniz. İşlem hattı grafiğini görürsünüz:

Bileşene sağ tıklayarak her bileşenin günlüklerini ve çıkışlarını denetleyebilirsiniz veya bileşeni seçerek ayrıntı bölmesini açabilirsiniz. Kullanıcı arabiriminde işlem hattı hatalarını nasıl ayıklayacağınızı öğrenmek için Azure Machine Learning studio'yu kullanarak işlem hattı hatalarını ayıklama bölümüne bakın.

(İsteğe bağlı) Bileşenleri çalışma alanına kaydetme

Önceki bölümlerde, bir görüntü sınıflandırma görevini tamamlamak için üç bileşen kullanarak bir işlem hattı oluşturmıştınız. Ayrıca, çalışma alanı içinde paylaşılabilmeleri ve yeniden kullanılabilmesi için bileşenleri çalışma alanınıza kaydedebilirsiniz. Aşağıdaki örnekte veri hazırlama bileşeninin nasıl kaydedilecekleri gösterilmektedir:

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)

Kayıtlı bir bileşeni ada ve sürüme göre almak için kullanabilirsiniz ml_client.components.get() . Daha önce bir Python işlevinden veya YAML'den yüklenen bir bileşeni kaydetmek için kullanabilirsiniz ml_client.components.create_or_update() .

Sonraki adımlar

• Makine öğrenmesi SDK'sını kullanarak işlem hatları oluşturma hakkında daha fazla örnek için örnek depoya bakın
• İşlem hattını göndermek ve hatalarını ayıklamak için studio kullanıcı arabirimini kullanma hakkında bilgi için bkz. Azure Machine Learning studio ile bileşenleri kullanarak makine öğrenmesi işlem hatlarını oluşturma ve çalıştırma
• Bileşenleri ve işlem hatlarını oluşturmak için Azure Machine Learning CLI kullanma hakkında bilgi için bkz. Azure Machine Learning CLI ile bileşenleri kullanarak makine öğrenmesi işlem hatları oluşturma ve çalıştırma
• İşlem hatlarını toplu iş uç noktalarını kullanarak üretime dağıtma hakkında bilgi için bkz. İşlem hatlarını toplu iş uç noktalarıyla dağıtma