öğretici: toplu puanlama için Azure Machine Learning işlem hattı oluşturma

bu gelişmiş öğreticide, batch puanlama işi çalıştırmak için Azure Machine Learning işlem hattı oluşturmayı öğreneceksiniz. Makine öğrenimi ardışık düzenleri, iş akışınızı hız, taşınabilirlik ve yeniden kullanım açısından iyileştirerek altyapı ve otomasyon yerine makine öğrenimine odaklanmanıza olanak sağlayabilir. Bir işlem hattı derleyip yayımladıktan sonra, işlem hattını herhangi bir platformda herhangi bir HTTP kitaplığından tetiklemek için kullanabileceğiniz bir REST uç noktası yapılandırırsınız.

Örnek, etiketli görüntüleri sınıflandırmak için TensorFlow 'da uygulanan önceden eğitilen Inception-v3 sinir ağ modelini kullanır.

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 ücretsiz veya ücretli sürümünü bugün deneyin.

Önkoşullar

• hızlı başlangıcı doldurun: zaten bir Azure Machine Learning çalışma alanınız veya işlem örneğiniz yoksa Azure Machine Learning kullanmaya başlayın .
• Hızlı başlangıç adımlarını tamamladıktan sonra:
  1. Studio 'da Not defterleri ' ni seçin.
  2. Örnekler sekmesini seçin.
  3. Öğreticiler/Machine-Learning-Pipelines-Advanced/tutorial-Pipeline-Batch-Scoring-Classification. ipynb Not defterini açın.

Kurulum öğreticisini kendi Yerel ortamınızdaçalıştırmak istiyorsanız, öğreticiye GitHuberişebilirsiniz. pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requestsGerekli paketleri almak için öğesini çalıştırın.

Çalışma alanını yapılandırma ve veri deposu oluşturma

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

from azureml.core import Workspace
ws = Workspace.from_config()

Örnek görüntüler için bir veri deposu oluşturma

pipelinedataHesapta, sampledata genel blob kapsayıcısından ımagenet değerlendirmesi ortak veri örneğini alın. register_azure_blob_container()Verileri, ad altında çalışma alanı için kullanılabilir hale getirmek için çağırın images_datastore . Daha sonra, çalışma alanı varsayılan veri deposunu çıkış veri deposu olarak ayarlayın. İşlem hattındaki çıktıyı öğrenmek için çıkış veri deposunu kullanın.

Verilere erişme hakkında daha fazla bilgi için bkz. verilere erişme.

from azureml.core.datastore import Datastore

batchscore_blob = Datastore.register_azure_blob_container(ws, 
                      datastore_name="images_datastore", 
                      container_name="sampledata", 
                      account_name="pipelinedata", 
                      overwrite=True)

def_data_store = ws.get_default_datastore()

Veri kümesi nesneleri oluşturma

İşlem hatları oluştururken, Dataset nesneler çalışma alanı veri depolarından verileri okumak için kullanılır ve OutputFileDatasetConfig nesneler işlem hattı adımları arasında ara verileri aktarmak için kullanılır.

Bu senaryoda, Dataset hem giriş görüntüleri hem de sınıflandırma etiketleri (y-test değerleri) için veri deposu dizinlerine karşılık gelen nesneler oluşturursunuz. OutputFileDatasetConfigToplu Puanlama çıkış verileri için de bir nesne oluşturun.

from azureml.core.dataset import Dataset
from azureml.data import OutputFileDatasetConfig

input_images = Dataset.File.from_files((batchscore_blob, "batchscoring/images/"))
label_ds = Dataset.File.from_files((batchscore_blob, "batchscoring/labels/"))
output_dir = OutputFileDatasetConfig(name="scores")

Daha sonra yeniden kullanmak istiyorsanız veri kümelerini çalışma alanına kaydedin. Bu adım isteğe bağlıdır.

input_images = input_images.register(workspace = ws, name = "input_images")
label_ds = label_ds.register(workspace = ws, name = "label_ds")

Modeli indir ve Kaydet

Bir işlem hattındaki toplu Puanlama için kullanmak üzere önceden eğitilen TensorFlow modelini indirin. İlk olarak, modeli depoladığınız yerel bir dizin oluşturun. Ardından, modeli indirip ayıklayın.

import os
import tarfile
import urllib.request

if not os.path.isdir("models"):
    os.mkdir("models")
    
response = urllib.request.urlretrieve("http://download.tensorflow.org/models/inception_v3_2016_08_28.tar.gz", "model.tar.gz")
tar = tarfile.open("model.tar.gz", "r:gz")
tar.extractall("models")

Ardından, modeli işlem hattı işleminde kolayca alabilmeniz için çalışma alanınıza kaydedin. register()Statik işlevde model_name parametresi SDK genelinde modelinizi bulmak için kullandığınız anahtardır.

from azureml.core.model import Model
 
model = Model.register(model_path="models/inception_v3.ckpt",
                       model_name="inception",
                       tags={"pretrained": "inception"},
                       description="Imagenet trained tensorflow inception",
                       workspace=ws)

Uzaktan işlem hedefini oluşturma ve iliştirme

Makine öğrenimi ardışık düzenleri yerel olarak çalıştırılamaz, bu nedenle bunları bulut kaynaklarında veya uzak işlem hedeflerinde çalıştırmalısınız. Uzaktan işlem hedefi, denemeleri ve makine öğrenimi iş akışlarını çalıştırdığınız yeniden kullanılabilir bir sanal işlem ortamıdır.

GPU etkin bir AmlCompute hedef oluşturmak ve ardından çalışma alanınıza eklemek için aşağıdaki kodu çalıştırın. İşlem hedefleri hakkında daha fazla bilgi için kavramsal makaleyebakın.

from azureml.core.compute import AmlCompute, ComputeTarget
from azureml.exceptions import ComputeTargetException
compute_name = "gpu-cluster"

# checks to see if compute target already exists in workspace, else create it
try:
    compute_target = ComputeTarget(workspace=ws, name=compute_name)
except ComputeTargetException:
    config = AmlCompute.provisioning_configuration(vm_size="STANDARD_NC6",
                                                   vm_priority="lowpriority", 
                                                   min_nodes=0, 
                                                   max_nodes=1)

    compute_target = ComputeTarget.create(workspace=ws, name=compute_name, provisioning_configuration=config)
    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

Puanlama betiği yazma

Puanlama yapmak için, adlı bir Batch Puanlama betiği oluşturun batch_scoring.py ve sonra geçerli dizine yazın. Betik, giriş görüntülerini alır, sınıflandırma modelini uygular ve daha sonra tahminleri bir sonuç dosyasına çıkarır.

batch_scoring.pyBetik, daha sonra oluşturduğunuz sunucudan geçirilen aşağıdaki parametreleri alır ParallelRunStep :

• --model_name: Kullanılan modelin adı.
• --labels_dir: labels.txt Dosyanın konumu.

İşlem hattı altyapısı, ArgumentParser parametreleri işlem hattı adımlarına geçirmek için sınıfını kullanır. Örneğin, aşağıdaki kodda, ilk bağımsız değişkene --model_name özellik tanımlayıcısı verilir model_name . init()İşlevinde, Model.get_model_path(args.model_name) Bu özelliğe erişmek için kullanılır.

%%writefile batch_scoring.py

import os
import argparse
import datetime
import time
import tensorflow as tf
from math import ceil
import numpy as np
import shutil
from tensorflow.contrib.slim.python.slim.nets import inception_v3

from azureml.core import Run
from azureml.core.model import Model
from azureml.core.dataset import Dataset

slim = tf.contrib.slim

image_size = 299
num_channel = 3


def get_class_label_dict(labels_dir):
    label = []
    labels_path = os.path.join(labels_dir, 'labels.txt')
    proto_as_ascii_lines = tf.gfile.GFile(labels_path).readlines()
    for l in proto_as_ascii_lines:
        label.append(l.rstrip())
    return label


def init():
    global g_tf_sess, probabilities, label_dict, input_images

    parser = argparse.ArgumentParser(description="Start a tensorflow model serving")
    parser.add_argument('--model_name', dest="model_name", required=True)
    parser.add_argument('--labels_dir', dest="labels_dir", required=True)
    args, _ = parser.parse_known_args()

    label_dict = get_class_label_dict(args.labels_dir)
    classes_num = len(label_dict)

    with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
        input_images = tf.placeholder(tf.float32, [1, image_size, image_size, num_channel])
        logits, _ = inception_v3.inception_v3(input_images,
                                              num_classes=classes_num,
                                              is_training=False)
        probabilities = tf.argmax(logits, 1)

    config = tf.ConfigProto()
    config.gpu_options.allow_growth = True
    g_tf_sess = tf.Session(config=config)
    g_tf_sess.run(tf.global_variables_initializer())
    g_tf_sess.run(tf.local_variables_initializer())

    model_path = Model.get_model_path(args.model_name)
    saver = tf.train.Saver()
    saver.restore(g_tf_sess, model_path)


def file_to_tensor(file_path):
    image_string = tf.read_file(file_path)
    image = tf.image.decode_image(image_string, channels=3)

    image.set_shape([None, None, None])
    image = tf.image.resize_images(image, [image_size, image_size])
    image = tf.divide(tf.subtract(image, [0]), [255])
    image.set_shape([image_size, image_size, num_channel])
    return image


def run(mini_batch):
    result_list = []
    for file_path in mini_batch:
        test_image = file_to_tensor(file_path)
        out = g_tf_sess.run(test_image)
        result = g_tf_sess.run(probabilities, feed_dict={input_images: [out]})
        result_list.append(os.path.basename(file_path) + ": " + label_dict[result[0]])
    return result_list

İşlem hattını oluşturma

İşlem hattını çalıştırmadan önce, Python ortamını tanımlayan bir nesne oluşturun ve batch_scoring.py betiğinizin gerektirdiği bağımlılıkları oluşturur. Gereken ana bağımlılık TensorFlow ' dır, ancak aynı zamanda azureml-core azureml-dataprep[fuse] ParallelRunStep için gereklidir. Ayrıca, Docker ve Docker-GPU desteği de belirtin.

from azureml.core import Environment
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.runconfig import DEFAULT_GPU_IMAGE

cd = CondaDependencies.create(pip_packages=["tensorflow-gpu==1.15.2",
                                            "azureml-core", "azureml-dataprep[fuse]"])
env = Environment(name="parallelenv")
env.python.conda_dependencies = cd
env.docker.base_image = DEFAULT_GPU_IMAGE

Betiği kaydırmak için yapılandırma oluştur

Komut dosyası, ortam yapılandırması ve parametreleri kullanarak işlem hattı adımını oluşturun. Çalışma alanınıza zaten eklediğiniz işlem hedefini belirtin.

from azureml.pipeline.steps import ParallelRunConfig

parallel_run_config = ParallelRunConfig(
    environment=env,
    entry_script="batch_scoring.py",
    source_directory=".",
    output_action="append_row",
    mini_batch_size="20",
    error_threshold=1,
    compute_target=compute_target,
    process_count_per_node=2,
    node_count=1
)

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

İşlem hattı adımı, aşağıdakiler dahil olmak üzere bir işlem hattı çalıştırmak için ihtiyacınız olan her şeyi kapsülleyen bir nesnedir:

• Ortam ve bağımlılık ayarları
• İşlem hattının çalıştırılacağı işlem kaynağı
• Giriş ve çıkış verileri ve tüm özel parametreler
• Adım sırasında çalışacak bir betik veya SDK mantığına başvuru

Birden çok sınıf üst sınıftan devralınır PipelineStep . Bir adım oluşturmak için belirli çerçeveleri veya yığınları kullanmak üzere sınıfları seçebilirsiniz. Bu örnekte, ParallelRunStep özel bir Python betiği kullanarak adım mantığınızı tanımlamak için sınıfını kullanırsınız. Betiğinizin bir bağımsız değişkeni, adımın bir girişi ya da adımın bir çıkışı ise, bağımsız değişkenin sırasıyla hem dizide hem de ya da parametresinde tanımlanması arguments gerekir input output .

Birden fazla adımın olduğu senaryolarda dizideki bir nesne başvurusu, outputs sonraki bir işlem hattı adımı için giriş olarak kullanılabilir hale gelir.

from azureml.pipeline.steps import ParallelRunStep
from datetime import datetime

parallel_step_name = "batchscoring-" + datetime.now().strftime("%Y%m%d%H%M")

label_config = label_ds.as_named_input("labels_input")

batch_score_step = ParallelRunStep(
    name=parallel_step_name,
    inputs=[input_images.as_named_input("input_images")],
    output=output_dir,
    arguments=["--model_name", "inception",
               "--labels_dir", label_config],
    side_inputs=[label_config],
    parallel_run_config=parallel_run_config,
    allow_reuse=False
)

Farklı adım türleri için kullanabileceğiniz tüm sınıfların bir listesi için, bkz. adımlar paketi.

İşlem hattını gönderme

Şimdi işlem hattını çalıştırın. İlk olarak, Pipeline çalışma alanı başvurusunu ve oluşturduğunuz işlem hattı adımını kullanarak bir nesne oluşturun. stepsParametresi bir adım dizisidir. Bu durumda, toplu Puanlama için yalnızca bir adım vardır. Birden çok adım içeren işlem hatları oluşturmak için, adımları Bu dizide sırayla yerleştirin.

Sonra, işlem hattını Experiment.submit() yürütmeye göndermek için işlevini kullanın. wait_for_completionİşlevi, işlem hattı derleme işlemi sırasında günlükleri çıktı olarak verir. Geçerli ilerlemeyi görmek için günlükleri kullanabilirsiniz.

from azureml.core import Experiment
from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[batch_score_step])
pipeline_run = Experiment(ws, 'Tutorial-Batch-Scoring').submit(pipeline)
pipeline_run.wait_for_completion(show_output=True)

Çıkışı indirme ve gözden geçirme

Betikten oluşturulan çıkış dosyasını indirmek için aşağıdaki kodu batch_scoring.py çalıştırın. Ardından puanlama sonuçlarını keşfedin.

import pandas as pd

batch_run = next(pipeline_run.get_children())
batch_output = batch_run.get_output_data("scores")
batch_output.download(local_path="inception_results")

for root, dirs, files in os.walk("inception_results"):
    for file in files:
        if file.endswith("parallel_run_step.txt"):
            result_file = os.path.join(root, file)

df = pd.read_csv(result_file, delimiter=":", header=None)
df.columns = ["Filename", "Prediction"]
print("Prediction has ", df.shape[0], " rows")
df.head(10)

REST uç noktasını yayımlama ve çalıştırma

İşlem hattını çalışma alanınıza yayımlamak için aşağıdaki kodu çalıştırın. Azure Machine Learning Studio'daki çalışma alanınız içinde, çalıştırma geçmişi ve süreleri de dahil olmak üzere işlem hattı meta verilerini görebilir. İşlem hattını stüdyodan el ile de çalıştırabilirsiniz.

İşlem hattını yayımlamak, işlem hattını herhangi bir platformda herhangi bir HTTP kitaplığından çalıştırmak için kullanabileceğiniz bir REST uç noktası sağlar.

published_pipeline = pipeline_run.publish_pipeline(
    name="Inception_v3_scoring", description="Batch scoring using Inception v3 model", version="1.0")

published_pipeline

İşlem hattını REST uç noktalarından çalıştırmak için OAuth2 Taşıyıcı türü kimlik doğrulaması üst bilgisi gerekir. Aşağıdaki örnekte etkileşimli kimlik doğrulaması (çizim amacıyla) kullanılır, ancak otomatik veya başsız kimlik doğrulaması gerektiren çoğu üretim senaryosunda, bu makalede açıklandığı gibi hizmet sorumlusu kimlik doğrulamasını kullanın.

Hizmet sorumlusu kimlik doğrulaması, uygulamasında uygulama kaydı Azure Active Directory. İlk olarak bir gizli dizi oluşturun ve ardından hizmet sorumlusu rolünüze makine öğrenmesi çalışma alanınıza erişim izni ve ardından bu gizli diziyi kullanın. Kimlik doğrulama ServicePrincipalAuthentication akışınızı yönetmek için sınıfını kullanın.

hem InteractiveLoginAuthentication hem de ServicePrincipalAuthentication 'den devralın. AbstractAuthentication Her iki durumda da, get_authentication_header() üst bilgi getirmek için işlevini aynı şekilde kullanın:

from azureml.core.authentication import InteractiveLoginAuthentication

interactive_auth = InteractiveLoginAuthentication()
auth_header = interactive_auth.get_authentication_header()

Yayımlanan işlem hattı nesnesinin özelliğinden REST endpoint URL'sini elde edin. REST URL'sini Azure Machine Learning Studio'daki çalışma alanınıza da bulabilirsiniz.

Uç noktasına bir HTTP POST isteği oluşturma. İstekte kimlik doğrulaması üst bilginizi belirtin. Deneme adına sahip bir JSON yük nesnesi ekleyin.

Çalıştırmayı tetiklemek için istekte bulundur. Çalıştırma kimliğinin değerini Id almak için yanıt sözlüğünden anahtara erişmek için kodu dahil etmek.

import requests

rest_endpoint = published_pipeline.endpoint
response = requests.post(rest_endpoint, 
                         headers=auth_header, 
                         json={"ExperimentName": "Tutorial-Batch-Scoring",
                               "ParameterAssignments": {"process_count_per_node": 6}})
run_id = response.json()["Id"]

Yeni çalıştırmanın durumunu izlemek için çalıştırma kimliğini kullanın. Yeni çalıştırmanın bitip biti 10-15 dakika daha sürer.

Yeni çalıştırma, öğreticide daha önce çalıştırmıştık işlem hattına benzer. Tam çıkışı görüntülemeyi seçebilirsiniz.

from azureml.pipeline.core.run import PipelineRun
from azureml.widgets import RunDetails

published_pipeline_run = PipelineRun(ws.experiments["Tutorial-Batch-Scoring"], run_id)
RunDetails(published_pipeline_run).show()

Kaynakları temizleme

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

İşlem örneğini durdurma

İşlem örneği kullandıysanız, maliyeti düşürmek için kullanmadısanız VM'yi durdurun.

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

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

3. Durdur'a seçin.

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

Her şeyi silme

Oluşturduğunuz kaynakları kullanmayı planlasanız, ücret ödemeden bunları silin:

1. Kaynak Azure portal sol menüden Kaynak grupları'ı 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 tutabilirsiniz ancak tek bir çalışma alanını silebilirsiniz. Çalışma alanı özelliklerini görüntüden Sil'i seçin.

Sonraki adımlar

Bu makine öğrenmesi işlem hatları öğreticisinde aşağıdaki görevleri gerçekleştirebilirsiniz:

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