Öğretici: toplu Puanlama için Azure Machine Learning işlem hattı oluşturmaTutorial: Build an Azure Machine Learning pipeline for batch scoring

Uygulama hedefi: YesBasic Edition EvetEnterprise edition                   (Enterprise Edition 'A yükseltme)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Bu öğreticide, Batch Puanlama işini çalıştırmak için Azure Machine Learning bir işlem hattı kullanırsınız.In this tutorial, you use a pipeline in Azure Machine Learning to run a batch scoring job. Örnek, etiketlenmemiş görüntüleri sınıflandırmak için preeğitilen -v3 evsel sinir Network TensorFlow modelini kullanır.The example uses the pretrained Inception-V3 convolutional neural network Tensorflow model to classify unlabeled images. 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.After you build and publish a pipeline, you configure a REST endpoint that you can use to trigger the pipeline from any HTTP library on any platform.

Makine öğrenimi ardışık düzenleri, iş akışınızı hız, taşınabilirlik ve yeniden kullanma süreciyle iyileştirin. böylece, altyapı ve otomasyon yerine uzmanlık makinenizin öğrenimine odaklanırsınız.Machine learning pipelines optimize your workflow with speed, portability, and reuse, so you can focus on your expertise - machine learning - instead of on infrastructure and automation. Makine öğrenimi işlem hatları hakkında daha fazla bilgi edinin.Learn more about machine learning pipelines.

Bu öğreticide, aşağıdaki görevleri tamamlayacaksınız:In this tutorial, you complete the following tasks:

  • Çalışma alanını yapılandırma ve örnek verileri indirmeConfigure workspace and download sample data
  • Verileri getirmek ve çıkarmak için veri nesneleri oluşturmaCreate data objects to fetch and output data
  • Çalışma alanınıza modeli indirme, hazırlama ve kaydetmeDownload, prepare, and register the model in your workspace
  • İşlem hedeflerini sağlama ve bir Puanlama betiği oluşturmaProvision compute targets and create a scoring script
  • İşlem hattı oluşturma, çalıştırma ve yayımlamaBuild, run, and publish a pipeline
  • İşlem hattı için bir REST uç noktasını etkinleştirmeEnable a REST endpoint for the pipeline

Azure aboneliğiniz yoksa başlamadan önce ücretsiz bir hesap oluşturun.If you don’t have an Azure subscription, create a free account before you begin. Azure Machine Learning ücretsiz veya ücretli sürümünü bugün deneyin.Try the free or paid version of Azure Machine Learning today.

ÖnkoşullarPrerequisites

  • Zaten bir Azure Machine Learning çalışma alanınız veya Not defteri sanal makineniz yoksa, Kurulum öğreticisinin 1. kısmınıdoldurun.If you don't already have an Azure Machine Learning workspace or notebook virtual machine, complete Part 1 of the setup tutorial.
  • Kurulum öğreticisini tamamladığınızda, Öğreticiler/Tutorial-Pipeline-Batch-Scoring-Classification. ipynb Not defterini açmak için aynı not defteri sunucusunu kullanın.When you finish the setup tutorial, use the same notebook server to open the tutorials/tutorial-pipeline-batch-scoring-classification.ipynb notebook.

Kurulum öğreticisini kendi Yerel ortamınızdaçalıştırmak istiyorsanız GitHub'daki öğreticiye erişebilirsiniz.If you want to run the setup tutorial in your own local environment, you can access the tutorial on GitHub. Gerekli paketleri almak için pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests çalıştırın.Run pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests to get the required packages.

Çalışma alanını yapılandırma ve veri deposu oluşturmaConfigure workspace and create a datastore

Mevcut Azure Machine Learning çalışma alanından bir çalışma alanı nesnesi oluşturun.Create a workspace object from the existing Azure Machine Learning workspace.

  • Çalışma alanı , Azure aboneliğinizi ve kaynak bilgilerinizi kabul eden bir sınıftır.A workspace is a class that accepts your Azure subscription and resource information. Çalışma alanı, modelinizi izlemek ve izlemek için kullanabileceğiniz bir bulut kaynağı da oluşturur.The workspace also creates a cloud resource you can use to monitor and track your model runs.
  • Workspace.from_config() config.json dosyayı okur ve sonra kimlik doğrulama ayrıntılarını wsadlı bir nesneye yükler.Workspace.from_config() reads the config.json file and then loads the authentication details into an object named ws. ws nesnesi bu öğretici boyunca kodda kullanılır.The ws object is used in the code throughout this tutorial.
from azureml.core import Workspace
ws = Workspace.from_config()

Örnek görüntüler için bir veri deposu oluşturmaCreate a datastore for sample images

pipelinedata hesapta, sampledata genel blob kapsayıcısından ımagenet değerlendirmesi ortak veri örneğini alın.On the pipelinedata account, get the ImageNet evaluation public data sample from the sampledata public blob container. Verilerin adı images_datastorealtında çalışma alanı için kullanılabilir olması için register_azure_blob_container() çağırın.Call register_azure_blob_container() to make the data available to the workspace under the name images_datastore. Daha sonra, çalışma alanı varsayılan veri deposunu çıkış veri deposu olarak ayarlayın.Then, set the workspace default datastore as the output datastore. İşlem hattındaki çıktıyı öğrenmek için çıkış veri deposunu kullanın.Use the output datastore to score output in the pipeline.

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 nesneleri oluşturmaCreate data objects

Bir işlem hattı oluşturduğunuzda, bir DataReference nesnesi, çalışma alanı veri deposundan verileri okur.When you build a pipeline, a DataReference object reads data from the workspace datastore. PipelineData nesnesi, işlem hattı adımları arasında ara verileri aktarır.A PipelineData object transfers intermediate data between pipeline steps.

Önemli

Bu öğreticideki toplu işlem Puanlama örneği yalnızca bir ardışık düzen adımını kullanır.The batch scoring example in this tutorial uses only one pipeline step. Birden çok adımı olan kullanım durumlarında, tipik akış şu adımları içerir:In use cases that have multiple steps, the typical flow will include these steps:

  1. Ham verileri getirmek, bazı dönüşümleriniz gerçekleştirmek ve sonra bir PipelineData nesnesinin çıktısını almak için DataReference nesneleri giriş olarak kullanın.Use DataReference objects as inputs to fetch raw data, perform some transformation, and then output a PipelineData object.

  2. Giriş nesnesiolarak önceki adımda PipelineData çıktı nesnesini kullanın.Use the PipelineData output object in the preceding step as an input object. Sonraki adımlar için tekrarlayın.Repeat it for subsequent steps.

Bu senaryoda, 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 DataReference nesneleri oluşturursunuz.In this scenario, you create DataReference objects that correspond to the datastore directories for both the input images and the classification labels (y-test values). Toplu Puanlama çıkış verileri için bir PipelineData nesnesi de oluşturursunuz.You also create a PipelineData object for the batch scoring output data.

from azureml.data.data_reference import DataReference
from azureml.pipeline.core import PipelineData

input_images = DataReference(datastore=batchscore_blob, 
                             data_reference_name="input_images",
                             path_on_datastore="batchscoring/images",
                             mode="download"
                            )

label_dir = DataReference(datastore=batchscore_blob, 
                          data_reference_name="input_labels",
                          path_on_datastore="batchscoring/labels",
                          mode="download"                          
                         )

output_dir = PipelineData(name="scores", 
                          datastore=def_data_store, 
                          output_path_on_compute="batchscoring/results")

Modeli indir ve KaydetDownload and register the model

Bir işlem hattındaki toplu Puanlama için kullanmak üzere önceden eğitilen TensorFlow modelini indirin.Download the pretrained Tensorflow model to use it for batch scoring in a pipeline. İlk olarak, modeli depoladığınız yerel bir dizin oluşturun.First, create a local directory where you store the model. Ardından, modeli indirip ayıklayın.Then, download and extract the model.

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.Next, register the model to your workspace, so you can easily retrieve the model in the pipeline process. register() static işlevinde model_name parametresi, SDK 'nın tamamında modelinizi bulmak için kullandığınız anahtardır.In the register() static function, the model_name parameter is the key you use to locate your model throughout the SDK.

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ştirmeCreate and attach the remote compute target

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.Machine learning pipelines can't be run locally, so you run them on cloud resources or remote compute targets. 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.A remote compute target is a reusable virtual compute environment where you run experiments and machine learning workflows.

GPU özellikli AmlCompute hedefi oluşturmak ve ardından çalışma alanınıza eklemek için aşağıdaki kodu çalıştırın.Run the following code to create a GPU-enabled AmlCompute target, and then attach it to your workspace. İşlem hedefleri hakkında daha fazla bilgi için kavramsal makaleyebakın.For more information about compute targets, see the conceptual article.

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 yazmaWrite a scoring script

Puanlama yapmak için batch_scoring.pyadlı bir toplu işlem Puanlama betiği oluşturun ve sonra geçerli dizine yazın.To do the scoring, create a batch scoring script called batch_scoring.py, and then write it to the current directory. Betik, giriş görüntülerini alır, sınıflandırma modelini uygular ve daha sonra tahminleri bir sonuç dosyasına çıkarır.The script takes input images, applies the classification model, and then outputs the predictions to a results file.

batch_scoring.py betiği, bu öğreticide daha sonra oluşturduğunuz ardışık düzen adımından geçirilen aşağıdaki parametreleri alır:The batch_scoring.py script takes the following parameters, which are passed from the pipeline step that you create later in this tutorial:

  • --model_name: kullanılan modelin adı.--model_name: The name of the model being used.
  • --label_dir: labels.txt dosyasını tutan dizin.--label_dir: The directory that holds the labels.txt file.
  • --dataset_path: giriş görüntülerini içeren dizin.--dataset_path: The directory that contains the input images.
  • --output_dir: betik sonrasında results-label.txt dosyası için çıkış dizini, verileri veri üzerinde çalıştırır.--output_dir: The output directory for the results-label.txt file after the script runs the model on the data.
  • --batch_size: modeli çalıştırırken kullanılan toplu iş boyutu.--batch_size: The batch size used in running the model.

İşlem hattı altyapısı, parametreleri ardışık düzen adımlarına geçirmek için ArgumentParser sınıfını kullanır.The pipeline infrastructure uses the ArgumentParser class to pass parameters into pipeline steps. Örneğin, aşağıdaki kodda --model_name ilk bağımsız değişken model_nameözellik tanımlayıcısı olarak verilmiştir.For example, in the following code, the first argument --model_name is given the property identifier model_name. main() işlevinde, bu özelliğe erişmek için Model.get_model_path(args.model_name) kullanılır.In the main() function, Model.get_model_path(args.model_name) is used to access this property.

%%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.model import Model

slim = tf.contrib.slim

parser = argparse.ArgumentParser(description="Start a tensorflow model serving")
parser.add_argument('--model_name', dest="model_name", required=True)
parser.add_argument('--label_dir', dest="label_dir", required=True)
parser.add_argument('--dataset_path', dest="dataset_path", required=True)
parser.add_argument('--output_dir', dest="output_dir", required=True)
parser.add_argument('--batch_size', dest="batch_size", type=int, required=True)

args = parser.parse_args()

image_size = 299
num_channel = 3

# create output directory if it does not exist
os.makedirs(args.output_dir, exist_ok=True)


def get_class_label_dict(label_file):
    label = []
    proto_as_ascii_lines = tf.gfile.GFile(label_file).readlines()
    for l in proto_as_ascii_lines:
        label.append(l.rstrip())
    return label


class DataIterator:
    def __init__(self, data_dir):
        self.file_paths = []
        image_list = os.listdir(data_dir)
        self.file_paths = [data_dir + '/' + file_name.rstrip() for file_name in image_list]
        self.labels = [1 for file_name in self.file_paths]

    @property
    def size(self):
        return len(self.labels)

    def input_pipeline(self, batch_size):
        images_tensor = tf.convert_to_tensor(self.file_paths, dtype=tf.string)
        labels_tensor = tf.convert_to_tensor(self.labels, dtype=tf.int64)
        input_queue = tf.train.slice_input_producer([images_tensor, labels_tensor], shuffle=False)
        labels = input_queue[1]
        images_content = tf.read_file(input_queue[0])

        image_reader = tf.image.decode_jpeg(images_content, channels=num_channel, name="jpeg_reader")
        float_caster = tf.cast(image_reader, tf.float32)
        new_size = tf.constant([image_size, image_size], dtype=tf.int32)
        images = tf.image.resize_images(float_caster, new_size)
        images = tf.divide(tf.subtract(images, [0]), [255])

        image_batch, label_batch = tf.train.batch([images, labels], batch_size=batch_size, capacity=5 * batch_size)
        return image_batch


def main(_):
    label_file_name = os.path.join(args.label_dir, "labels.txt")
    label_dict = get_class_label_dict(label_file_name)
    classes_num = len(label_dict)
    test_feeder = DataIterator(data_dir=args.dataset_path)
    total_size = len(test_feeder.labels)
    count = 0

    # get model from model registry
    model_path = Model.get_model_path(args.model_name)

    with tf.Session() as sess:
        test_images = test_feeder.input_pipeline(batch_size=args.batch_size)
        with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
            input_images = tf.placeholder(tf.float32, [args.batch_size, 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)

        sess.run(tf.global_variables_initializer())
        sess.run(tf.local_variables_initializer())
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        saver = tf.train.Saver()
        saver.restore(sess, model_path)
        out_filename = os.path.join(args.output_dir, "result-labels.txt")
        with open(out_filename, "w") as result_file:
            i = 0
            while count < total_size and not coord.should_stop():
                test_images_batch = sess.run(test_images)
                file_names_batch = test_feeder.file_paths[i * args.batch_size:
                                                          min(test_feeder.size, (i + 1) * args.batch_size)]
                results = sess.run(probabilities, feed_dict={input_images: test_images_batch})
                new_add = min(args.batch_size, total_size - count)
                count += new_add
                i += 1
                for j in range(new_add):
                    result_file.write(os.path.basename(file_names_batch[j]) + ": " + label_dict[results[j]] + "\n")
                result_file.flush()
            coord.request_stop()
            coord.join(threads)

        shutil.copy(out_filename, "./outputs/")

if __name__ == "__main__":
    tf.app.run()

İpucu

Bu öğreticideki işlem hattının yalnızca bir adımı vardır ve çıktıyı bir dosyaya yazar.The pipeline in this tutorial has only one step, and it writes the output to a file. Çok adımlı işlem hatları için, sonraki adımlara giriş için çıkış verilerini yazmak üzere bir dizin tanımlamak üzere ArgumentParser de kullanabilirsiniz.For multi-step pipelines, you also use ArgumentParser to define a directory to write output data for input to subsequent steps. ArgumentParser tasarım düzenini kullanarak birden çok işlem hattı adımı arasında veri geçirmenin bir örneği için, bkz. Not defteri.For an example of passing data between multiple pipeline steps by using the ArgumentParser design pattern, see the notebook.

İşlem hattını oluşturma ve çalıştırmaBuild and run the pipeline

İş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.Before you run the pipeline, create an object that defines the Python environment and creates the dependencies that your batch_scoring.py script requires. Gerekli ana bağımlılık, TensorFlow ' dır, ancak arka plan işlemlerinde SDK 'dan azureml-defaults de yüklersiniz.The main dependency required is Tensorflow, but you also install azureml-defaults from the SDK for background processes. Bağımlılıkları kullanarak bir RunConfiguration nesnesi oluşturun.Create a RunConfiguration object by using the dependencies. Ayrıca, Docker ve Docker-GPU desteği de belirtin.Also, specify Docker and Docker-GPU support.

from azureml.core.runconfig import DEFAULT_GPU_IMAGE
from azureml.core.runconfig import CondaDependencies, RunConfiguration

cd = CondaDependencies.create(pip_packages=["tensorflow-gpu==1.13.1", "azureml-defaults"])

amlcompute_run_config = RunConfiguration(conda_dependencies=cd)
amlcompute_run_config.environment.docker.enabled = True
amlcompute_run_config.environment.docker.base_image = DEFAULT_GPU_IMAGE
amlcompute_run_config.environment.spark.precache_packages = False

İşlem hattını ParametreleştirmeParameterize the pipeline

İşlem hattının toplu iş boyutunu denetlemek için özel bir parametre tanımlayın.Define a custom parameter for the pipeline to control the batch size. İşlem hattı yayımlandıktan ve bir REST uç noktası aracılığıyla sunulduktan sonra, yapılandırılmış tüm parametreler de sunulur.After the pipeline is published and exposed via a REST endpoint, any configured parameters are also exposed. Ardışık düzeni bir HTTP isteği aracılığıyla yeniden çalıştırdığınızda JSON yükünde özel parametreler belirtebilirsiniz.You can specify custom parameters in the JSON payload when you rerun the pipeline via an HTTP request.

Bu davranışı etkinleştirmek ve bir ad ve varsayılan değer tanımlamak için bir PipelineParameter nesnesi oluşturun.Create a PipelineParameter object to enable this behavior and to define a name and default value.

from azureml.pipeline.core.graph import PipelineParameter
batch_size_param = PipelineParameter(name="param_batch_size", default_value=20)

İşlem hattı adım oluşturmaCreate the pipeline step

İş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:A pipeline step is an object that encapsulates everything you need to run a pipeline, including:

  • Ortam ve bağımlılık ayarlarıEnvironment and dependency settings
  • İşlem hattının çalıştırılacağı işlem kaynağıThe compute resource to run the pipeline on
  • Giriş ve çıkış verileri ve tüm özel parametrelerInput and output data, and any custom parameters
  • Adım sırasında çalışacak bir betik veya SDK mantığına başvuruReference to a script or SDK logic to run during the step

Birden çok sınıf PipelineStepüst sınıftan devralınır.Multiple classes inherit from the parent class PipelineStep. Bir adım oluşturmak için belirli çerçeveleri veya yığınları kullanmak üzere sınıfları seçebilirsiniz.You can choose classes to use specific frameworks or stacks to build a step. Bu örnekte, özel bir Python betiği kullanarak adım mantığınızı tanımlamak için PythonScriptStep sınıfını kullanırsınız.In this example, you use the PythonScriptStep class to define your step logic by using a custom Python script. Betiğinizin bir bağımsız değişkeni adım veya adımın çıktısındaki bir giriş ise, bağımsız değişken, sırasıyla arguments dizisinde ve input ya da output parametresinde tanımlanmalıdır.If an argument to your script is either an input to the step or an output of the step, the argument must be defined both in the arguments array and in either the input or the output parameter, respectively.

Birden fazla adımın olduğu senaryolarda, outputs dizideki bir nesne başvurusu, sonraki bir işlem hattı adımı için giriş olarak kullanılabilir hale gelir.In scenarios where there is more than one step, an object reference in the outputs array becomes available as an input for a subsequent pipeline step.

from azureml.pipeline.steps import PythonScriptStep

batch_score_step = PythonScriptStep(
    name="batch_scoring",
    script_name="batch_scoring.py",
    arguments=["--dataset_path", input_images, 
               "--model_name", "inception",
               "--label_dir", label_dir, 
               "--output_dir", output_dir, 
               "--batch_size", batch_size_param],
    compute_target=compute_target,
    inputs=[input_images, label_dir],
    outputs=[output_dir],
    runconfig=amlcompute_run_config
)

Farklı adım türleri için kullanabileceğiniz tüm sınıfların bir listesi için, bkz. adımlar paketi.For a list of all the classes you can use for different step types, see the steps package.

İşlem hattını çalıştırmaRun the pipeline

Şimdi işlem hattını çalıştırın.Now, run the pipeline. İlk olarak, çalışma alanı başvurusunu ve oluşturduğunuz işlem hattı adımını kullanarak bir Pipeline nesnesi oluşturun.First, create a Pipeline object by using your workspace reference and the pipeline step you created. steps parametresi bir adım dizisidir.The steps parameter is an array of steps. Bu durumda, toplu Puanlama için yalnızca bir adım vardır.In this case, there's only one step for batch scoring. Birden çok adım içeren işlem hatları oluşturmak için, adımları Bu dizide sırayla yerleştirin.To build pipelines that have multiple steps, place the steps in order in this array.

Sonra, işlem hattını yürütmeye göndermek için Experiment.submit() işlevini kullanın.Next, use the Experiment.submit() function to submit the pipeline for execution. Ayrıca, param_batch_sizeözel parametresini de belirtirsiniz.You also specify the custom parameter param_batch_size. wait_for_completion işlevi, işlem hattı derleme işlemi sırasında günlükleri çıktı.The wait_for_completion function outputs logs during the pipeline build process. Geçerli ilerlemeyi görmek için günlükleri kullanabilirsiniz.You can use the logs to see current progress.

Önemli

İlk işlem hattı çalıştırması yaklaşık 15 dakikasürer.The first pipeline run takes roughly 15 minutes. Tüm bağımlılıklar indirilmelidir, bir Docker görüntüsü oluşturulur ve Python ortamı sağlanmakta ve oluşturulur.All dependencies must be downloaded, a Docker image is created, and the Python environment is provisioned and created. Bu kaynaklar oluşturulması yerine yeniden kullanıldığından işlem hattının yeniden çalıştırılması çok daha az zaman alır.Running the pipeline again takes significantly less time because those resources are reused instead of created. Ancak, işlem hattının toplam çalışma süresi, betiklerinizin ve her bir ardışık düzen adımında çalışan işlemlerin iş yüküne bağlıdır.However, total run time for the pipeline depends on the workload of your scripts and the processes that are running in each pipeline step.

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

pipeline = Pipeline(workspace=ws, steps=[batch_score_step])
pipeline_run = Experiment(ws, 'batch_scoring').submit(pipeline, pipeline_parameters={"param_batch_size": 20})
pipeline_run.wait_for_completion(show_output=True)

Çıktıyı indirin ve gözden geçirinDownload and review output

batch_scoring.py betiğinizden oluşturulan çıkış dosyasını indirmek için aşağıdaki kodu çalıştırın.Run the following code to download the output file that's created from the batch_scoring.py script. Ardından, Puanlama sonuçlarını araştırın.Then, explore the scoring results.

import pandas as pd

step_run = list(pipeline_run.get_children())[0]
step_run.download_file("./outputs/result-labels.txt")

df = pd.read_csv("result-labels.txt", delimiter=":", header=None)
df.columns = ["Filename", "Prediction"]
df.head(10)
KısaltınFilename TahminPrediction
00 ILSVRC2012_val_00000102. JPEGILSVRC2012_val_00000102.JPEG Rhodesian bir RhogebackRhodesian Ridgeback
1\.1 ILSVRC2012_val_00000103. JPEGILSVRC2012_val_00000103.JPEG Tripodtripod
22 ILSVRC2012_val_00000104. JPEGILSVRC2012_val_00000104.JPEG daktilo klavyesitypewriter keyboard
33 ILSVRC2012_val_00000105. JPEGILSVRC2012_val_00000105.JPEG silici korunsilky terrier
44 ILSVRC2012_val_00000106. JPEGILSVRC2012_val_00000106.JPEG Wınwınör kravatWindsor tie
55 ILSVRC2012_val_00000107. JPEGILSVRC2012_val_00000107.JPEG Harvestmanharvestman
66 ILSVRC2012_val_00000108. JPEGILSVRC2012_val_00000108.JPEG Kemanviolin
77 ILSVRC2012_val_00000109. JPEGILSVRC2012_val_00000109.JPEG Hoparlörüloudspeaker
88 ILSVRC2012_val_00000110. JPEGILSVRC2012_val_00000110.JPEG Apronapron
99 ILSVRC2012_val_00000111. JPEGILSVRC2012_val_00000111.JPEG American LobsterAmerican lobster

REST uç noktasından Yayımla ve ÇalıştırPublish and run from a REST endpoint

İşlem hattını çalışma alanınıza yayımlamak için aşağıdaki kodu çalıştırın.Run the following code to publish the pipeline to your workspace. Azure Machine Learning Studio 'daki çalışma alanınızda çalışma geçmişi ve süreler dahil olmak üzere işlem hattı için meta verileri görebilirsiniz.In your workspace in Azure Machine Learning studio, you can see metadata for the pipeline, including run history and durations. Ardışık düzeni Studio 'dan el ile de çalıştırabilirsiniz.You can also run the pipeline manually from the studio.

İşlem hattının yayımlanması, herhangi bir platformda herhangi bir HTTP kitaplığından işlem hattını çalıştırmak için kullanabileceğiniz bir REST uç noktası sağlar.Publishing the pipeline enables a REST endpoint that you can use to run the pipeline from any HTTP library on any platform.

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ç noktasından çalıştırmak için, OAuth2 taşıyıcı türünde bir kimlik doğrulama üst bilgisi gerekir.To run the pipeline from the REST endpoint, you need an OAuth2 Bearer-type authentication header. Aşağıdaki örnek etkileşimli kimlik doğrulaması kullanır (çizim amaçları için), ancak otomatik veya gözetimsiz kimlik doğrulaması gerektiren çoğu üretim senaryosunda, Bu not defterinde açıklandığıgibi hizmet sorumlusu kimlik doğrulamasını kullanın.The following example uses interactive authentication (for illustration purposes), but for most production scenarios that require automated or headless authentication, use service principal authentication as described in this notebook.

Hizmet sorumlusu kimlik doğrulaması, Azure Active Directorybir uygulama kaydı oluşturulmasını içerir.Service principal authentication involves creating an App Registration in Azure Active Directory. İlk olarak, bir istemci parolası oluşturun ve ardından hizmet sorumlusu rolünüze Machine Learning çalışma alanınıza erişim verirsiniz.First, you generate a client secret, and then you grant your service principal role access to your machine learning workspace. Kimlik doğrulama akışınızı yönetmek için ServicePrincipalAuthentication sınıfını kullanın.Use the ServicePrincipalAuthentication class to manage your authentication flow.

Hem InteractiveLoginAuthentication hem de ServicePrincipalAuthentication AbstractAuthenticationdevralınır.Both InteractiveLoginAuthentication and ServicePrincipalAuthentication inherit from AbstractAuthentication. Her iki durumda da get_authentication_header() işlevini, üstbilgiyi getirmek için aynı şekilde kullanın:In both cases, use the get_authentication_header() function in the same way to fetch the header:

from azureml.core.authentication import InteractiveLoginAuthentication

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

Yayımlanan ardışık düzen nesnesinin endpoint özelliğinden REST URL 'sini alın.Get the REST URL from the endpoint property of the published pipeline object. REST URL 'sini Azure Machine Learning Studio 'daki çalışma alanınızda de bulabilirsiniz.You can also find the REST URL in your workspace in Azure Machine Learning studio.

Uç noktaya bir HTTP POST isteği oluşturun.Build an HTTP POST request to the endpoint. İstekte kimlik doğrulama üst bilgisini belirtin.Specify your authentication header in the request. Deneme adı ve toplu iş boyutu parametresine sahip bir JSON yük nesnesi ekleyin.Add a JSON payload object that has the experiment name and the batch size parameter. Öğreticide daha önce belirtildiği gibi, adım yapılandırmasında bir PipelineParameter nesnesi olarak tanımladığınız için param_batch_size batch_scoring.py betiğiyle geçirilir.As noted earlier in the tutorial, param_batch_size is passed through to your batch_scoring.py script because you defined it as a PipelineParameter object in the step configuration.

Çalıştırmayı tetiklemeye yönelik isteği yapın.Make the request to trigger the run. Çalıştırma KIMLIĞININ değerini almak için yanıt sözlüğünden Id anahtarına erişmek üzere kodu ekleyin.Include code to access the Id key from the response dictionary to get the value of the run ID.

import requests

rest_endpoint = published_pipeline.endpoint
response = requests.post(rest_endpoint, 
                         headers=auth_header, 
                         json={"ExperimentName": "batch_scoring",
                               "ParameterAssignments": {"param_batch_size": 50}})
run_id = response.json()["Id"]

Yeni çalıştırmanın durumunu izlemek için çalıştırma KIMLIĞINI kullanın.Use the run ID to monitor the status of the new run. Yeni çalıştırmanın tamamlanmasının bir başka 10-15 dakika sürer.The new run takes another 10-15 min to finish.

Yeni çalıştırma öğreticide daha önce çalıştırdığınız işlem hattına benzer şekilde görünür.The new run will look similar to the pipeline you ran earlier in the tutorial. Tam çıktıyı görüntüleme seçeneğini belirleyebilirsiniz.You can choose not to view the full output.

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

published_pipeline_run = PipelineRun(ws.experiments["batch_scoring"], run_id)
RunDetails(published_pipeline_run).show()

Kaynakları temizlemeClean up resources

Diğer Azure Machine Learning öğreticileri çalıştırmayı planlıyorsanız, bu bölümü tamammayın.Don't complete this section if you plan to run other Azure Machine Learning tutorials.

Not defteri VM 'sini durdurStop the Notebook VM

Bir işlem örneği veya Not defteri VM 'si kullandıysanız, maliyeti azaltmak için kullanmadığınız sanal makineyi durdurun.If you used a compute instance or Notebook VM, stop the VM when you are not using it to reduce cost.

  1. Çalışma alanınızda işlem' ı seçin.In your workspace, select Compute.

  2. Listeden VM’yi seçin.From the list, select the VM.

  3. Durdur' u seçin.Select Stop.

  4. Sunucuyu yeniden kullanmaya hazırsanız Başlat' ı seçin.When you're ready to use the server again, select Start.

Her şeyi silDelete everything

Oluşturduğunuz kaynakları kullanmayı planlamıyorsanız, hiçbir ücret ödemezsiniz:If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. Azure portal, sol taraftaki menüden kaynak grupları' nı seçin.In the Azure portal, in the left menu, select Resource groups.
  2. Kaynak grupları listesinde, oluşturduğunuz kaynak grubunu seçin.In the list of resource groups, select the resource group you created.
  3. Kaynak grubunu sil'i seçin.Select Delete resource group.
  4. Kaynak grubu adını girin.Enter the resource group name. Ardından Sil' i seçin.Then, select Delete.

Ayrıca, kaynak grubunu koruyabilir ancak tek bir çalışma alanını silebilirsiniz.You can also keep the resource group but delete a single workspace. Çalışma alanı özelliklerini görüntüleyin ve sonra Sil' i seçin.Display the workspace properties, and then select Delete.

Sonraki adımlarNext steps

Bu makine öğrenimi ardışık düzenleri öğreticisinde aşağıdaki görevleri yaptınız:In this machine learning pipelines tutorial, you did the following tasks:

  • Uzak bir GPU işlem kaynağında çalışacak ortam bağımlılıklarıyla bir işlem hattı oluşturuldu.Built a pipeline with environment dependencies to run on a remote GPU compute resource.
  • Önceden eğitilen bir TensorFlow modeli kullanarak toplu tahminleri çalıştırmak için bir Puanlama betiği oluşturuldu.Created a scoring script to run batch predictions by using a pretrained Tensorflow model.
  • Bir işlem hattı yayımlandı ve bir REST uç noktasından çalıştırılmak üzere etkinleştirildi.Published a pipeline and enabled it to be run from a REST endpoint.

Machine Learning SDK 'Yı kullanarak işlem hattı oluşturma hakkında daha fazla örnek için Not defteri deposunabakın.For more examples of how to build pipelines by using the machine learning SDK, see the notebook repository.