Kör batch-härledning på stora mängder data med hjälp av Azure Machine LearningRun batch inference on large amounts of data by using Azure Machine Learning

gäller för:  Ja Basic Edition  Ja Enterprise Edition                               (Uppgradera till Enterprise Edition) APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Lär dig hur du kör batch-härledning på stora mängder data asynkront och parallellt med hjälp av Azure Machine Learning.Learn how to run batch inference on large amounts of data asynchronously and in parallel by using Azure Machine Learning. ParallelRunStep tillhandahåller parallella funktioner.The ParallelRunStep provides parallelism capabilities out of the box.

Med ParallelRunStep är det enkelt att skala offline-inferences till stora kluster datorer i terabyte strukturerade eller ostrukturerade data med förbättrad produktivitet och optimerad kostnad.With ParallelRunStep, it's straightforward to scale offline inferences to large clusters of machines on terabytes of structured or unstructured data with improved productivity and optimized cost.

I den här artikeln får du lära dig följande uppgifter:In this article, you learn the following tasks:

  1. Konfigurera Machine Learning-resurser.Set up machine learning resources.
  2. Konfigurera indata och utdata för batch-datahärledning.Configure batch inference data inputs and output.
  3. Förbered den förtränade avbildnings klassificerings modellen baserat på MNIST -datauppsättningen.Prepare the pre-trained image classification model based on the MNIST dataset.
  4. Skriv ditt härlednings skript.Write your inference script.
  5. Skapa en pipeline för maskin inlärning som innehåller ParallelRunStep och kör batch-härledning på MNIST-testavbildningar.Create a machine learning pipeline containing ParallelRunStep and run batch inference on MNIST test images.
  6. Skicka en ny körnings härledning igen med nya indata och parametrar.Resubmit a batch inference run with new data input and parameters.
  7. Granska resultaten.View the results.

FörutsättningarPrerequisites

Konfigurera Machine Learning-resurserSet up machine learning resources

Följande åtgärder konfigurerar de Machine Learning-resurser som du behöver för att köra en pipeline för batch-härledning:The following actions set up the machine learning resources that you need to run a batch inference pipeline:

  • Anslut till en arbets yta.Connect to a workspace.
  • Skapa eller koppla en befintlig beräknings resurs.Create or attach existing compute resource.

Konfigurera arbetsytaConfigure workspace

Skapa ett arbetsyteobjekt från den befintliga arbetsytan.Create a workspace object from the existing workspace. Workspace.from_config()läser config.jspå filen och läser in informationen i ett objekt med namnet ws.Workspace.from_config() reads the config.json file and loads the details into an object named ws.

from azureml.core import Workspace

ws = Workspace.from_config()

Viktigt

Det här kodfragmentet förväntar sig att arbets ytans konfiguration sparas i den aktuella katalogen eller dess överordnade.This code snippet expects the workspace configuration to be saved in the current directory or its parent. Mer information om hur du skapar en arbets yta finns i skapa och hantera Azure Machine Learning arbets ytor.For more information on creating a workspace, see Create and manage Azure Machine Learning workspaces. Mer information om hur du sparar konfigurationen till filen finns i skapa en konfigurations fil för arbets ytor.For more information on saving the configuration to file, see Create a workspace configuration file.

Skapa ett beräknings målCreate a compute target

I Azure Machine Learning refererar beräkning (eller beräknings mål) till de datorer eller kluster som utför beräknings stegen i din Machine Learning-pipeline.In Azure Machine Learning, compute (or compute target) refers to the machines or clusters that perform the computational steps in your machine learning pipeline. Kör följande kod för att skapa ett CPU-baserat AmlCompute -mål.Run the following code to create a CPU based AmlCompute target.

from azureml.core.compute import AmlCompute, ComputeTarget
from azureml.core.compute_target import ComputeTargetException

# choose a name for your cluster
compute_name = os.environ.get("AML_COMPUTE_CLUSTER_NAME", "cpucluster")
compute_min_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MIN_NODES", 0)
compute_max_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MAX_NODES", 4)

# This example uses CPU VM. For using GPU VM, set SKU to STANDARD_NC6
vm_size = os.environ.get("AML_COMPUTE_CLUSTER_SKU", "STANDARD_D2_V2")


if compute_name in ws.compute_targets:
    compute_target = ws.compute_targets[compute_name]
    if compute_target and type(compute_target) is AmlCompute:
        print('found compute target. just use it. ' + compute_name)
else:
    print('creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size = vm_size,
                                                                min_nodes = compute_min_nodes, 
                                                                max_nodes = compute_max_nodes)

    # create the cluster
    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)
    
    # can poll for a minimum number of nodes and for a specific timeout. 
    # if no min node count is provided it will use the scale settings for the cluster
    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)
    
     # For a more detailed view of current AmlCompute status, use get_status()
    print(compute_target.get_status().serialize())

Anteckning

Du kan välja att använda virtuella datorer med låg prioritet för att köra vissa eller alla arbets belastningar.You may choose to use low-priority VMs to run some or all of your workloads. Se så här skapar du en virtuell dator med låg prioritet.See how to create a low-priority VM.

Konfigurera indata och utdataConfigure inputs and output

Skapa ett data lager med exempel bilderCreate a datastore with sample images

Hämta utvärderings versionen av MNIST från den offentliga BLOB-behållaren sampledata på ett konto med namnet pipelinedata .Get the MNIST evaluation set from the public blob container sampledata on an account named pipelinedata. Skapa ett data lager med namnet mnist_datastore som pekar på den här behållaren.Create a datastore with the name mnist_datastore, which points to this container. I följande anrop till register_azure_blob_container anger overwrite flaggan för att True skriva över alla data lager som skapades tidigare med det namnet.In the following call to register_azure_blob_container, setting the overwrite flag to True overwrites any datastore that was created previously with that name.

Du kan ändra det här steget så att det pekar på din BLOB-behållare genom att ange dina egna värden för datastore_name , container_name och account_name .You can change this step to point to your blob container by providing your own values for datastore_name, container_name, and account_name.

from azureml.core import Datastore
from azureml.core import Workspace

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

Ange sedan standard data lagret för arbets ytan som utdata-datalager.Next, specify the workspace default datastore as the output datastore. Du använder den för att få en utmatnings effekt.You'll use it for inference output.

När du skapar din arbets yta är Azure Files   och blob-lagringen   kopplade till arbets ytan som standard.When you create your workspace, Azure Files and Blob storage are attached to the workspace by default. Azure Files är standard data lagret för en arbets yta, men du kan också använda Blob Storage som ett data lager.Azure Files is the default datastore for a workspace, but you can also use Blob storage as a datastore. Mer information finns i alternativ för Azure Storage.For more information, see Azure storage options.

def_data_store = ws.get_default_datastore()

Skapa data inmatningarCreate the data inputs

Indata för batch-härledning är de data som du vill partitionera för parallell bearbetning.The inputs for batch inference are the data that you want to partition for parallel processing. En pipeline för batch-härledning accepterar data indata via Dataset .A batch inference pipeline accepts data inputs through Dataset.

Datasetär för att utforska, transformera och hantera data i Azure Machine Learning.Dataset is for exploring, transforming, and managing data in Azure Machine Learning. Det finns två typer: TabularDataset och FileDataset .There are two types: TabularDataset and FileDataset. I det här exemplet ska du använda FileDataset som indata.In this example, you'll use FileDataset as the inputs. FileDatasetger dig möjlighet att ladda ned eller montera filerna i din beräkning.FileDataset provides you with the ability to download or mount the files to your compute. Genom att skapa en data uppsättning skapar du en referens till data käll platsen.By creating a dataset, you create a reference to the data source location. Om du har tillämpat transformeringar av under inställningar till data uppsättningen lagras de även i data uppsättningen.If you applied any subsetting transformations to the dataset, they will be stored in the dataset as well. Data behålls på den befintliga platsen, så ingen extra lagrings kostnad uppstår.The data remains in its existing location, so no extra storage cost is incurred.

Mer information om Azure Machine Learning data uppsättningar finns i skapa och komma åt data uppsättningar (för hands version).For more information about Azure Machine Learning datasets, see Create and access datasets (preview).

from azureml.core.dataset import Dataset

path_on_datastore = mnist_blob.path('mnist/')
input_mnist_ds = Dataset.File.from_files(path=path_on_datastore, validate=False)

För att kunna använda dynamiska data inmatningar när du kör pipeline för batch-härledning kan du definiera indata Dataset som en PipelineParameter .In order to use dynamic data inputs when running the batch inference pipeline, you can define the inputs Dataset as a PipelineParameter. Du kan ange indata-datauppsättningen varje gång du skickar en körnings pipeline för batch-härledning.You can specify the inputs dataset each time you resubmit a batch inference pipeline run.

from azureml.data.dataset_consumption_config import DatasetConsumptionConfig
from azureml.pipeline.core import PipelineParameter

pipeline_param = PipelineParameter(name="mnist_param", default_value=input_mnist_ds)
input_mnist_ds_consumption = DatasetConsumptionConfig("minist_param_config", pipeline_param).as_mount()

Skapa utdataCreate the output

PipelineDataobjekt används för att överföra mellanliggande data mellan pipeline-steg.PipelineData objects are used for transferring intermediate data between pipeline steps. I det här exemplet använder du den för att ge en utmatnings effekt.In this example, you use it for inference output.

from azureml.pipeline.core import Pipeline, PipelineData

output_dir = PipelineData(name="inferences", datastore=def_data_store)

Förbereda modellenPrepare the model

Ladda ned den förtränade avbildnings klassificerings modellenoch extrahera den sedan till models katalogen.Download the pre-trained image classification model, and then extract it to the models directory.

import os
import tarfile
import urllib.request

model_dir = 'models'
if not os.path.isdir(model_dir):
    os.mkdir(model_dir)

url="https://pipelinedata.blob.core.windows.net/mnist-model/mnist-tf.tar.gz"
response = urllib.request.urlretrieve(url, "model.tar.gz")
tar = tarfile.open("model.tar.gz", "r:gz")
tar.extractall(model_dir)

Registrera sedan modellen med arbets ytan så att den är tillgänglig för din beräknings resurs.Then register the model with your workspace so it's available to your compute resource.

from azureml.core.model import Model

# Register the downloaded model 
model = Model.register(model_path="models/",
                       model_name="mnist",
                       tags={'pretrained': "mnist"},
                       description="Mnist trained tensorflow model",
                       workspace=ws)

Skriv ditt härlednings skriptWrite your inference script

Varning

Följande kod är bara ett exempel som används av exempel antecknings boken .The following code is only a sample that the sample notebook uses. Du måste skapa ditt eget skript för ditt scenario.You'll need to create your own script for your scenario.

Skriptet måste innehålla två funktioner:The script must contain two functions:

  • init(): Använd den här funktionen för eventuell kostsam eller vanlig förberedelse för senare härledning.init(): Use this function for any costly or common preparation for later inference. Använd till exempel den för att läsa in modellen i ett globalt objekt.For example, use it to load the model into a global object. Den här funktionen kommer endast att anropas en gång i början av processen.This function will be called only once at beginning of process.
  • run(mini_batch): Funktionen kommer att köras för varje mini_batch instans.run(mini_batch): The function will run for each mini_batch instance.
    • mini_batch: ParallelRunStep anropar Run-metoden och skickar antingen en lista eller en Pandas DataFrame som ett argument till metoden.mini_batch: ParallelRunStep will invoke run method and pass either a list or pandas DataFrame as an argument to the method. Varje post i mini_batch är en fil Sök väg om indata är en FileDataset eller en Pandas DataFrame om indata är en TabularDataset .Each entry in mini_batch will be a file path if input is a FileDataset or a pandas DataFrame if input is a TabularDataset.
    • response: Run ()-metoden ska returnera en Pandas DataFrame eller en matris.response: run() method should return a pandas DataFrame or an array. För append_row output_action läggs dessa returnerade element till i den gemensamma utdatafilen.For append_row output_action, these returned elements are appended into the common output file. För summary_only ignoreras innehållet i elementen.For summary_only, the contents of the elements are ignored. För alla utdata-åtgärder anger varje returnerat utdata en lyckad körning av indata-element i mini-batch för indata.For all output actions, each returned output element indicates one successful run of input element in the input mini-batch. Se till att tillräckligt med data inkluderas i körnings resultatet för att mappa indata till att köra resultatet av utdata.Make sure that enough data is included in run result to map input to run output result. Kör utdata skrivs i utdatafilen och är inte garanterat i ordning, du bör använda vissa nycklar i utdata för att mappa den till indata.Run output will be written in output file and not guaranteed to be in order, you should use some key in the output to map it to input.
%%writefile digit_identification.py
# Snippets from a sample script.
# Refer to the accompanying digit_identification.py
# (https://aka.ms/batch-inference-notebooks)
# for the implementation script.

import os
import numpy as np
import tensorflow as tf
from PIL import Image
from azureml.core import Model


def init():
    global g_tf_sess

    # Pull down the model from the workspace
    model_path = Model.get_model_path("mnist")

    # Construct a graph to execute
    tf.reset_default_graph()
    saver = tf.train.import_meta_graph(os.path.join(model_path, 'mnist-tf.model.meta'))
    g_tf_sess = tf.Session()
    saver.restore(g_tf_sess, os.path.join(model_path, 'mnist-tf.model'))


def run(mini_batch):
    print(f'run method start: {__file__}, run({mini_batch})')
    resultList = []
    in_tensor = g_tf_sess.graph.get_tensor_by_name("network/X:0")
    output = g_tf_sess.graph.get_tensor_by_name("network/output/MatMul:0")

    for image in mini_batch:
        # Prepare each image
        data = Image.open(image)
        np_im = np.array(data).reshape((1, 784))
        # Perform inference
        inference_result = output.eval(feed_dict={in_tensor: np_im}, session=g_tf_sess)
        # Find the best probability, and add it to the result list
        best_result = np.argmax(inference_result)
        resultList.append("{}: {}".format(os.path.basename(image), best_result))

    return resultList

Om du har en annan fil eller mapp i samma katalog som ditt härlednings skript kan du referera till den genom att söka efter den aktuella arbets katalogen.If you have another file or folder in the same directory as your inference script, you can reference it by finding the current working directory.

script_dir = os.path.realpath(os.path.join(__file__, '..',))
file_path = os.path.join(script_dir, "<file_name>")

Skapa och kör pipelinen som innehåller ParallelRunStepBuild and run the pipeline containing ParallelRunStep

Nu har du allt du behöver: data inmatningar, modell, utdata och ditt skript för härledning.Now you have everything you need: the data inputs, the model, the output, and your inference script. Nu ska vi bygga pipelinen för batch-härledning som innehåller ParallelRunStep.Let's build the batch inference pipeline containing ParallelRunStep.

Förbereda miljönPrepare the environment

Börja med att ange beroenden för skriptet.First, specify the dependencies for your script. På så sätt kan du installera pip-paket samt konfigurera miljön.Doing so allows you to install pip packages as well as configure the environment.

Inkludera alltid azureml-Core och azureml-dataset-runtime [Pandas, säkring] i PIP-paket listan.Always include azureml-core and azureml-dataset-runtime[pandas, fuse] in the pip package list. Om du använder en anpassad Docker-avbildning (user_managed_dependencies = true) bör du även ha Conda installerat.If you use a custom docker image (user_managed_dependencies=True), you should also have conda installed.

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

batch_conda_deps = CondaDependencies.create(pip_packages=["tensorflow==1.15.2", "pillow", 
                                                          "azureml-core", "azureml-dataset-runtime[pandas, fuse]"])

batch_env = Environment(name="batch_environment")
batch_env.python.conda_dependencies = batch_conda_deps
batch_env.docker.enabled = True
batch_env.docker.base_image = DEFAULT_GPU_IMAGE

Ange parametrar med ParallelRunConfigSpecify the parameters using ParallelRunConfig

ParallelRunConfigär den viktigaste konfigurationen för ParallelRunStep instansen i Azure Machine Learning pipelinen.ParallelRunConfig is the major configuration for ParallelRunStep instance within the Azure Machine Learning pipeline. Du använder den för att omsluta ditt skript och konfigurera nödvändiga parametrar, inklusive alla följande poster:You use it to wrap your script and configure necessary parameters, including all of the following entries:

  • entry_script: Ett användar skript som en lokal fil Sök väg som ska köras parallellt på flera noder.entry_script: A user script as a local file path that will be run in parallel on multiple nodes. Om source_directory det finns använder du en relativ sökväg.If source_directory is present, use a relative path. Annars använder du valfri sökväg som är tillgänglig på datorn.Otherwise, use any path that's accessible on the machine.
  • mini_batch_size: Den mini-batch-storlek som skickas till ett enda run() anrop.mini_batch_size: The size of the mini-batch passed to a single run() call. (valfritt; standardvärdet är 10 filer för FileDataset och 1MB for TabularDataset .)(optional; the default value is 10 files for FileDataset and 1MB for TabularDataset.)
    • För är FileDataset det antalet filer med minimivärdet 1 .For FileDataset, it's the number of files with a minimum value of 1. Du kan kombinera flera filer i en mini-batch.You can combine multiple files into one mini-batch.
    • För är TabularDataset det data storleken.For TabularDataset, it's the size of data. Exempel värden är 1024 , 1024KB , 10MB och 1GB .Example values are 1024, 1024KB, 10MB, and 1GB. Det rekommenderade värdet är 1MB .The recommended value is 1MB. Mini-batch från TabularDataset kommer aldrig att överskrida fil gränser.The mini-batch from TabularDataset will never cross file boundaries. Om du till exempel har CSV-filer med olika storlekar är den minsta filen 100 KB och störst är 10 MB.For example, if you have .csv files with various sizes, the smallest file is 100 KB and the largest is 10 MB. Om du anger mini_batch_size = 1MB kommer filer med en storlek som är mindre än 1 MB att behandlas som en mini-batch.If you set mini_batch_size = 1MB, then files with a size smaller than 1 MB will be treated as one mini-batch. Filer med en storlek som är större än 1 MB delas upp i flera mini-batchar.Files with a size larger than 1 MB will be split into multiple mini-batches.
  • error_threshold: Antalet post-och fil haverier TabularDataset FileDataset som ska ignoreras under bearbetningen.error_threshold: The number of record failures for TabularDataset and file failures for FileDataset that should be ignored during processing. Om antalet fel för hela inflödet överskrider det här värdet kommer jobbet att avbrytas.If the error count for the entire input goes above this value, the job will be aborted. Fel tröskeln är för alla indatatyper och inte för enskilda mini-batchar som skickas till- run() metoden.The error threshold is for the entire input and not for individual mini-batch sent to the run() method. Intervallet är [-1, int.max] .The range is [-1, int.max]. -1Delen indikerar att ignorera alla avbrott under bearbetningen.The -1 part indicates ignoring all failures during processing.
  • output_action: Ett av följande värden anger hur utdata ska ordnas:output_action: One of the following values indicates how the output will be organized:
    • summary_only: Användar skriptet kommer att lagra utdata.summary_only: The user script will store the output. ParallelRunStepkommer bara att använda utdata för fel tröskel beräkningen.ParallelRunStep will use the output only for the error threshold calculation.
    • append_row: För alla indata skapas bara en fil i mappen utdata för att lägga till alla utdata avgränsade med rad.append_row: For all inputs, only one file will be created in the output folder to append all outputs separated by line.
  • append_row_file_name: Om du vill anpassa namnet på utdatafilen för append_row output_action (valfritt; standardvärde parallel_run_step.txt ).append_row_file_name: To customize the output file name for append_row output_action (optional; default value is parallel_run_step.txt).
  • source_directory: Sökvägar till mappar som innehåller alla filer som ska köras på beräknings målet (valfritt).source_directory: Paths to folders that contain all files to execute on the compute target (optional).
  • compute_target: AmlCompute Stöds endast.compute_target: Only AmlCompute is supported.
  • node_count: Antalet beräknade datornoder som ska användas för att köra användar skriptet.node_count: The number of compute nodes to be used for running the user script.
  • process_count_per_node: Antalet processer per nod.process_count_per_node: The number of processes per node. Bästa praxis är att ställa in på antalet GPU eller CPU en nod har (valfritt; standardvärde är 1 ).Best practice is to set to the number of GPU or CPU one node has (optional; default value is 1).
  • environment: Python-miljöns definition.environment: The Python environment definition. Du kan konfigurera den att använda en befintlig python-miljö eller konfigurera en tillfällig miljö.You can configure it to use an existing Python environment or to set up a temporary environment. Definitionen är också ansvarig för att ange nödvändiga program beroenden (valfritt).The definition is also responsible for setting the required application dependencies (optional).
  • logging_level: Logg utförlighet.logging_level: Log verbosity. Värden i ökande utförlighet är: WARNING , INFO och DEBUG .Values in increasing verbosity are: WARNING, INFO, and DEBUG. (valfritt; standardvärdet är INFO )(optional; the default value is INFO)
  • run_invocation_timeout: run() Tids gränsen för metod anrop i sekunder.run_invocation_timeout: The run() method invocation timeout in seconds. (valfritt; standardvärdet är 60 )(optional; default value is 60)
  • run_max_try: Maximalt antal försök run() för en mini-batch.run_max_try: Maximum try count of run() for a mini-batch. A run() Miss lyckas om ett undantag genereras eller om inget returneras när run_invocation_timeout nås (valfritt 3 ).A run() is failed if an exception is thrown, or nothing is returned when run_invocation_timeout is reached (optional; default value is 3).

Du kan ange mini_batch_size , node_count ,,, process_count_per_node logging_level run_invocation_timeout och run_max_try som PipelineParameter , så att du kan finjustera parametervärdena när du skickar om en pipeline-körning.You can specify mini_batch_size, node_count, process_count_per_node, logging_level, run_invocation_timeout, and run_max_try as PipelineParameter, so that when you resubmit a pipeline run, you can fine-tune the parameter values. I det här exemplet använder du PipelineParameter för mini_batch_size och Process_count_per_node och du kommer att ändra dessa värden när du skickar om en körning senare.In this example, you use PipelineParameter for mini_batch_size and Process_count_per_node and you will change these values when resubmit a run later.

I det här exemplet förutsätter vi att du använder digit_identification.py skriptet som diskuterades tidigare.This example assumes that you're using the digit_identification.py script that was discussed earlier. Om du använder ett eget skript ändrar du source_directory parametrarna och entry_script .If you use your own script, change the source_directory and entry_script parameters accordingly.

from azureml.pipeline.core import PipelineParameter
from azureml.pipeline.steps import ParallelRunConfig

parallel_run_config = ParallelRunConfig(
    source_directory='.',
    entry_script="digit_identification.py",
    mini_batch_size=PipelineParameter(name="batch_size_param", default_value="5"),
    error_threshold=10,
    output_action="append_row",
    append_row_file_name="mnist_outputs.txt",
    environment=batch_env,
    compute_target=compute_target,
    process_count_per_node=PipelineParameter(name="process_count_param", default_value=2),
    node_count=2)

Skapa ParallelRunStepCreate the ParallelRunStep

Skapa ParallelRunStep med hjälp av skriptet, miljö konfigurationen och parametrarna.Create the ParallelRunStep by using the script, environment configuration, and parameters. Ange det beräknings mål som du redan har kopplat till din arbets yta som mål för körning av ditt härlednings skript.Specify the compute target that you already attached to your workspace as the target of execution for your inference script. Använd ParallelRunStep för att skapa pipeline-steget för batch-härledning, som tar alla följande parametrar:Use ParallelRunStep to create the batch inference pipeline step, which takes all the following parameters:

  • name: Namnet på steget med följande namngivnings begränsningar: unika, 3-32 tecken och regex ^ [ a-z ] ([-a-Z0-9] * [a-Z0-9])? $.name: The name of the step, with the following naming restrictions: unique, 3-32 characters, and regex ^[a-z]([-a-z0-9]*[a-z0-9])?$.
  • parallel_run_config: Ett ParallelRunConfig objekt som definieras tidigare.parallel_run_config: A ParallelRunConfig object, as defined earlier.
  • inputs: En eller flera data uppsättningar med en enkel Azure Machine Learning typ som ska partitioneras för parallell bearbetning.inputs: One or more single-typed Azure Machine Learning datasets to be partitioned for parallel processing.
  • side_inputs: En eller flera referens data eller data uppsättningar som används som sid indata utan att behöva partitioneras.side_inputs: One or more reference data or datasets used as side inputs without need to be partitioned.
  • output: Ett PipelineData objekt som motsvarar utdata-katalogen.output: A PipelineData object that corresponds to the output directory.
  • arguments: En lista över argument som skickas till användar skriptet.arguments: A list of arguments passed to the user script. Använd unknown_args för att hämta dem i ditt Entry-skript (valfritt).Use unknown_args to retrieve them in your entry script (optional).
  • allow_reuse: Om steget ska återanvända tidigare resultat när det körs med samma inställningar/indata.allow_reuse: Whether the step should reuse previous results when run with the same settings/inputs. Om den här parametern är är False en ny körning alltid att skapas för det här steget under pipeline-körningen.If this parameter is False, a new run will always be generated for this step during pipeline execution. (valfritt; standardvärdet är True .)(optional; the default value is True.)
from azureml.pipeline.steps import ParallelRunStep

parallelrun_step = ParallelRunStep(
    name="predict-digits-mnist",
    parallel_run_config=parallel_run_config,
    inputs=[input_mnist_ds_consumption],
    output=output_dir,
    allow_reuse=True
)

Skapa och kör pipelinencreate and run the pipeline

Kör nu pipelinen.Now, run the pipeline. Börja med att skapa ett Pipeline objekt med hjälp av din arbets ytans referens och det pipeline-steg som du skapade.First, create a Pipeline object by using your workspace reference and the pipeline step that you created. stepsParametern är en matris med steg.The steps parameter is an array of steps. I det här fallet finns det bara ett steg för batch-härledning.In this case, there's only one step for batch inference. Placera stegen i den här matrisen för att bygga pipeliner som har flera steg.To build pipelines that have multiple steps, place the steps in order in this array.

Använd sedan Experiment.submit() funktionen för att skicka pipelinen för körning.Next, use the Experiment.submit() function to submit the pipeline for execution.

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

pipeline = Pipeline(workspace=ws, steps=[parallelrun_step])
experiment = Experiment(ws, 'digit_identification')
pipeline_run = experiment.submit(pipeline)

Övervaka jobbets härlednings jobbMonitor the batch inference job

Det kan ta lång tid att slutföra en batch-härledning.A batch inference job can take a long time to finish. Det här exemplet övervakar förloppet med hjälp av en Jupyter-widget.This example monitors progress by using a Jupyter widget. Du kan också övervaka jobbets förlopp genom att använda:You can also monitor the job's progress by using:

  • Azure Machine Learning Studio.Azure Machine Learning Studio.
  • Konsolens utdata från PipelineRun objektet.Console output from the PipelineRun object.
from azureml.widgets import RunDetails
RunDetails(pipeline_run).show()

pipeline_run.wait_for_completion(show_output=True)

Skicka en körning igen med nya data inmatningar och parametrarResubmit a run with new data inputs and parameters

Eftersom du har gjort indatana och flera konfigureras som kan PipelineParameter du skicka om en körning av en batch-härledning med en annan data uppsättning och finjustera parametrarna utan att behöva skapa en helt ny pipeline.Since you made the inputs and several configures as PipelineParameter, you can resubmit a batch inference run with a different dataset input and fine-tune the parameters without having to create an entirely new pipeline. Du kommer att använda samma data lager men använda bara en enda bild som data inmatning.You will use the same datastore but use only a single image as data inputs.

path_on_datastore = mnist_blob.path('mnist/0.png')
single_image_ds = Dataset.File.from_files(path=path_on_datastore, validate=False)

pipeline_run_2 = experiment.submit(pipeline, 
                                   pipeline_parameters={"mnist_param": single_image_ds, 
                                                        "batch_size_param": "1",
                                                        "process_count_param": 1}
)

pipeline_run_2.wait_for_completion(show_output=True)

Visa resultatetView the results

Resultaten från ovanstående körning skrivs till den DataStore som anges i PipelineData objektet som utdata, som i det här fallet kallas inferences.The results from above run are written to the DataStore specified in the PipelineData object as the output data, which in this case is called inferences. Resultaten lagras i standard-BLOB-behållaren, du kan navigera till ditt lagrings konto och Visa Storage Explorer, fil Sök vägen är azureml-blobstore-GUID/azureml/RunId / output_dir.The results are stored in the default blob container, you can navigate to your storage account and view through Storage Explorer, the file path is azureml-blobstore-GUID/azureml/RunId/output_dir.

Du kan också hämta dessa data för att visa resultatet.You can also download this data to view the results. Nedan visas exempel koden för att visa de första 10 raderna.Below is the sample code to view the first 10 rows.

import pandas as pd
import tempfile

batch_run = pipeline_run.find_step_run(parallelrun_step.name)[0]
batch_output = batch_run.get_output_data(output_dir.name)

target_dir = tempfile.mkdtemp()
batch_output.download(local_path=target_dir)
result_file = os.path.join(target_dir, batch_output.path_on_datastore, parallel_run_config.append_row_file_name)

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

Nästa stegNext steps

Om du vill se den här processens arbets slut till slut punkt, kan du testa den bärbara datorn.To see this process working end to end, try the batch inference notebook.

För fel sökning och fel söknings vägledning för ParallelRunStep, se instruktionen instruktion.For debugging and troubleshooting guidance for ParallelRunStep, see the how-to guide.

För fel sökning och fel söknings vägledning för pipelines, se instruktionen instruktion.For debugging and troubleshooting guidance for pipelines, see the how-to guide.

Lär dig hur du kör antecknings böcker genom att följa artikeln Använd Jupyter Notebooks för att utforska den här tjänsten.Learn how to run notebooks by following the article Use Jupyter notebooks to explore this service.