Nasazování modelů pomocí služby Azure Machine LearningDeploy models with Azure Machine Learning

PLATÍ PRO: ano Základnívydání                         ano   Enterprise   edition   (Upgrade na edici Enterprise) APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Zjistěte, jak nasadit model strojového učení jako webovou službu v cloudu Azure nebo na zařízení Azure IoT Edge.Learn how to deploy your machine learning model as a web service in the Azure cloud or to Azure IoT Edge devices.

Pracovní postup je podobný bez ohledu na to, kam model nasadíte:The workflow is similar no matter where you deploy your model:

  1. Zaregistrujte model.Register the model.
  2. Připravte nasazení.Prepare to deploy. (Zadejte prostředky, využití, cílový výpočetní objekt.)(Specify assets, usage, compute target.)
  3. Nasaďte model do cílového výpočetního objektu.Deploy the model to the compute target.
  4. Otestujte nasazený model, nazývaný také webová služba.Test the deployed model, also called a web service.

Další informace o konceptech, které jsou součástí pracovního postupu nasazení, najdete v tématu Správa, nasazení a monitorování modelů pomocí Azure Machine Learning.For more information on the concepts involved in the deployment workflow, see Manage, deploy, and monitor models with Azure Machine Learning.

PožadavkyPrerequisites

Připojení k pracovnímu prostoruConnect to your workspace

Následující kód ukazuje, jak se připojit k pracovnímu prostoru Azure Machine Learning pomocí informací uložených v mezipaměti do místního vývojového prostředí:The following code shows how to connect to an Azure Machine Learning workspace by using information cached to the local development environment:

  • Použití sady SDKUsing the SDK

    from azureml.core import Workspace
    ws = Workspace.from_config(path=".file-path/ws_config.json")
    

    Další informace o použití sady SDK pro připojení k pracovnímu prostoru najdete v dokumentaci k Azure Machine Learning SDK pro Python.For more information on using the SDK to connect to a workspace, see the Azure Machine Learning SDK for Python documentation.

  • Použití cliUsing the CLI

    Při použití rozhraní příkazového -w --workspace-name řádku použijte parametr nebo k určení pracovního prostoru pro příkaz.When using the CLI, use the -w or --workspace-name parameter to specify the workspace for the command.

  • Používání nástroje Visual Studio CodeUsing Visual Studio Code

    Při použití kódu sady Visual Studio vyberete pracovní prostor pomocí grafického rozhraní.When you use Visual Studio Code, you select the workspace by using a graphical interface. Další informace najdete v tématu Nasazení a správa modelů v dokumentaci k rozšíření kódu sady Visual Studio.For more information, see Deploy and manage models in the Visual Studio Code extension documentation.

Registrace modeluRegister your model

Registrovaný model je logický kontejner pro jeden nebo více souborů, které tvoří model.A registered model is a logical container for one or more files that make up your model. Například pokud máte model, který je uložen ve více souborech, můžete je zaregistrovat jako jeden model v pracovním prostoru.For example, if you have a model that's stored in multiple files, you can register them as a single model in the workspace. Po registraci souborů můžete stáhnout nebo nasadit registrovaný model a přijímat všechny soubory, které jste zaregistrovali.After you register the files, you can then download or deploy the registered model and receive all the files that you registered.

Tip

Při registraci modelu, zadáte cestu buď umístění v cloudu (z trénovacího běhu) nebo místní adresář.When you register a model, you provide the path of either a cloud location (from a training run) or a local directory. Tato cesta je jen najít soubory pro upload jako součást procesu registrace.This path is just to locate the files for upload as part of the registration process. Nemusí odpovídat cestě použité v vstupním skriptu.It doesn't need to match the path used in the entry script. Další informace naleznete v tématu Vyhledání souborů modelu v vstupním skriptu.For more information, see Locate model files in your entry script.

Modely strojového učení jsou registrované v pracovním prostoru Azure Machine Learning.Machine learning models are registered in your Azure Machine Learning workspace. Model může pocházet z Azure Machine Learning nebo odjinud.The model can come from Azure Machine Learning or from somewhere else. Při registraci modelu můžete volitelně poskytnout metadata o modelu.When registering a model, you can optionally provide metadata about the model. tags Slovníky properties a, které použijete pro registraci modelu, lze potom použít k filtrování modelů.The tags and properties dictionaries that you apply to a model registration can then be used to filter models.

Následující příklady ukazují, jak zaregistrovat model.The following examples demonstrate how to register a model.

Registrace modelu z experimentuRegister a model from an experiment run

Fragmenty kódu v této části ukazují, jak zaregistrovat model z trénovacího běhu:The code snippets in this section demonstrate how to register a model from a training run:

Důležité

Chcete-li použít tyto úryvky, musíte mít dříve provedené školení spustit Run a musíte mít přístup k objektu (SDK příklad) nebo hodnotu ID spuštění (příklad CLI).To use these snippets, you need to have previously performed a training run and you need to have access to the Run object (SDK example) or the run ID value (CLI example). Další informace o trénovacích modelech najdete v tématu Nastavení výpočetních cílů pro trénování modelu.For more information on training models, see Set up compute targets for model training.

  • Použití sady SDKUsing the SDK

    Při použití sady SDK k trénování modelu můžete přijímat buď Run objekt nebo AutoMLRun objekt, v závislosti na tom, jak jste trénoval model.When you use the SDK to train a model, you can receive either a Run object or an AutoMLRun object, depending on how you trained the model. Každý objekt lze zaregistrovat model vytvořený experimentu spustit.Each object can be used to register a model created by an experiment run.

    • Registrace modelu z azureml.core.Run objektu:Register a model from an azureml.core.Run object:

      model = run.register_model(model_name='sklearn_mnist',
                                 tags={'area': 'mnist'},
                                 model_path='outputs/sklearn_mnist_model.pkl')
      print(model.name, model.id, model.version, sep='\t')
      

      Parametr model_path odkazuje na umístění cloudu modelu.The model_path parameter refers to the cloud location of the model. V tomto příkladu se používá cesta k jednomu souboru.In this example, the path of a single file is used. Chcete-li do registrace modelu model_path zahrnout více souborů, nastavte na cestu ke složce, která soubory obsahuje.To include multiple files in the model registration, set model_path to the path of a folder that contains the files. Další informace naleznete v dokumentaci Run.register_model.For more information, see the Run.register_model documentation.

    • Registrace modelu z azureml.train.automl.run.AutoMLRun objektu:Register a model from an azureml.train.automl.run.AutoMLRun object:

          description = 'My AutoML Model'
          model = run.register_model(description = description,
                                     tags={'area': 'mnist'})
      
          print(run.model_id)
      

      V tomto metric příkladu iteration a parametry nejsou zadány, takže iterace s nejlepší primární metriky budou registrovány.In this example, the metric and iteration parameters aren't specified, so the iteration with the best primary metric will be registered. Hodnota model_id vrácená z běhu se používá místo názvu modelu.The model_id value returned from the run is used instead of a model name.

      Další informace naleznete v dokumentaci K odsát register_model.For more information, see the AutoMLRun.register_model documentation.

  • Použití cliUsing the CLI

    az ml model register -n sklearn_mnist  --asset-path outputs/sklearn_mnist_model.pkl  --experiment-name myexperiment --run-id myrunid --tag area=mnist
    

    Tip

    Pokud se zobrazí chybová zpráva oznamující, že rozšíření ml není nainstalováno, nainstalujte ji pomocí následujícího příkazu:If you get an error message stating that the ml extension isn't installed, use the following command to install it:

    az extension add -n azure-cli-ml
    

    Parametr --asset-path odkazuje na umístění cloudu modelu.The --asset-path parameter refers to the cloud location of the model. V tomto příkladu se používá cesta k jednomu souboru.In this example, the path of a single file is used. Chcete-li do registrace modelu --asset-path zahrnout více souborů, nastavte na cestu ke složce, která soubory obsahuje.To include multiple files in the model registration, set --asset-path to the path of a folder that contains the files.

  • Používání nástroje Visual Studio CodeUsing Visual Studio Code

    Zaregistrujte modely pomocí libovolné ho modelu soubory nebo složky pomocí rozšíření Visual Studio Code.Register models using any model files or folders by using the Visual Studio Code extension.

Registrace modelu z místního souboruRegister a model from a local file

Model můžete zaregistrovat poskytnutím místní cesty modelu.You can register a model by providing the local path of the model. Můžete zadat cestu ke složce nebo k jednomu souboru.You can provide the path of either a folder or a single file. Pomocí této metody můžete zaregistrovat modely trénované s Azure Machine Learning a pak stáhnout.You can use this method to register models trained with Azure Machine Learning and then downloaded. Tuto metodu můžete také použít k registraci modelů trénovaných mimo Azure Machine Learning.You can also use this method to register models trained outside of Azure Machine Learning.

Důležité

Měli byste používat pouze modely, které vytvoříte nebo získáte z důvěryhodného zdroje.You should use only models that you create or obtain from a trusted source. Serializované modely byste měli považovat za kód, protože chyby zabezpečení byly zjištěny v řadě oblíbených formátů.You should treat serialized models as code, because security vulnerabilities have been discovered in a number of popular formats. Modely mohou být také záměrně trénované se zlým úmyslem poskytnout neobjektivní nebo nepřesný výstup.Also, models might be intentionally trained with malicious intent to provide biased or inaccurate output.

  • Použití sad SDK a ONNXUsing the SDK and ONNX

    import os
    import urllib.request
    from azureml.core.model import Model
    # Download model
    onnx_model_url = "https://www.cntk.ai/OnnxModels/mnist/opset_7/mnist.tar.gz"
    urllib.request.urlretrieve(onnx_model_url, filename="mnist.tar.gz")
    os.system('tar xvzf mnist.tar.gz')
    # Register model
    model = Model.register(workspace = ws,
                            model_path ="mnist/model.onnx",
                            model_name = "onnx_mnist",
                            tags = {"onnx": "demo"},
                            description = "MNIST image classification CNN from ONNX Model Zoo",)
    

    Chcete-li do registrace modelu model_path zahrnout více souborů, nastavte na cestu ke složce, která soubory obsahuje.To include multiple files in the model registration, set model_path to the path of a folder that contains the files.

  • Použití cliUsing the CLI

    az ml model register -n onnx_mnist -p mnist/model.onnx
    

    Chcete-li do registrace modelu -p zahrnout více souborů, nastavte na cestu ke složce, která soubory obsahuje.To include multiple files in the model registration, set -p to the path of a folder that contains the files.

Odhad času: Přibližně 10 sekund.Time estimate: Approximately 10 seconds.

Další informace naleznete v dokumentaci k třídě Model.For more information, see the documentation for the Model class.

Další informace o práci s modely trénovanými mimo Azure Machine Learning najdete v tématu Jak nasadit existující model.For more information on working with models trained outside Azure Machine Learning, see How to deploy an existing model.

Koncové body s jedním a více modelySingle versus multi-model endpoints

Azure ML podporuje nasazení jednoho nebo více modelů za jeden koncový bod.Azure ML supports deploying single or multiple models behind a single endpoint.

Koncové body s více modely používají sdílený kontejner k hostování více modelů.Multi-model endpoints use a shared container to host multiple models. To pomáhá snižovat režijní náklady, zlepšuje využití a umožňuje řetězit moduly do souborů.This helps to reduce overhead costs, improves utilization, and enables you to chain modules together into ensembles. Modely zadané ve skriptu nasazení jsou připojeny a zpřístupněny na disku sloužícího kontejneru – můžete je načíst do paměti na vyžádání a skóre na základě konkrétního modelu, který je požadován v době hodnocení.Models you specify in your deployment script are mounted and made available on the disk of the serving container - you can load them into memory on demand and score based on the specific model being requested at scoring time.

Příklad E2E, který ukazuje, jak používat více modelů za jeden kontejnerizovaný koncový bod, naleznete v tomto příkladuFor an E2E example, which shows how to use multiple models behind a single containerized endpoint, see this example

Příprava nasazeníPrepare to deploy

Chcete-li nasadit model jako službu, potřebujete následující součásti:To deploy the model as a service, you need the following components:

  • Definujte odvozené prostředí.Define inference environment. Toto prostředí zapouzdřuje závislosti potřebné ke spuštění modelu pro odvození.This environment encapsulates the dependencies required to run your model for inference.
  • Definujte bodovací kód.Define scoring code. Tento skript přijímá požadavky, skóre požadavky pomocí modelu a vrátí výsledky.This script accepts requests, scores the requests by using the model, and returns the results.
  • Definujte konfiguraci odvození.Define inference configuration. Konfigurace odvození určuje konfiguraci prostředí, vstupní skript a další součásti potřebné ke spuštění modelu jako služby.The inference configuration specifies the environment configuration, entry script, and other components needed to run the model as a service.

Jakmile budete mít potřebné součásti, můžete profilovat službu, která bude vytvořena v důsledku nasazení modelu pochopit jeho požadavky na procesor a paměť.Once you have the necessary components, you can profile the service that will be created as a result of deploying your model to understand its CPU and memory requirements.

1. Definovat odvozené prostředí1. Define inference environment

Odvození konfigurace popisuje, jak nastavit webovou službu obsahující model.An inference configuration describes how to set up the web-service containing your model. Používá se později, při nasazení modelu.It's used later, when you deploy the model.

Konfigurace odvození používá prostředí Azure Machine Learning k definování softwarových závislostí potřebných pro vaše nasazení.Inference configuration uses Azure Machine Learning environments to define the software dependencies needed for your deployment. Prostředí umožňují vytvářet, spravovat a znovu používat softwarové závislosti potřebné pro školení a nasazení.Environments allow you to create, manage, and reuse the software dependencies required for training and deployment. Můžete vytvořit prostředí z vlastních souborů závislostí nebo použít jedno z kurátorských prostředí Azure Machine Learning.You can create an environment from custom dependency files or use one of the curated Azure Machine Learning environments. Následující YAML je příkladem souboru závislostí Conda pro odvození.The following YAML is an example of a Conda dependencies file for inference. Všimněte si, že je nutné označit azureml výchozí hodnoty s verion >= 1.0.45 jako pip závislost, protože obsahuje funkce potřebné k hostování modelu jako webové služby.Note that you must indicate azureml-defaults with verion >= 1.0.45 as a pip dependency, because it contains the functionality needed to host the model as a web service. Pokud chcete použít automatické generování schématu, vstupní skript musí inference-schema také importovat balíčky.If you want to use automatic schema generation, your entry script must also import the inference-schema packages.

name: project_environment
dependencies:
  - python=3.6.2
  - scikit-learn=0.20.0
  - pip:
      # You must list azureml-defaults as a pip dependency
    - azureml-defaults>=1.0.45
    - inference-schema[numpy-support]

Důležité

Pokud je vaše závislost dostupná prostřednictvím conda a pip (od PyPi), společnost Microsoft doporučuje používat verzi Conda, protože balíčky Conda se obvykle docházejí s předem vytvořenými binárními soubory, které usnadňují instalaci.If your dependency is available through both Conda and pip (from PyPi), Microsoft recommends using the Conda version, as Conda packages typically come with pre-built binaries that make installation more reliable.

Další informace naleznete v tématu Principy Conda a Pip.For more information, see Understanding Conda and Pip.

Chcete-li zkontrolovat, zda je vaše závislost conda search <package-name> k dispozici prostřednictvím Conda, použijte příkaz nebo použijte indexy balíčků na https://anaconda.org/anaconda/repo adrese a https://anaconda.org/conda-forge/repo.To check if your dependency is available through Conda, use the conda search <package-name> command, or use the package indexes at https://anaconda.org/anaconda/repo and https://anaconda.org/conda-forge/repo.

Soubor závislostí můžete použít k vytvoření objektu prostředí a jeho uložení do pracovního prostoru pro budoucí použití:You can use the dependencies file to create an environment object and save it to your workspace for future use:

from azureml.core.environment import Environment
myenv = Environment.from_conda_specification(name = 'myenv',
                                             file_path = 'path-to-conda-specification-file'
myenv.register(workspace=ws)

2. Definovat bodovací kód2. Define scoring code

Vstupní skript přijímá data odeslaná do nasazené webové služby a předává je do modelu.The entry script receives data submitted to a deployed web service and passes it to the model. Potom vezme odpověď vrácenou modelem a vrátí ji klientovi.It then takes the response returned by the model and returns that to the client. Skript je specifický pro váš model.The script is specific to your model. Musí pochopit data, která model očekává a vrátí.It must understand the data that the model expects and returns.

Skript obsahuje dvě funkce, které načítají a spouštějí model:The script contains two functions that load and run the model:

  • init(): Tato funkce obvykle načte model do globálního objektu.init(): Typically, this function loads the model into a global object. Tato funkce je spuštěna pouze jednou, když je spuštěn kontejner Dockeru pro webovou službu.This function is run only once, when the Docker container for your web service is started.

  • run(input_data): Tato funkce používá model k předvídání hodnoty založené na vstupních datech.run(input_data): This function uses the model to predict a value based on the input data. Vstupy a výstupy spuštění obvykle pro serializaci a deserializaci používají JSON.Inputs and outputs of the run typically use JSON for serialization and deserialization. Pracovat můžete také s nezpracovanými binárními daty.You can also work with raw binary data. Data můžete transformovat před jejich odesláním do modelu nebo před jejich vrácením klientovi.You can transform the data before sending it to the model or before returning it to the client.

Načtení souborů modelu do vstupního skriptuLoad model files in your entry script

Existují dva způsoby, jak najít modely v vstupním skriptu:There are two ways to locate models in your entry script:

  • AZUREML_MODEL_DIR: Proměnná prostředí obsahující cestu k umístění modelu.AZUREML_MODEL_DIR: An environment variable containing the path to the model location.
  • Model.get_model_path: Rozhraní API, které vrací cestu k souboru modelu pomocí registrovaného názvu modelu.Model.get_model_path: An API that returns the path to model file using the registered model name.
AZUREML_MODEL_DIRAZUREML_MODEL_DIR

AZUREML_MODEL_DIR je proměnná prostředí vytvořená během nasazení služby.AZUREML_MODEL_DIR is an environment variable created during service deployment. Tuto proměnnou prostředí můžete použít k nalezení umístění nasazených modelů.You can use this environment variable to find the location of the deployed model(s).

Následující tabulka popisuje hodnotu AZUREML_MODEL_DIR v závislosti na počtu nasazených modelů:The following table describes the value of AZUREML_MODEL_DIR depending on the number of models deployed:

NasazeníDeployment Hodnota proměnné prostředíEnvironment variable value
Jediný modelSingle model Cesta ke složce obsahující model.The path to the folder containing the model.
Více modelůMultiple models Cesta ke složce obsahující všechny modely.The path to the folder containing all models. Modely jsou umístěny podle názvu$MODEL_NAME/$VERSIONa verze v této složce ( )Models are located by name and version in this folder ($MODEL_NAME/$VERSION)

Během registrace modelu a nasazení modely jsou umístěny v cestě AZUREML_MODEL_DIR a jejich původní názvy souborů jsou zachovány.During model registration and deployment, Models are placed in the AZUREML_MODEL_DIR path, and their original filenames are preserved.

Chcete-li získat cestu k souboru modelu v vstupním skriptu, zkombinujte proměnnou prostředí s cestou souboru, kterou hledáte.To get the path to a model file in your entry script, combine the environment variable with the file path you're looking for.

Příklad jednoho modeluSingle model example

# Example when the model is a file
model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_regression_model.pkl')

# Example when the model is a folder containing a file
file_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'my_model_folder', 'sklearn_regression_model.pkl')

Příklad více modelůMultiple model example

# Example when the model is a file, and the deployment contains multiple models
model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_model', '1', 'sklearn_regression_model.pkl')
get_model_pathget_model_path

Při registraci modelu zadáte název modelu, který se používá pro správu modelu v registru.When you register a model, you provide a model name that's used for managing the model in the registry. Tento název se používá s metodou Model.get_model_path() k načtení cesty k souboru modelu nebo souborům v místním systému souborů.You use this name with the Model.get_model_path() method to retrieve the path of the model file or files on the local file system. Pokud zaregistrujete složku nebo kolekci souborů, vrátí toto rozhraní API cestu k adresáři, který tyto soubory obsahuje.If you register a folder or a collection of files, this API returns the path of the directory that contains those files.

Když zaregistrujete model, dáte mu název.When you register a model, you give it a name. Název odpovídá místu, kde je umístěn model, místně nebo během nasazení služby.The name corresponds to where the model is placed, either locally or during service deployment.

(Nepovinné) Definovat schéma webové služby modelu(Optional) Define model web service schema

Chcete-li automaticky generovat schéma pro webovou službu, zadejte ukázku vstupu nebo výstupu v konstruktoru pro jeden z definovaných objektů typu.To automatically generate a schema for your web service, provide a sample of the input and/or output in the constructor for one of the defined type objects. Typ a ukázka se používají k automatickému vytvoření schématu.The type and sample are used to automatically create the schema. Azure Machine Learning pak vytvoří specifikaci OpenAPI (Swagger) pro webovou službu během nasazení.Azure Machine Learning then creates an OpenAPI (Swagger) specification for the web service during deployment.

Tyto typy jsou aktuálně podporovány:These types are currently supported:

  • pandas
  • numpy
  • pyspark
  • Standardní objekt PythonuStandard Python object

Chcete-li použít generování schématu, zahrňte balíček s otevřeným zdrojovým kódem inference-schema do souboru závislostí.To use schema generation, include the open-source inference-schema package in your dependencies file. Další informace o tomto https://github.com/Azure/InferenceSchemabalíčku naleznete v tématu .For more information on this package, see https://github.com/Azure/InferenceSchema. Definujte vstupní a výstupní ukázkové formáty v proměnných input_sample a, output_sample které představují formáty požadavků a odpovědí pro webovou službu.Define the input and output sample formats in the input_sample and output_sample variables, which represent the request and response formats for the web service. Tyto ukázky použijte ve vstupní a výstupní run() funkce decorators na funkci.Use these samples in the input and output function decorators on the run() function. Následující příklad scikit-learn používá generování schématu.The following scikit-learn example uses schema generation.

Ukázkový vstupní skriptExample entry script

Následující příklad ukazuje, jak přijmout a vrátit data JSON:The following example demonstrates how to accept and return JSON data:

#Example: scikit-learn and Swagger
import json
import numpy as np
import os
from sklearn.externals import joblib
from sklearn.linear_model import Ridge

from inference_schema.schema_decorators import input_schema, output_schema
from inference_schema.parameter_types.numpy_parameter_type import NumpyParameterType


def init():
    global model
    # AZUREML_MODEL_DIR is an environment variable created during deployment. Join this path with the filename of the model file.
    # It holds the path to the directory that contains the deployed model (./azureml-models/$MODEL_NAME/$VERSION).
    # If there are multiple models, this value is the path to the directory containing all deployed models (./azureml-models).
    # Alternatively: model_path = Model.get_model_path('sklearn_mnist')
    model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_mnist_model.pkl')
    # Deserialize the model file back into a sklearn model
    model = joblib.load(model_path)


input_sample = np.array([[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]])
output_sample = np.array([3726.995])


@input_schema('data', NumpyParameterType(input_sample))
@output_schema(NumpyParameterType(output_sample))
def run(data):
    try:
        result = model.predict(data)
        # You can return any data type, as long as it is JSON serializable.
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

Následující příklad ukazuje, jak definovat vstupní <key: value> data jako slovník pomocí DataFrame.The following example demonstrates how to define the input data as a <key: value> dictionary by using a DataFrame. Tato metoda je podporovaná pro využívání nasazené webové služby z Power BI.This method is supported for consuming the deployed web service from Power BI. (Dalšíinformace o využití webové služby z Power BI.)(Learn more about how to consume the web service from Power BI.)

import json
import pickle
import numpy as np
import pandas as pd
import azureml.train.automl
from sklearn.externals import joblib
from azureml.core.model import Model

from inference_schema.schema_decorators import input_schema, output_schema
from inference_schema.parameter_types.numpy_parameter_type import NumpyParameterType
from inference_schema.parameter_types.pandas_parameter_type import PandasParameterType


def init():
    global model
    # Replace filename if needed.
    model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'model_file.pkl')
    # Deserialize the model file back into a sklearn model.
    model = joblib.load(model_path)


input_sample = pd.DataFrame(data=[{
    # This is a decimal type sample. Use the data type that reflects this column in your data.
    "input_name_1": 5.1,
    # This is a string type sample. Use the data type that reflects this column in your data.
    "input_name_2": "value2",
    # This is an integer type sample. Use the data type that reflects this column in your data.
    "input_name_3": 3
}])

# This is an integer type sample. Use the data type that reflects the expected result.
output_sample = np.array([0])


@input_schema('data', PandasParameterType(input_sample))
@output_schema(NumpyParameterType(output_sample))
def run(data):
    try:
        result = model.predict(data)
        # You can return any data type, as long as it is JSON serializable.
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

Další příklady naleznete v následujících skriptech:For more examples, see the following scripts:

3. Definovat konfiguraci odvození3. Define inference configuration

Následující příklad ukazuje načítání prostředí z pracovního prostoru a jeho použití s konfigurací odvození:The following example demonstrates loading an environment from your workspace and then using it with the inference configuration:

from azureml.core.environment import Environment
from azureml.core.model import InferenceConfig


myenv = Environment.get(workspace=ws, name='myenv', version='1')
inference_config = InferenceConfig(entry_script='path-to-score.py',
                                   environment=myenv)

Další informace o prostředích naleznete v tématu Vytváření a správa prostředí pro školení a nasazení.For more information on environments, see Create and manage environments for training and deployment.

Další informace o konfiguraci odvození naleznete v dokumentaci třídy InferenceConfig.For more information on inference configuration, see the InferenceConfig class documentation.

Informace o použití vlastní image Dockeru s odvozenou konfigurací najdete v tématu Jak nasadit model pomocí vlastní image Dockeru.For information on using a custom Docker image with an inference configuration, see How to deploy a model using a custom Docker image.

Příklad funkce CLI InferenceConfigCLI example of InferenceConfig

Položky v inferenceconfig.json dokumentu mapují na parametry třídy InferenceConfig.The entries in the inferenceconfig.json document map to the parameters for the InferenceConfig class. Následující tabulka popisuje mapování mezi entitami v dokumentu JSON a parametry metody:The following table describes the mapping between entities in the JSON document and the parameters for the method:

Entita JSONJSON entity Parametr metodyMethod parameter PopisDescription
entryScript entry_script Cesta k místnímu souboru, který obsahuje kód pro spuštění obrazu.Path to a local file that contains the code to run for the image.
sourceDirectory source_directory Nepovinný parametr.Optional. Cesta ke složkám, které obsahují všechny soubory k vytvoření obrazu, což usnadňuje přístup k souborům v této složce nebo podsložce.Path to folders that contain all files to create the image, which makes it easy to access any files within this folder or subfolder. Můžete nahrát celou složku z místního počítače jako závislosti pro webovou službu.You can upload an entire folder from your local machine as dependencies for the Webservice. Poznámka: cesty entry_script, conda_file a extra_docker_file_steps jsou relativní cesty k cestě source_directory.Note: your entry_script, conda_file, and extra_docker_file_steps paths are relative paths to the source_directory path.
environment environment Nepovinný parametr.Optional. Prostředí Azure Machine Learning.Azure Machine Learning environment.

Do konfiguračního souboru odvození můžete zahrnout úplné specifikace prostředí Azure Machine Learning.You can include full specifications of an Azure Machine Learning environment in the inference configuration file. Pokud toto prostředí neexistuje ve vašem pracovním prostoru, Azure Machine Learning ho vytvoří.If this environment doesn't exist in your workspace, Azure Machine Learning will create it. V opačném případě Azure Machine Learning bude aktualizovat prostředí v případě potřeby.Otherwise, Azure Machine Learning will update the environment if necessary. Následující JSON je příkladem:The following JSON is an example:

{
    "entryScript": "score.py",
    "environment": {
        "docker": {
            "arguments": [],
            "baseDockerfile": null,
            "baseImage": "mcr.microsoft.com/azureml/base:intelmpi2018.3-ubuntu16.04",
            "enabled": false,
            "sharedVolumes": true,
            "shmSize": null
        },
        "environmentVariables": {
            "EXAMPLE_ENV_VAR": "EXAMPLE_VALUE"
        },
        "name": "my-deploy-env",
        "python": {
            "baseCondaEnvironment": null,
            "condaDependencies": {
                "channels": [
                    "conda-forge"
                ],
                "dependencies": [
                    "python=3.6.2",
                    {
                        "pip": [
                            "azureml-defaults",
                            "azureml-telemetry",
                            "scikit-learn",
                            "inference-schema[numpy-support]"
                        ]
                    }
                ],
                "name": "project_environment"
            },
            "condaDependenciesFile": null,
            "interpreterPath": "python",
            "userManagedDependencies": false
        },
        "version": "1"
    }
}

Můžete také použít existující prostředí Azure Machine Learning v oddělených parametrech rozhraní příkazového řádku a odebrat klíč "prostředí" z konfiguračního souboru odvození.You can also use an existing Azure Machine Learning environment in separated CLI parameters and remove the "environment" key from the inference configuration file. Použijte -e pro název prostředí a --ev pro verzi prostředí.Use -e for the environment name, and --ev for the environment version. Pokud nezadáte --ev, bude použita nejnovější verze.If you don't specify --ev, the latest version will be used. Zde je příklad konfiguračního souboru odvození:Here is an example of an inference configuration file:

{
    "entryScript": "score.py",
    "sourceDirectory": null
}

Následující příkaz ukazuje, jak nasadit model pomocí předchozího konfiguračního souboru odvození (s názvem myInferenceConfig.json).The following command demonstrates how to deploy a model using the previous inference configuration file (named myInferenceConfig.json).

Používá také nejnovější verzi existujícího prostředí Azure Machine Learning (s názvem AzureML-Minimal).It also uses the latest version of an existing Azure Machine Learning environment (named AzureML-Minimal).

az ml model deploy -m mymodel:1 --ic myInferenceConfig.json -e AzureML-Minimal --dc deploymentconfig.json

Následující příkaz ukazuje, jak nasadit model pomocí příkazového příkazu k příkazu k příkazu:The following command demonstrates how to deploy a model by using the CLI:

az ml model deploy -n myservice -m mymodel:1 --ic inferenceconfig.json

V tomto příkladu konfigurace určuje následující nastavení:In this example, the configuration specifies the following settings:

  • Že model vyžaduje Python.That the model requires Python.
  • Vstupní skript, který se používá ke zpracování webových požadavků odeslaných nasazené službě.The entry script, which is used to handle web requests sent to the deployed service.
  • Soubor Conda, který popisuje balíčky Pythonu potřebné pro odvození.The Conda file that describes the Python packages needed for inference.

Informace o použití vlastní image Dockeru s odvozenou konfigurací najdete v tématu Jak nasadit model pomocí vlastní image Dockeru.For information on using a custom Docker image with an inference configuration, see How to deploy a model using a custom Docker image.

4. (Nepovinné) Profilmodelu k určení využití prostředků4. (Optional) Profile your model to determine resource utilization

Jakmile zaregistrujete model a připravíte další součásti nezbytné pro jeho nasazení, můžete určit procesor a paměť, které bude nasazená služba potřebovat.Once you have registered your model and prepared the other components necessary for its deployment, you can determine the CPU and memory the deployed service will need. Profilování testuje službu, která spouští váš model a vrací informace, jako je využití procesoru, využití paměti a latence odezvy.Profiling tests the service that runs your model and returns information such as the CPU usage, memory usage, and response latency. Poskytuje také doporučení pro procesor a paměť na základě využití prostředků.It also provides a recommendation for the CPU and memory based on resource usage.

Chcete-li profilovat model, budete potřebovat:In order to profile your model, you will need:

  • Registrovaný model.A registered model.
  • Odvození konfigurace na základě vstupního skriptu a definice prostředí odvození.An inference configuration based on your entry script and inference environment definition.
  • Tabulková datová sada s jedním sloupcem, kde každý řádek obsahuje řetězec představující data ukázkového požadavku.A single column tabular dataset, where each row contains a string representing sample request data.

Důležité

V tomto okamžiku podporujeme pouze profilování služeb, které očekávají, že jejich data požadavku budou řetězec, například: řetězec serializovaný json, text, serializovaný obrázek řetězce atd. Obsah každého řádku datové sady (řetězce) bude vložen do těla požadavku HTTP a odeslán službě zapouzdření modelu pro vyhodnocování.At this point we only support profiling of services that expect their request data to be a string, for example: string serialized json, text, string serialized image, etc. The content of each row of the dataset (string) will be put into the body of the HTTP request and sent to the service encapsulating the model for scoring.

Níže je uveden příklad, jak můžete vytvořit vstupní datovou sadu pro profil služby, která očekává, že její data příchozích požadavků budou obsahovat serializovaný json.Below is an example of how you can construct an input dataset to profile a service that expects its incoming request data to contain serialized json. V tomto případě jsme vytvořili datovou sadu založenou na sto instancích stejného obsahu dat požadavku.In this case, we created a dataset based one hundred instances of the same request data content. V reálných scénářích doporučujeme použít větší datové sady obsahující různé vstupy, zejména v případě, že vaše využití prostředků modelu nebo chování je závislé na vstupu.In real world scenarios we suggest that you use larger datasets containing various inputs, especially if your model resource usage/behavior is input dependent.

import json
from azureml.core import Datastore
from azureml.core.dataset import Dataset
from azureml.data import dataset_type_definitions

input_json = {'data': [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
                       [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]]}
# create a string that can be utf-8 encoded and
# put in the body of the request
serialized_input_json = json.dumps(input_json)
dataset_content = []
for i in range(100):
    dataset_content.append(serialized_input_json)
dataset_content = '\n'.join(dataset_content)
file_name = 'sample_request_data.txt'
f = open(file_name, 'w')
f.write(dataset_content)
f.close()

# upload the txt file created above to the Datastore and create a dataset from it
data_store = Datastore.get_default(ws)
data_store.upload_files(['./' + file_name], target_path='sample_request_data')
datastore_path = [(data_store, 'sample_request_data' +'/' + file_name)]
sample_request_data = Dataset.Tabular.from_delimited_files(
    datastore_path, separator='\n',
    infer_column_types=True,
    header=dataset_type_definitions.PromoteHeadersBehavior.NO_HEADERS)
sample_request_data = sample_request_data.register(workspace=ws,
                                                   name='sample_request_data',
                                                   create_new_version=True)

Jakmile budete mít připravenou datovou sadu obsahující ukázková data požadavku, vytvořte konfiguraci odvození.Once you have the dataset containing sample request data ready, create an inference configuration. Odvození konfigurace je založena na score.py a definice prostředí.Inference configuration is based on the score.py and the environment definition. Následující příklad ukazuje, jak vytvořit konfiguraci odvození a spustit profilování:The following example demonstrates how to create the inference configuration and run profiling:

from azureml.core.model import InferenceConfig, Model
from azureml.core.dataset import Dataset


model = Model(ws, id=model_id)
inference_config = InferenceConfig(entry_script='path-to-score.py',
                                   environment=myenv)
input_dataset = Dataset.get_by_name(workspace=ws, name='sample_request_data')
profile = Model.profile(ws,
            'unique_name',
            [model],
            inference_config,
            input_dataset=input_dataset)

profile.wait_for_completion(True)

# see the result
details = profile.get_details()

Následující příkaz ukazuje, jak profilovat model pomocí příkazového příkazu k příkazu k příkazu:The following command demonstrates how to profile a model by using the CLI:

az ml model profile -g <resource-group-name> -w <workspace-name> --inference-config-file <path-to-inf-config.json> -m <model-id> --idi <input-dataset-id> -n <unique-name>

Tip

Chcete-li zachovat informace vrácené profilováním, použijte značky nebo vlastnosti modelu.To persist the information returned by profiling, use tags or properties for the model. Pomocí značek nebo vlastností ukládá data s modelem v registru modelu.Using tags or properties stores the data with the model in the model registry. Následující příklady ukazují přidání nové značky obsahující informace requestedCpu a: requestedMemoryInGbThe following examples demonstrate adding a new tag containing the requestedCpu and requestedMemoryInGb information:

model.add_tags({'requestedCpu': details['requestedCpu'],
                'requestedMemoryInGb': details['requestedMemoryInGb']})
az ml model profile -g <resource-group-name> -w <workspace-name> --i <model-id> --add-tag requestedCpu=1 --add-tag requestedMemoryInGb=0.5

Nasazení do cíleDeploy to target

Nasazení používá konfiguraci nasazení konfigurace konfigurace odvození k nasazení modelů.Deployment uses the inference configuration deployment configuration to deploy the models. Proces nasazení je podobný bez ohledu na cíl výpočetního prostředí.The deployment process is similar regardless of the compute target. Nasazení do AKS se mírně liší, protože je nutné zadat odkaz na cluster AKS.Deploying to AKS is slightly different because you must provide a reference to the AKS cluster.

Výběr výpočetního cíleChoose a compute target

K hostování nasazení webové služby můžete použít následující výpočetní cíle nebo výpočetní prostředky:You can use the following compute targets, or compute resources, to host your web service deployment:

Cílový výpočetní objektCompute target PoužitíUsed for Podpora GPUGPU support Podpora pro FPGAFPGA support PopisDescription
Místní  webová službaLocal web service Testování/laděníTesting/debugging     Používá se pro omezené testování a řešení potíží.Use for limited testing and troubleshooting. Hardwarová akcelerace závisí na použití knihoven v místním systému.Hardware acceleration depends on use of libraries in the local system.
Webová služba výpočetní instance Azure Machine LearningAzure Machine Learning compute instance web service Testování/laděníTesting/debugging     Používá se pro omezené testování a řešení potíží.Use for limited testing and troubleshooting.
Azure Kubernetes Service (AKS)Azure Kubernetes Service (AKS) Odvození v reálném časeReal-time inference Ano (nasazení webové služby)Yes (web service deployment) AnoYes Používá se pro nasazení ve velkém měřítku.Use for high-scale production deployments. Poskytuje rychlou dobu odezvy a automatické škálování nasazené služby.Provides fast response time and autoscaling of the deployed service. Automatické škálování clusteru není podporované prostřednictvím sady Azure Machine Learning SDK.Cluster autoscaling isn't supported through the Azure Machine Learning SDK. Chcete-li změnit uzly v clusteru AKS, použijte ui pro cluster AKS na webu Azure Portal.To change the nodes in the AKS cluster, use the UI for your AKS cluster in the Azure portal. AKS je jedinou možností, která je k dispozici pro návrháře.AKS is the only option available for the designer.
Azure Container InstancesAzure Container Instances Testování nebo vývojTesting or development     Používá se pro úlohy založené na procesoru v nízkém měřítku, které vyžadují méně než 48 GB paměti RAM.Use for low-scale CPU-based workloads that require less than 48 GB of RAM.
Výpočetní clustery Azure Machine LearningAzure Machine Learning compute clusters (Náhled) Odvození dávky (Preview) Batch inference Ano (kanál strojového učení)Yes (machine learning pipeline)   Spusťte dávkové vyhodnocování na výpočetních výkonech bez serveru.Run batch scoring on serverless compute. Podporuje virtuální ch odpyka normálních a málo prioritních.Supports normal and low-priority VMs.
Azure FunctionsAzure Functions (Náhled) Odvození v reálném čase(Preview) Real-time inference      
Azure IoT EdgeAzure IoT Edge (Náhled) Modul IoT (Preview) IoT module     Nasazujte a obsluhujte modely ML na zařízeních IoT.Deploy and serve ML models on IoT devices.
Azure Data Box EdgeAzure Data Box Edge Přes IoT EdgeVia IoT Edge   AnoYes Nasazujte a obsluhujte modely ML na zařízeních IoT.Deploy and serve ML models on IoT devices.

Poznámka

I když výpočetní cíle, jako je místní, Azure Machine Learning výpočetní instance a Azure Machine Learning výpočetní clustery podporují GPU pro školení a experimentování, pomocí GPU pro odvození při nasazení jako webová služba je podporována pouze ve službě Azure Kubernetes.Although compute targets like local, Azure Machine Learning compute instance, and Azure Machine Learning compute clusters support GPU for training and experimentation, using GPU for inference when deployed as a web service is supported only on Azure Kubernetes Service.

Použití GPU pro odvození při vyhodnocování pomocí kanálu strojového učení je podporované jenom na Azure Machine Learning Compute.Using a GPU for inference when scoring with a machine learning pipeline is supported only on Azure Machine Learning Compute.

Definování konfigurace nasazeníDefine your deployment configuration

Před nasazením modelu je nutné definovat konfiguraci nasazení.Before deploying your model, you must define the deployment configuration. Konfigurace nasazení je specifická pro výpočetní cíl, který bude hostitelem webové služby.The deployment configuration is specific to the compute target that will host the web service. Například při nasazení modelu místně, je nutné zadat port, kde služba přijímá požadavky.For example, when you deploy a model locally, you must specify the port where the service accepts requests. Konfigurace nasazení není součástí vstupního skriptu.The deployment configuration isn't part of your entry script. Používá se k definování charakteristik výpočetního cíle, který bude hostitelem modelu a vstupního skriptu.It's used to define the characteristics of the compute target that will host the model and entry script.

Můžete také potřebovat vytvořit výpočetní prostředek, pokud například nemáte ještě azure kubernetes service (AKS) instance přidružené k vašemu pracovnímu prostoru.You might also need to create the compute resource, if, for example, you don't already have an Azure Kubernetes Service (AKS) instance associated with your workspace.

Následující tabulka obsahuje příklad vytvoření konfigurace nasazení pro každý výpočetní cíl:The following table provides an example of creating a deployment configuration for each compute target:

Cílový výpočetní objektCompute target Příklad konfigurace nasazeníDeployment configuration example
LocalLocal deployment_config = LocalWebservice.deploy_configuration(port=8890)
Azure Container InstancesAzure Container Instances deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)
Azure Kubernetes ServiceAzure Kubernetes Service deployment_config = AksWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)

Třídy pro místní, Azure Container Instances a AKS azureml.core.webservicewebové služby lze importovat z :The classes for local, Azure Container Instances, and AKS web services can be imported from azureml.core.webservice:

from azureml.core.webservice import AciWebservice, AksWebservice, LocalWebservice

Zabezpečení nasazení pomocí TLSSecuring deployments with TLS

Další informace o zabezpečení nasazení webové služby naleznete v tématu Povolení tls a nasazení.For more information on how to secure a web service deployment, see Enable TLS and deploy.

Místní nasazeníLocal deployment

Chcete-li nasadit model místně, musíte mít Docker nainstalován na místním počítači.To deploy a model locally, you need to have Docker installed on your local machine.

Použití sady SDKUsing the SDK

from azureml.core.webservice import LocalWebservice, Webservice

deployment_config = LocalWebservice.deploy_configuration(port=8890)
service = Model.deploy(ws, "myservice", [model], inference_config, deployment_config)
service.wait_for_deployment(show_output = True)
print(service.state)

Další informace naleznete v dokumentaci k LocalWebservice, Model.deploy()a Webservice.For more information, see the documentation for LocalWebservice, Model.deploy(), and Webservice.

Použití cliUsing the CLI

Chcete-li nasadit model pomocí příkazového příkazu, použijte následující příkaz.To deploy a model by using the CLI, use the following command. Nahraďte mymodel:1 se názvem a verzí registrovaného modelu:Replace mymodel:1 with the name and version of the registered model:

az ml model deploy -m mymodel:1 --ic inferenceconfig.json --dc deploymentconfig.json

Položky v deploymentconfig.json dokumentu mapovat na parametry LocalWebservice.deploy_configuration.The entries in the deploymentconfig.json document map to the parameters for LocalWebservice.deploy_configuration. Následující tabulka popisuje mapování mezi entitami v dokumentu JSON a parametry metody:The following table describes the mapping between the entities in the JSON document and the parameters for the method:

Entita JSONJSON entity Parametr metodyMethod parameter PopisDescription
computeType Není k dispoziciNA Cílové výpočetní prostředí.The compute target. Pro místní cíle musí localbýt hodnota .For local targets, the value must be local.
port port Místní port, na kterém chcete vystavit koncový bod HTTP služby.The local port on which to expose the service's HTTP endpoint.

Tento JSON je příklad konfigurace nasazení pro použití s CLI:This JSON is an example deployment configuration for use with the CLI:

{
    "computeType": "local",
    "port": 32267
}

Další informace naleznete v dokumentaci k nasazení modelu az ml.For more information, see the az ml model deploy documentation.

Principy stavu službyUnderstanding service state

Během nasazení modelu se může zobrazit změna stavu služby při jeho plném nasazení.During model deployment, you may see the service state change while it fully deploys.

Následující tabulka popisuje různé stavy služeb:The following table describes the different service states:

Stav webové službyWebservice state PopisDescription Konečný stav?Final state?
PřechodTransitioning Služba je v procesu nasazení.The service is in the process of deployment. NeNo
Není v pořádkuUnhealthy Služba byla nasazena, ale momentálně je nedostupná.The service has deployed but is currently unreachable. NeNo
UnschedulableUnschedulable Službu nelze v tuto chvíli nasadit z důvodu nedostatku prostředků.The service cannot be deployed at this time due to lack of resources. NeNo
FailedFailed Službě se nepodařilo nasadit z důvodu chyby nebo selhání.The service has failed to deploy due to an error or crash. AnoYes
V pořádkuHealthy Služba je v pořádku a koncový bod je k dispozici.The service is healthy and the endpoint is available. AnoYes

Webová služba výpočetní instance (vývoj/test)Compute instance web service (dev/test)

Viz Nasazení modelu do výpočetní instance Azure Machine Learning.See Deploy a model to Azure Machine Learning compute instance.

Instance kontejneru Azure (vývoj a testování)Azure Container Instances (dev/test)

Viz Nasazení do instancí kontejnerů Azure.See Deploy to Azure Container Instances.

Služba Azure Kubernetes (vývoj/testování a výroba)Azure Kubernetes Service (dev/test and production)

Viz Nasazení do služby Azure Kubernetes.See Deploy to Azure Kubernetes Service.

Testování A/B (řízené zavádění)A/B Testing (controlled rollout)

Další informace naleznete v tématu Řízené zavádění modelů ML.See Controlled rollout of ML models for more information.

Využívání webových služebConsume web services

Každá nasazená webová služba poskytuje koncový bod REST, takže můžete vytvářet klientské aplikace v libovolném programovacím jazyce.Every deployed web service provides a REST endpoint, so you can create client applications in any programming language. Pokud jste pro svou službu povolili ověřování pomocí klíče, musíte v hlavičce požadavku zadat klíč služby jako token.If you've enabled key-based authentication for your service, you need to provide a service key as a token in your request header. Pokud jste povolili ověřování na základě tokenu pro vaši službu, musíte poskytnout Azure Machine Learning JSON Web Token (JWT) jako nosný token v záhlaví požadavku.If you've enabled token-based authentication for your service, you need to provide an Azure Machine Learning JSON Web Token (JWT) as a bearer token in your request header.

Hlavní rozdíl je, že klíče jsou statické a mohou být regenerovány ručněa tokeny je třeba aktualizovat po vypršení platnosti.The primary difference is that keys are static and can be regenerated manually, and tokens need to be refreshed upon expiration. Ověřování na klíči je podporované pro Azure Container Instance a Azure Kubernetes Service nasazené webové služby a ověřování založené na tokenech je k dispozici jenom pro nasazení služby Azure Kubernetes Service.Key-based auth is supported for Azure Container Instance and Azure Kubernetes Service deployed web-services, and token-based auth is only available for Azure Kubernetes Service deployments. Další informace a konkrétní ukázky kódu najdete v návodu k ověřování.See the how-to on authentication for more information and specific code samples.

Tip

Po nasazení služby můžete načíst dokument JSON schématu.You can retrieve the schema JSON document after you deploy the service. Pomocí vlastnosti swagger_uri z nasazené webové service.swagger_urislužby (například) získáte identifikátor URI do souboru Swagger místní webové služby.Use the swagger_uri property from the deployed web service (for example, service.swagger_uri) to get the URI to the local web service's Swagger file.

Spotřeba požadavku a odpovědiRequest-response consumption

Tady je příklad, jak vyvolat službu v Pythonu:Here's an example of how to invoke your service in Python:

import requests
import json

headers = {'Content-Type': 'application/json'}

if service.auth_enabled:
    headers['Authorization'] = 'Bearer '+service.get_keys()[0]
elif service.token_auth_enabled:
    headers['Authorization'] = 'Bearer '+service.get_token()[0]

print(headers)

test_sample = json.dumps({'data': [
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
]})

response = requests.post(
    service.scoring_uri, data=test_sample, headers=headers)
print(response.status_code)
print(response.elapsed)
print(response.json())

Další informace naleznete v tématu Vytváření klientských aplikací pro využití webových služeb.For more information, see Create client applications to consume web services.

Schéma webové služby (specifikace OpenAPI)Web service schema (OpenAPI specification)

Pokud jste s nasazením použili automatické generování schématu, můžete získat adresu specifikace OpenAPI pro službu pomocí vlastnosti swagger_uri.If you used automatic schema generation with your deployment, you can get the address of the OpenAPI specification for the service by using the swagger_uri property. (Například print(service.swagger_uri).) K načtení specifikace použijte požadavek GET nebo otevřete identifikátor URI v prohlížeči.(For example, print(service.swagger_uri).) Use a GET request or open the URI in a browser to retrieve the specification.

Následující dokument JSON je příkladem schématu (specifikace OpenAPI) generovaného pro nasazení:The following JSON document is an example of a schema (OpenAPI specification) generated for a deployment:

{
    "swagger": "2.0",
    "info": {
        "title": "myservice",
        "description": "API specification for Azure Machine Learning myservice",
        "version": "1.0"
    },
    "schemes": [
        "https"
    ],
    "consumes": [
        "application/json"
    ],
    "produces": [
        "application/json"
    ],
    "securityDefinitions": {
        "Bearer": {
            "type": "apiKey",
            "name": "Authorization",
            "in": "header",
            "description": "For example: Bearer abc123"
        }
    },
    "paths": {
        "/": {
            "get": {
                "operationId": "ServiceHealthCheck",
                "description": "Simple health check endpoint to ensure the service is up at any given point.",
                "responses": {
                    "200": {
                        "description": "If service is up and running, this response will be returned with the content 'Healthy'",
                        "schema": {
                            "type": "string"
                        },
                        "examples": {
                            "application/json": "Healthy"
                        }
                    },
                    "default": {
                        "description": "The service failed to execute due to an error.",
                        "schema": {
                            "$ref": "#/definitions/ErrorResponse"
                        }
                    }
                }
            }
        },
        "/score": {
            "post": {
                "operationId": "RunMLService",
                "description": "Run web service's model and get the prediction output",
                "security": [
                    {
                        "Bearer": []
                    }
                ],
                "parameters": [
                    {
                        "name": "serviceInputPayload",
                        "in": "body",
                        "description": "The input payload for executing the real-time machine learning service.",
                        "schema": {
                            "$ref": "#/definitions/ServiceInput"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "The service processed the input correctly and provided a result prediction, if applicable.",
                        "schema": {
                            "$ref": "#/definitions/ServiceOutput"
                        }
                    },
                    "default": {
                        "description": "The service failed to execute due to an error.",
                        "schema": {
                            "$ref": "#/definitions/ErrorResponse"
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "ServiceInput": {
            "type": "object",
            "properties": {
                "data": {
                    "type": "array",
                    "items": {
                        "type": "array",
                        "items": {
                            "type": "integer",
                            "format": "int64"
                        }
                    }
                }
            },
            "example": {
                "data": [
                    [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
                ]
            }
        },
        "ServiceOutput": {
            "type": "array",
            "items": {
                "type": "number",
                "format": "double"
            },
            "example": [
                3726.995
            ]
        },
        "ErrorResponse": {
            "type": "object",
            "properties": {
                "status_code": {
                    "type": "integer",
                    "format": "int32"
                },
                "message": {
                    "type": "string"
                }
            }
        }
    }
}

Další informace naleznete v tématu OpenAPI specifikace.For more information, see OpenAPI specification.

Nástroj, který můžete vytvořit klientské knihovny ze specifikace, naleznete v tématu swagger-codegen.For a utility that can create client libraries from the specification, see swagger-codegen.

Odvození dávkyBatch inference

Cíle Azure Machine Learning Compute jsou vytvořené a spravované azure machine learningem.Azure Machine Learning Compute targets are created and managed by Azure Machine Learning. Můžou se použít pro predikci dávek z kanálů Azure Machine Learning.They can be used for batch prediction from Azure Machine Learning pipelines.

Návod dávkového odvození pomocí Azure Machine Learning Compute najdete v tématu Jak spustit predikce dávek.For a walkthrough of batch inference with Azure Machine Learning Compute, see How to run batch predictions.

Odvození od IoT okrajeIoT Edge inference

Podpora pro nasazení k okraji je ve verzi Preview.Support for deploying to the edge is in preview. Další informace najdete v tématu Nasazení Azure Machine Learning jako modul IoT Edge.For more information, see Deploy Azure Machine Learning as an IoT Edge module.

Aktualizace webových služebUpdate web services

Chcete-li aktualizovat webovou update službu, použijte metodu.To update a web service, use the update method. Můžete aktualizovat webovou službu tak, aby používala nový model, nový vstupní skript nebo nové závislosti, které lze zadat v konfiguraci odvození.You can update the web service to use a new model, a new entry script, or new dependencies that can be specified in an inference configuration. Další informace naleznete v dokumentaci k webu Webservice.update.For more information, see the documentation for Webservice.update.

Důležité

Při vytváření nové verze modelu je nutné ručně aktualizovat každou službu, kterou chcete použít.When you create a new version of a model, you must manually update each service that you want to use it.

Sadu SDK nelze použít k aktualizaci webové služby publikované z návrháře Azure Machine Learning.You can not use the SDK to update a web service published from the Azure Machine Learning designer.

Použití sady SDKUsing the SDK

Následující kód ukazuje, jak pomocí sady SDK aktualizovat model, prostředí a vstupní skript pro webovou službu:The following code shows how to use the SDK to update the model, environment, and entry script for a web service:

from azureml.core import Environment
from azureml.core.webservice import Webservice
from azureml.core.model import Model, InferenceConfig

# Register new model.
new_model = Model.register(model_path="outputs/sklearn_mnist_model.pkl",
                           model_name="sklearn_mnist",
                           tags={"key": "0.1"},
                           description="test",
                           workspace=ws)

# Use version 3 of the environment.
deploy_env = Environment.get(workspace=ws,name="myenv",version="3")
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=deploy_env)

service_name = 'myservice'
# Retrieve existing service.
service = Webservice(name=service_name, workspace=ws)



# Update to new model(s).
service.update(models=[new_model], inference_config=inference_config)
print(service.state)
print(service.get_logs())

Použití cliUsing the CLI

Můžete také aktualizovat webovou službu pomocí cli ML.You can also update a web service by using the ML CLI. Následující příklad ukazuje registraci nového modelu a aktualizaci webové služby tak, aby používala nový model:The following example demonstrates registering a new model and then updating a web service to use the new model:

az ml model register -n sklearn_mnist  --asset-path outputs/sklearn_mnist_model.pkl  --experiment-name myexperiment --output-metadata-file modelinfo.json
az ml service update -n myservice --model-metadata-file modelinfo.json

Tip

V tomto příkladu se dokument JSON používá k předání informací o modelu z příkazu registrace do příkazu update.In this example, a JSON document is used to pass the model information from the registration command into the update command.

Chcete-li službu aktualizovat tak, aby používala nový vstupní skript nebo ic prostředí, vytvořte konfigurační soubor odvození a zadejte jej pomocí parametru.To update the service to use a new entry script or environment, create an inference configuration file and specify it with the ic parameter.

Další informace naleznete v dokumentaci k aktualizaci služby az ml.For more information, see the az ml service update documentation.

Průběžné nasazování modelůContinuously deploy models

Modely můžete průběžně nasazovat pomocí rozšíření Machine Learning pro Azure DevOps.You can continuously deploy models by using the Machine Learning extension for Azure DevOps. Rozšíření Machine Learning pro Azure DevOps můžete použít k aktivaci kanálu nasazení, když se v pracovním prostoru Azure Machine Learning zaregistruje nový model strojového učení.You can use the Machine Learning extension for Azure DevOps to trigger a deployment pipeline when a new machine learning model is registered in an Azure Machine Learning workspace.

  1. Zaregistrujte se k Azure Pipelines, což umožňuje průběžnou integraci a doručování vaší aplikace na libovolnou platformu nebo cloud.Sign up for Azure Pipelines, which makes continuous integration and delivery of your application to any platform or cloud possible. (Všimněte si, že Azure kanály není stejný jako kanály Machine Learning.)(Note that Azure Pipelines isn't the same as Machine Learning pipelines.)

  2. Vytvořte projekt Azure DevOps.Create an Azure DevOps project.

  3. Nainstalujte rozšíření Machine Learning pro Azure Pipelines.Install the Machine Learning extension for Azure Pipelines.

  4. Pomocí připojení služeb nastavte připojení k primárnímu servisnímu objektu k pracovnímu prostoru Azure Machine Learning, abyste měli přístup k artefaktům.Use service connections to set up a service principal connection to your Azure Machine Learning workspace so you can access your artifacts. Přejděte na nastavení projektu, vyberte Připojení servisua pak vyberte Správce prostředků Azure:Go to project settings, select Service connections, and then select Azure Resource Manager:

    Vyberte Správce prostředků AzureSelect Azure Resource Manager

  5. V seznamu Úroveň oboru vyberte AzureMLWorkspacea zadejte zbývající hodnoty:In the Scope level list, select AzureMLWorkspace, and then enter the rest of the values:

    Vybrat AzureMLWorkspace

  6. Chcete-li průběžně nasazovat model strojového učení pomocí Azure Pipelines, v části kanály vyberte vydání.To continuously deploy your machine learning model by using Azure Pipelines, under pipelines, select release. Přidejte nový artefakt a vyberte artefakt modelu AzureML a připojení služby, které jste vytvořili dříve.Add a new artifact, and then select the AzureML Model artifact and the service connection that you created earlier. Vyberte model a verzi pro aktivaci nasazení:Select the model and version to trigger a deployment:

    Výběr modelu AzureMLSelect AzureML Model

  7. Povolte aktivační událost modelu na artefaktu modelu.Enable the model trigger on your model artifact. Když zapnete aktivační událost, pokaždé, když zadaná verze (to znamená nejnovější verze) tohoto modelu je registrována ve vašem pracovním prostoru, azure devops verze kanálu se aktivuje.When you turn on the trigger, every time the specified version (that is, the newest version) of that model is registered in your workspace, an Azure DevOps release pipeline is triggered.

    Povolení aktivační události modeluEnable the model trigger

Další ukázkové projekty a příklady najdete v těchto ukázkových úložištích na GitHubu:For more sample projects and examples, see these sample repos in GitHub:

Stažení modeluDownload a model

Pokud chcete stáhnout model a použít jej ve vlastním prostředí spuštění, můžete tak učinit pomocí následujících příkazů sady SDK / CLI:If you want to download your model to use it in your own execution environment, you can do so with the following SDK / CLI commands:

Sdk:SDK:

model_path = Model(ws,'mymodel').download()

Cli:CLI:

az ml model download --model-id mymodel:1 --target-dir model_folder

(Náhled) Nasazení modelu bez kódu(Preview) No-code model deployment

Nasazení modelu bez kódu je aktuálně ve verzi preview a podporuje následující architektury strojového učení:No-code model deployment is currently in preview and supports the following machine learning frameworks:

Formát Tentenzifukového uloženého modeluTensorflow SavedModel format

Tensorflow modely musí být registrovány ve formátu SavedModel pro práci s nasazením modelu bez kódu.Tensorflow models need to be registered in SavedModel format to work with no-code model deployment.

Naleznete v tomto odkazu informace o tom, jak vytvořit SavedModel.Please see this link for information on how to create a SavedModel.

from azureml.core import Model

model = Model.register(workspace=ws,
                       model_name='flowers',                        # Name of the registered model in your workspace.
                       model_path='./flowers_model',                # Local Tensorflow SavedModel folder to upload and register as a model.
                       model_framework=Model.Framework.TENSORFLOW,  # Framework used to create the model.
                       model_framework_version='1.14.0',            # Version of Tensorflow used to create the model.
                       description='Flowers model')

service_name = 'tensorflow-flower-service'
service = Model.deploy(ws, service_name, [model])

Modely ONNXONNX models

Registrace a nasazení modelu ONNX je podporována pro jakýkoli odvozený graf ONNX.ONNX model registration and deployment is supported for any ONNX inference graph. Kroky předběžného zpracování a následného zpracování nejsou aktuálně podporovány.Preprocess and postprocess steps are not currently supported.

Zde je příklad, jak zaregistrovat a nasadit model MNIST ONNX:Here is an example of how to register and deploy an MNIST ONNX model:

from azureml.core import Model

model = Model.register(workspace=ws,
                       model_name='mnist-sample',                  # Name of the registered model in your workspace.
                       model_path='mnist-model.onnx',              # Local ONNX model to upload and register as a model.
                       model_framework=Model.Framework.ONNX ,      # Framework used to create the model.
                       model_framework_version='1.3',              # Version of ONNX used to create the model.
                       description='Onnx MNIST model')

service_name = 'onnx-mnist-service'
service = Model.deploy(ws, service_name, [model])

Pokud používáte Pytorch, export modelů z PyTorch do ONNX má podrobnosti o konverzi a omezení.If you're using Pytorch, Exporting models from PyTorch to ONNX has the details on conversion and limitations.

Scikit-učit modelyScikit-learn models

Pro všechny předdefinované typy modelů scikit-learn není podporováno žádné nasazení modelu kódu.No code model deployment is supported for all built-in scikit-learn model types.

Zde je příklad, jak zaregistrovat a nasadit model sklearn bez dalšího kódu:Here is an example of how to register and deploy a sklearn model with no extra code:

from azureml.core import Model
from azureml.core.resource_configuration import ResourceConfiguration

model = Model.register(workspace=ws,
                       model_name='my-sklearn-model',                # Name of the registered model in your workspace.
                       model_path='./sklearn_regression_model.pkl',  # Local file to upload and register as a model.
                       model_framework=Model.Framework.SCIKITLEARN,  # Framework used to create the model.
                       model_framework_version='0.19.1',             # Version of scikit-learn used to create the model.
                       resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5),
                       description='Ridge regression model to predict diabetes progression.',
                       tags={'area': 'diabetes', 'type': 'regression'})
                       
service_name = 'my-sklearn-service'
service = Model.deploy(ws, service_name, [model])

Poznámka: Modely, které podporují predict_proba bude používat tuto metodu ve výchozím nastavení.NOTE: Models which support predict_proba will use that method by default. Chcete-li přepsat toto použití předpovědět můžete upravit tělo POST, jak je uvedeno níže:To override this to use predict you can modify the POST body as below:

import json


input_payload = json.dumps({
    'data': [
        [ 0.03807591,  0.05068012,  0.06169621, 0.02187235, -0.0442235,
         -0.03482076, -0.04340085, -0.00259226, 0.01990842, -0.01764613]
    ],
    'method': 'predict'  # If you have a classification model, the default behavior is to run 'predict_proba'.
})

output = service.run(input_payload)

print(output)

Poznámka: Tyto závislosti jsou zahrnuty v předem sestavené sklearn odvození kontejneru:NOTE: These dependencies are included in the prebuilt sklearn inference container:

    - azureml-defaults
    - inference-schema[numpy-support]
    - scikit-learn
    - numpy

Modely balíčkůPackage models

V některých případech můžete chtít vytvořit image Dockeru bez nasazení modelu (pokud například plánujete nasazení do služby Azure App Service).In some cases, you might want to create a Docker image without deploying the model (if, for example, you plan to deploy to Azure App Service). Nebo můžete chtít stáhnout bitovou kopii a spustit ji v místní instalaci Dockeru.Or you might want to download the image and run it on a local Docker installation. Můžete dokonce chtít stáhnout soubory použité k vytvoření bitové kopie, zkontrolovat je, upravit je a vytvořit bitovou kopii ručně.You might even want to download the files used to build the image, inspect them, modify them, and build the image manually.

Model balení vám umožní dělat tyto věci.Model packaging enables you to do these things. Sbalí všechny prostředky potřebné k hostování modelu jako webové služby a umožňuje stáhnout si buď plně sestavenou bitovou kopii Dockeru, nebo soubory potřebné k jeho vytvoření.It packages all the assets needed to host a model as a web service and allows you to download either a fully built Docker image or the files needed to build one. Modelové balení lze použít dvěma způsoby:There are two ways to use model packaging:

Stáhněte si zabalený model: Stáhněte si bitovou kopii Dockeru, která obsahuje model a další soubory potřebné k hostování jako webová služba.Download a packaged model: Download a Docker image that contains the model and other files needed to host it as a web service.

Generovat soubor Dockerfile: Stáhněte si dockerfile, model, vstupní skript a další datové zdroje potřebné k vytvoření image Dockeru.Generate a Dockerfile: Download the Dockerfile, model, entry script, and other assets needed to build a Docker image. Potom můžete zkontrolovat soubory nebo provést změny před sestavením bitové kopie místně.You can then inspect the files or make changes before you build the image locally.

Oba balíčky lze získat místní image Dockeru.Both packages can be used to get a local Docker image.

Tip

Vytvoření balíčku je podobné nasazení modelu.Creating a package is similar to deploying a model. Používáte registrovaný model a konfiguraci odvození.You use a registered model and an inference configuration.

Důležité

Chcete-li stáhnout plně vytvořenou bitovou kopii nebo vytvořit bitovou kopii místně, musíte mít Docker nainstalovaný ve vývojovém prostředí.To download a fully built image or build an image locally, you need to have Docker installed in your development environment.

Stažení baleného modeluDownload a packaged model

Následující příklad vytvoří bitovou kopii, která je registrovaná v registru kontejnerů Azure pro váš pracovní prostor:The following example builds an image, which is registered in the Azure container registry for your workspace:

package = Model.package(ws, [model], inference_config)
package.wait_for_creation(show_output=True)

Po vytvoření balíčku můžete použít package.pull() k vyžádat image do místního prostředí Dockeru.After you create a package, you can use package.pull() to pull the image to your local Docker environment. Na výstupu tohoto příkazu se zobrazí název obrázku.The output of this command will display the name of the image. Například:For example:

Status: Downloaded newer image for myworkspacef78fd10.azurecr.io/package:20190822181338.Status: Downloaded newer image for myworkspacef78fd10.azurecr.io/package:20190822181338.

Po stažení modelu použijte docker images příkaz pro seznam místních obrázků:After you download the model, use the docker images command to list the local images:

REPOSITORY                               TAG                 IMAGE ID            CREATED             SIZE
myworkspacef78fd10.azurecr.io/package    20190822181338      7ff48015d5bd        4 minutes ago       1.43 GB

Chcete-li spustit místní kontejner založený na této bitové kopii, použijte následující příkaz ke spuštění pojmenovaného kontejneru z prostředí nebo příkazového řádku.To start a local container based on this image, use the following command to start a named container from the shell or command line. Nahraďte hodnotu <imageid> ID obrázku vráceným příkazem. docker imagesReplace the <imageid> value with the image ID returned by the docker images command.

docker run -p 6789:5001 --name mycontainer <imageid>

Tento příkaz spustí nejnovější verzi myimageobrázku s názvem .This command starts the latest version of the image named myimage. Mapuje místní port 6789 do portu v kontejneru, na kterém webová služba naslouchá (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Také přiřadí název mycontainer kontejneru, což usnadňuje zastavení kontejneru.It also assigns the name mycontainer to the container, which makes the container easier to stop. Po spuštění kontejneru můžete odeslat http://localhost:6789/scorežádosti společnosti .After the container is started, you can submit requests to http://localhost:6789/score.

Generování souboru Dockerfile a závislostíGenerate a Dockerfile and dependencies

Následující příklad ukazuje, jak stáhnout Dockerfile, model a další prostředky potřebné k vytvoření image místně.The following example shows how to download the Dockerfile, model, and other assets needed to build an image locally. Parametr generate_dockerfile=True označuje, že chcete soubory, nikoli plně sestavenou bitovou kopii.The generate_dockerfile=True parameter indicates that you want the files, not a fully built image.

package = Model.package(ws, [model], inference_config, generate_dockerfile=True)
package.wait_for_creation(show_output=True)
# Download the package.
package.save("./imagefiles")
# Get the Azure container registry that the model/Dockerfile uses.
acr=package.get_container_registry()
print("Address:", acr.address)
print("Username:", acr.username)
print("Password:", acr.password)

Tento kód stáhne soubory potřebné k imagefiles vytvoření bitové kopie do adresáře.This code downloads the files needed to build the image to the imagefiles directory. Dockerfile zahrnuty v uložených souborů odkazuje na základní image uložené v registru kontejneru Azure.The Dockerfile included in the saved files references a base image stored in an Azure container registry. Při vytváření bitové kopie v místní instalaci Dockeru je třeba k ověření v registru použít adresu, uživatelské jméno a heslo.When you build the image on your local Docker installation, you need to use the address, user name, and password to authenticate to the registry. Pomocí následujících kroků vytvořte bitovou kopii pomocí místní instalace Dockeru:Use the following steps to build the image by using a local Docker installation:

  1. Z relace prostředí nebo příkazového řádku použijte následující příkaz k ověření Dockeru pomocí registru kontejnerů Azure.From a shell or command-line session, use the following command to authenticate Docker with the Azure container registry. Nahraďte <address>, <username>a <password> s package.get_container_registry()hodnotami načtenými .Replace <address>, <username>, and <password> with the values retrieved by package.get_container_registry().

    docker login <address> -u <username> -p <password>
    
  2. Chcete-li vytvořit bitovou kopii, použijte následující příkaz.To build the image, use the following command. Nahraďte <imagefiles> cestou k package.save() adresáři, do kterého byly uloženy soubory.Replace <imagefiles> with the path of the directory where package.save() saved the files.

    docker build --tag myimage <imagefiles>
    

    Tento příkaz nastaví myimagenázev obrázku na .This command sets the image name to myimage.

Chcete-li ověřit, zda je docker images obraz vytvořen, použijte příkaz.To verify that the image is built, use the docker images command. Měli byste myimage vidět obrázek v seznamu:You should see the myimage image in the list:

REPOSITORY      TAG                 IMAGE ID            CREATED             SIZE
<none>          <none>              2d5ee0bf3b3b        49 seconds ago      1.43 GB
myimage         latest              739f22498d64        3 minutes ago       1.43 GB

Chcete-li spustit nový kontejner založený na této bitové kopii, použijte následující příkaz:To start a new container based on this image, use the following command:

docker run -p 6789:5001 --name mycontainer myimage:latest

Tento příkaz spustí nejnovější verzi myimageobrázku s názvem .This command starts the latest version of the image named myimage. Mapuje místní port 6789 do portu v kontejneru, na kterém webová služba naslouchá (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Také přiřadí název mycontainer kontejneru, což usnadňuje zastavení kontejneru.It also assigns the name mycontainer to the container, which makes the container easier to stop. Po spuštění kontejneru můžete odeslat http://localhost:6789/scorežádosti společnosti .After the container is started, you can submit requests to http://localhost:6789/score.

Příklad klienta pro testování místního kontejneruExample client to test the local container

Následující kód je příkladem klienta Pythonu, který lze použít s kontejnerem:The following code is an example of a Python client that can be used with the container:

import requests
import json

# URL for the web service.
scoring_uri = 'http://localhost:6789/score'

# Two sets of data to score, so we get two results back.
data = {"data":
        [
            [ 1,2,3,4,5,6,7,8,9,10 ],
            [ 10,9,8,7,6,5,4,3,2,1 ]
        ]
        }
# Convert to JSON string.
input_data = json.dumps(data)

# Set the content type.
headers = {'Content-Type': 'application/json'}

# Make the request and display the response.
resp = requests.post(scoring_uri, input_data, headers=headers)
print(resp.text)

Například klienti v jiných programovacích jazycích, naleznete v tématu využívat modely nasazené jako webové služby.For example clients in other programming languages, see Consume models deployed as web services.

Zastavení kontejneru DockeruStop the Docker container

Chcete-li kontejner zastavit, použijte následující příkaz z jiného prostředí nebo příkazového řádku:To stop the container, use the following command from a different shell or command line:

docker kill mycontainer

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

Chcete-li odstranit nasazenou service.delete()webovou službu, použijte .To delete a deployed web service, use service.delete(). Chcete-li odstranit registrovaný model.delete()model, použijte .To delete a registered model, use model.delete().

Další informace naleznete v dokumentaci k webservice.delete() a Model.delete().For more information, see the documentation for WebService.delete() and Model.delete().

Vytváření rozšířeného vstupního skriptuAdvanced entry script authoring

Binární dataBinary data

Pokud váš model přijímá binární data, jako je score.py bitová kopie, je nutné upravit soubor použitý pro vaše nasazení přijímat nezpracované požadavky HTTP.If your model accepts binary data, like an image, you must modify the score.py file used for your deployment to accept raw HTTP requests. Chcete-li přijmout nezpracovaná data, použijte třídu AMLRequest v vstupním skriptu @rawhttp a přidejte decorator do run() funkce.To accept raw data, use the AMLRequest class in your entry script and add the @rawhttp decorator to the run() function.

Zde je score.py příklad, který přijímá binární data:Here's an example of a score.py that accepts binary data:

from azureml.contrib.services.aml_request import AMLRequest, rawhttp
from azureml.contrib.services.aml_response import AMLResponse


def init():
    print("This is init()")


@rawhttp
def run(request):
    print("This is run()")
    print("Request: [{0}]".format(request))
    if request.method == 'GET':
        # For this example, just return the URL for GETs.
        respBody = str.encode(request.full_path)
        return AMLResponse(respBody, 200)
    elif request.method == 'POST':
        reqBody = request.get_data(False)
        # For a real-world solution, you would load the data from reqBody
        # and send it to the model. Then return the response.

        # For demonstration purposes, this example just returns the posted data as the response.
        return AMLResponse(reqBody, 200)
    else:
        return AMLResponse("bad request", 500)

Důležité

Třída AMLRequest je v azureml.contrib oboru názvů.The AMLRequest class is in the azureml.contrib namespace. Entity v tomto oboru názvů se často mění, když pracujeme na zlepšení služby.Entities in this namespace change frequently as we work to improve the service. Cokoli v tomto oboru názvů by mělo být považováno za náhled, který není plně podporován společností Microsoft.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Pokud potřebujete otestovat v místním vývojovém prostředí, můžete nainstalovat součásti pomocí následujícího příkazu:If you need to test this in your local development environment, you can install the components by using the following command:

pip install azureml-contrib-services

Sdílení zdrojů mezi zdroji (CORS)Cross-origin resource sharing (CORS)

Sdílení prostředků mezi zdroji je způsob, jak povolit prostředky na webové stránce, které mají být požadovány z jiné domény.Cross-origin resource sharing is a way to allow resources on a webpage to be requested from another domain. CORS funguje přes hlavičky HTTP odeslané s požadavkem klienta a vrácené s odpovědí služby.CORS works via HTTP headers sent with the client request and returned with the service response. Další informace o CORS a platných záhlavích najdete v tématu Sdílení prostředků mezi zdroji ve Wikipedii.For more information on CORS and valid headers, see Cross-origin resource sharing in Wikipedia.

Chcete-li nakonfigurovat nasazení modelu pro AMLResponse podporu CORS, použijte třídu v vstupním skriptu.To configure your model deployment to support CORS, use the AMLResponse class in your entry script. Tato třída umožňuje nastavit záhlaví na objekt odpovědi.This class allows you to set the headers on the response object.

Následující příklad nastaví Access-Control-Allow-Origin záhlaví odpovědi ze vstupního skriptu:The following example sets the Access-Control-Allow-Origin header for the response from the entry script:

from azureml.contrib.services.aml_response import AMLResponse

def init():
    print("This is init()")

def run(request):
    print("This is run()")
    print("Request: [{0}]".format(request))
    if request.method == 'GET':
        # For this example, just return the URL for GETs.
        respBody = str.encode(request.full_path)
        return AMLResponse(respBody, 200)
    elif request.method == 'POST':
        reqBody = request.get_data(False)
        # For a real-world solution, you would load the data from reqBody
        # and send it to the model. Then return the response.

        # For demonstration purposes, this example
        # adds a header and returns the request body.
        resp = AMLResponse(reqBody, 200)
        resp.headers['Access-Control-Allow-Origin'] = "http://www.example.com"
        return resp
    else:
        return AMLResponse("bad request", 500)

Důležité

Třída AMLResponse je v azureml.contrib oboru názvů.The AMLResponse class is in the azureml.contrib namespace. Entity v tomto oboru názvů se často mění, když pracujeme na zlepšení služby.Entities in this namespace change frequently as we work to improve the service. Cokoli v tomto oboru názvů by mělo být považováno za náhled, který není plně podporován společností Microsoft.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Pokud potřebujete otestovat v místním vývojovém prostředí, můžete nainstalovat součásti pomocí následujícího příkazu:If you need to test this in your local development environment, you can install the components by using the following command:

pip install azureml-contrib-services

Upozornění

Azure Machine Learning bude směrovat pouze požadavky POST a GET do kontejnerů, které spouštějí službu vyhodnocování.Azure Machine Learning will route only POST and GET requests to the containers running the scoring service. To může způsobit chyby způsobené prohlížečů pomocí požadavků možnosti před-letu CORS požadavky.This can cause errors due to browsers using OPTIONS requests to pre-flight CORS requests.

Další krokyNext steps