kurz: vytvoření kanálu Azure Machine Learning pro dávkové vyhodnocování

v tomto rozšířeném kurzu se naučíte, jak vytvořit kanál Azure Machine Learning pro spuštění úlohy vyhodnocování dávek. Kanály strojového učení optimalizují pracovní postup s využitím rychlosti, přenositelnosti a opakovaného použití, takže se můžete soustředit na strojové učení místo infrastruktury a automatizace. Po sestavení a publikování kanálu nakonfigurujete koncový bod REST, který můžete použít ke spuštění kanálu z libovolné knihovny HTTP na libovolné platformě.

V příkladu se používá předem provedený model konvoluční neuronové , který implementuje v Tensorflow pro klasifikaci neoznačených obrázků.

V tomto kurzu provedete následující úlohy:

Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet. vyzkoušení bezplatné nebo placené verze Azure Machine Learning dnes

Požadavky

• dokončete rychlý start: začněte s Azure Machine Learning , pokud ještě nemáte pracovní prostor Azure Machine Learning nebo výpočetní instanci.
• Po dokončení rychlého startu:
  1. V studiu vyberte poznámkové bloky .
  2. Vyberte kartu ukázky .
  3. Otevřete Poznámkový blok kurzy/Machine-Learning-Pipelines-Advanced/tutorial-Pipeline-Batch-scoring-Classification. ipynb .

Pokud chcete spustit kurz nastavení ve vlastním místním prostředí, můžete získat přístup k tomuto kurzu na GitHub. Spusťte pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests , abyste získali požadované balíčky.

Konfigurace pracovního prostoru a vytvoření úložiště dat

vytvořte objekt pracovního prostoru z existujícího pracovního prostoru Azure Machine Learning.

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

Vytvoření úložiště dat pro ukázkové image

Na pipelinedata účtu Získejte ukázku veřejné dat ImageNet Evaluation z sampledata veřejného kontejneru objektů BLOB. Zavolejte register_azure_blob_container() k zpřístupnění dat pro pracovní prostor pod názvem images_datastore . Pak nastavte výchozí úložiště dat pracovního prostoru jako výstupní úložiště dat. Použijte výstupní úložiště dat k určení skóre výstupu v kanálu.

Další informace o přístupu k datům najdete v tématu Jak získat přístup k datům.

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

Vytváření objektů DataSet

Při sestavování kanálů se Dataset objekty používají pro čtení dat z úložiště dat v pracovním prostoru a OutputFileDatasetConfig objekty slouží k přenosu mezilehlých dat mezi jednotlivými kroky kanálu.

V tomto scénáři vytvoříte Dataset objekty, které odpovídají adresářům úložiště dat pro vstupní image i popisky klasifikace (hodnoty y-test). Také vytvoříte OutputFileDatasetConfig objekt pro výstupní data dávkového vyhodnocování.

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

Zaregistrujte datové sady do pracovního prostoru, pokud ho chcete znovu použít později. Tento krok je volitelný.

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

Stažení a registrace modelu

Stáhněte si předTensorflowný model, který se použije pro dávkové vyhodnocování v kanálu. Nejprve vytvořte místní adresář, do kterého chcete model Uložit. Pak stáhněte a extrahujte 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")

Dále zaregistrujte model do svého pracovního prostoru, abyste ho mohli snadno načíst v procesu kanálu. Ve register() funkci static model_name je parametr klíč, který použijete k vyhledání modelu v rámci sady 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)

Vytvoření a připojení vzdáleného cíle výpočtů

Kanály strojového učení nejde spouštět místně, takže je spouštíte na cloudových prostředcích nebo vzdálených výpočetních cílech. Vzdálený výpočetní cíl je opakovaně použitelný virtuální výpočetní prostředí, ve kterém spouštíte experimenty a pracovní postupy strojového učení.

Spusťte následující kód pro vytvoření cíle s povoleným GPU AmlCompute a pak ho připojte k pracovnímu prostoru. Další informace o cílových výpočetních operacích najdete v článku konceptu.

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)

Zápis vyhodnocovacího skriptu

Chcete-li provést bodování, vytvořte skript vyhodnocování s názvem batch_scoring.py a pak ho zapište do aktuálního adresáře. Skript bere vstupní image, použije model klasifikace a pak výstup předpovědi do souboru výsledků.

batch_scoring.pySkript přebírá následující parametry, které se předávají z ParallelRunStep vytvořeného nástroje později:

• --model_name: Název používaného modelu.
• --labels_dir: Umístění labels.txt souboru.

Infrastruktura kanálu používá ArgumentParser třídu k předání parametrů do kroků kanálu. Například v následujícím kódu je první argument --model_name dán identifikátor vlastnosti model_name . Ve init() funkci Model.get_model_path(args.model_name) se používá pro přístup k této vlastnosti.

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

Vytvoření kanálu

Před spuštěním kanálu vytvořte objekt, který definuje prostředí Python, a vytvoří závislosti, které váš batch_scoring.py skript vyžaduje. Hlavní požadovaná závislost je Tensorflow, ale nainstalujete i azureml-core ty, azureml-dataprep[fuse] které vyžaduje ParallelRunStep. Také zadejte Docker a Docker-GPU support.

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

Vytvoření konfigurace pro zabalení skriptu

Vytvořte krok kanálu pomocí skriptu, konfigurace prostředí a parametrů. Zadejte cíl služby COMPUTE, který jste už připojili k vašemu pracovnímu prostoru.

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
)

Vytvoření kroku kanálu

Krok kanálu je objekt, který zapouzdřuje všechno, co potřebujete ke spuštění kanálu, včetně:

• Nastavení prostředí a závislostí
• Výpočetní prostředek, na kterém se má kanál spustit
• Vstupní a výstupní data a libovolné vlastní parametry
• Odkaz na skript nebo logiku sady SDK, které se spustí během kroku

Více tříd dědí z nadřazené třídy PipelineStep . Můžete zvolit třídy pro použití specifických rozhraní nebo zásobníků k vytvoření kroku. V tomto příkladu použijete ParallelRunStep třídu k definování kroku logiky pomocí vlastního skriptu Pythonu. Je-li argument skriptu buď vstupem do kroku, nebo výstupem kroku, musí být argument definován v poli i arguments v input parametru nebo v output parametru.

Ve scénářích, kde je více než jeden krok, se odkaz na objekt v outputs poli zpřístupní jako vstup pro následný krok kanálu.

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
)

Seznam všech tříd, které lze použít pro různé typy kroků, naleznete v balíčku kroků.

Odeslat kanál

Teď kanál spusťte. Nejprve vytvořte Pipeline objekt pomocí odkazu na pracovní prostor a kroku kanálu, který jste vytvořili. stepsParametr je pole kroků. V tomto případě je pro dávkové vyhodnocování k dispozici pouze jeden krok. Chcete-li vytvořit kanály, které mají více kroků, umístěte kroky v tomto poli do pořadí.

Dále pomocí Experiment.submit() funkce odešlete kanál ke spuštění. wait_for_completionFunkce ukládá výstupy do protokolů během procesu sestavení kanálu. Pomocí protokolů můžete zobrazit aktuální průběh.

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)

Stáhnout a zkontrolovat výstup

Spuštěním následujícího kódu Stáhněte výstupní soubor, který je vytvořen ze batch_scoring.py skriptu. Pak prozkoumejte výsledky bodování.

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)

Publikování a spuštění z koncového bodu REST

Spusťte následující kód k publikování kanálu do svého pracovního prostoru. ve vašem pracovním prostoru v Azure Machine Learning studiu uvidíte metadata pro kanál, včetně historie spuštění a trvání. Kanál můžete také spustit ručně ze sady Studio.

Publikování kanálu umožňuje koncovému bodu REST, který můžete použít ke spuštění kanálu z libovolné knihovny HTTP na libovolné platformě.

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

published_pipeline

Pokud chcete kanál spustit z koncového bodu REST, budete potřebovat hlavičku ověřování typu OAuth2 Bearer. Následující příklad používá interaktivní ověřování (pro ilustraci), ale pro většinu produkčních scénářů, které vyžadují automatizované nebo bezobslužné ověřování, použijte ověřování instančního objektu, jak je popsáno v tomto článku.

ověřování instančního objektu zahrnuje vytvoření registrace aplikace v Azure Active Directory. Nejdřív vygenerujete tajný klíč klienta a potom udělíte roli instančního objektu přístup k pracovnímu prostoru Machine Learning. ServicePrincipalAuthenticationKe správě toku ověřování použijte třídu.

Obojí InteractiveLoginAuthentication a ServicePrincipalAuthentication dědí z AbstractAuthentication . V obou případech použijte get_authentication_header() funkci ve stejném způsobu, jak načíst hlavičku:

from azureml.core.authentication import InteractiveLoginAuthentication

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

Získejte adresu URL REST z endpoint vlastnosti publikovaného objektu kanálu. adresu URL REST můžete také najít ve vašem pracovním prostoru v Azure Machine Learning studiu.

Sestavte požadavek HTTP POST na koncový bod. Zadejte hlavičku ověřování v žádosti. Přidejte objekt datové části JSON, který má název experimentu.

Vytvořte žádost o aktivaci běhu. Chcete-li získat hodnotu ID běhu, přidejte kód pro přístup k Id klíči z slovníku odpovědí.

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

Ke sledování stavu nového běhu použijte ID běhu. Nové spuštění trvá dokončení dalších 10-15.

Nové spuštění bude vypadat podobně jako u kanálu, který jste spustili dříve v tomto kurzu. Můžete zvolit, aby se nezobrazil úplný výstup.

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

Vyčištění prostředků

tuto část neprovádějte, pokud máte v plánu spouštět další kurzy Azure Machine Learning.

Zastavení výpočetní instance

Pokud jste použili výpočetní instanci, zastavte virtuální počítač, pokud ho nepoužíváte ke snížení nákladů.

1. V pracovním prostoru vyberte COMPUTE.

2. V seznamu vyberte název výpočetní instance.

3. Vyberte zastavit.

4. Až budete chtít znovu použít server, vyberte Spustit.

Odstranit vše

Pokud neplánujete použít prostředky, které jste vytvořili, odstraňte je, takže se vám neúčtují žádné poplatky:

1. V Azure Portal v nabídce vlevo vyberte skupiny prostředků.
2. V seznamu skupin prostředků vyberte skupinu prostředků, kterou jste vytvořili.
3. Vyberte Odstranit skupinu prostředků.
4. Zadejte název skupiny prostředků. Pak vyberte Odstranit.

Můžete také zachovat skupinu prostředků, ale odstranit jeden pracovní prostor. Zobrazte vlastnosti pracovního prostoru a pak vyberte Odstranit.

Další kroky

V tomto kurzu strojového učení se provedly následující úlohy:

Další příklady vytváření kanálů pomocí sady Machine Learning SDK najdete v úložišti poznámkových bloků.