Modellek üzembe helyezése az Azure Machine LearninggelDeploy models with Azure Machine Learning

a következőkre vonatkozik:  igen , alapszintű kiadás  , igen Enterprise Edition                               (frissítés az Enterprise Editionrendszerre) APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Megtudhatja, hogyan helyezheti üzembe a gépi tanulási modellt webszolgáltatásként az Azure-felhőben, vagy Azure IoT Edge eszközöket.Learn how to deploy your machine learning model as a web service in the Azure cloud or to Azure IoT Edge devices.

A munkafolyamat a modell üzembe helyezésének helyétől függetlenül is hasonló:The workflow is similar no matter where you deploy your model:

  1. Regisztrálja a modellt.Register the model.
  2. Felkészülés a telepítésre.Prepare to deploy. (Az eszközök, a használat, a számítási cél meghatározása.)(Specify assets, usage, compute target.)
  3. A modell üzembe helyezése a számítási célra.Deploy the model to the compute target.
  4. Tesztelje az üzembe helyezett modellt, más néven webszolgáltatást.Test the deployed model, also called a web service.

Az üzembe helyezési munkafolyamatban részt vevő fogalmakkal kapcsolatos további információkért lásd: modellek kezelése, üzembe helyezése és figyelése Azure Machine Learningokkal.For more information on the concepts involved in the deployment workflow, see Manage, deploy, and monitor models with Azure Machine Learning.

ElőfeltételekPrerequisites

Csatlakozás a munkaterülethezConnect to your workspace

A következő kód bemutatja, hogyan csatlakozhat egy Azure Machine Learning munkaterülethez a helyi fejlesztési környezetbe gyorsítótárazott információk használatával:The following code shows how to connect to an Azure Machine Learning workspace by using information cached to the local development environment:

  • Az SDK használataUsing the SDK

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

    Az SDK munkaterülethez való kapcsolódásával kapcsolatos további információkért tekintse meg a Pythonhoz készült Azure Machine learning SDK dokumentációját.For more information on using the SDK to connect to a workspace, see the Azure Machine Learning SDK for Python documentation.

  • A parancssori felület használataUsing the CLI

    A parancssori felület használatakor a -w vagy --workspace-name a paraméterrel adhatja meg a parancs munkaterületét.When using the CLI, use the -w or --workspace-name parameter to specify the workspace for the command.

  • A Visual Studio Code használataUsing Visual Studio Code

    A Visual Studio Code használatakor a munkaterületet grafikus felületen kell kiválasztania.When you use Visual Studio Code, you select the workspace by using a graphical interface. További információ: modellek üzembe helyezése és kezelése a Visual Studio Code bővítmény dokumentációjában.For more information, see Deploy and manage models in the Visual Studio Code extension documentation.

A modell regisztrálásaRegister your model

A regisztrált modell a modellt alkotó egy vagy több fájl logikai tárolója.A registered model is a logical container for one or more files that make up your model. Ha például több fájlban tárolt modell van, akkor egyetlen modellként regisztrálhatja őket a munkaterületen.For example, if you have a model that's stored in multiple files, you can register them as a single model in the workspace. A fájlok regisztrálása után letöltheti vagy telepítheti a regisztrált modellt, és megkapja az összes regisztrált fájlt.After you register the files, you can then download or deploy the registered model and receive all the files that you registered.

Tipp

Modell regisztrálása esetén megadja a Felhőbeli hely (betanítási Futtatás) vagy egy helyi könyvtár elérési útját.When you register a model, you provide the path of either a cloud location (from a training run) or a local directory. Ez az elérési út csak a feltöltéshez szükséges fájlok megkeresése a regisztrációs folyamat részeként.This path is just to locate the files for upload as part of the registration process. Nem kell megegyeznie a bejegyzési parancsfájlban használt elérési úttal.It doesn't need to match the path used in the entry script. További információ: a modell fájljainak megkeresése a belépési parancsfájlban.For more information, see Locate model files in your entry script.

A gépi tanulási modellek regisztrálva vannak a Azure Machine Learning munkaterületen.Machine learning models are registered in your Azure Machine Learning workspace. A modell Azure Machine Learning vagy máshonnan is származhat.The model can come from Azure Machine Learning or from somewhere else. Modell regisztrálása esetén a modellre vonatkozó metaadatokat is megadhat.When registering a model, you can optionally provide metadata about the model. A tags modell properties -regisztrációra alkalmazott és a szótárak használatával szűrheti a modelleket.The tags and properties dictionaries that you apply to a model registration can then be used to filter models.

Az alábbi példák bemutatják, hogyan regisztrálhat egy modellt.The following examples demonstrate how to register a model.

Modell regisztrálása kísérlet futtatásávalRegister a model from an experiment run

Az ebben a szakaszban szereplő kódrészletek bemutatják, hogyan regisztrálhat egy modellt egy képzési futtatásból:The code snippets in this section demonstrate how to register a model from a training run:

Fontos

A kódrészletek használatához előzőleg be kell állítania egy tanítási futtatást, és hozzá kell férnie az Run objektumhoz (SDK-példa) vagy a futtatási azonosító értékéhez (CLI-példa).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). A modellek betanításával kapcsolatos további információkért lásd: számítási célok beállítása a modell betanításához.For more information on training models, see Set up compute targets for model training.

  • Az SDK használataUsing the SDK

    Ha az SDK-t használja a modell betanításához, akkor a modell kiképzésének módjától függően futtathat egy futtatási objektumot vagy egy AutoMLRun -objektumot.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. Minden objektum használható a kísérlet futtatásával létrehozott modellek regisztrálására.Each object can be used to register a model created by an experiment run.

    • Modell regisztrálása egy azureml.core.Run objektumból: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')
      

      A model_path paraméter a modell Felhőbeli helyét jelöli.The model_path parameter refers to the cloud location of the model. Ebben a példában egyetlen fájl elérési útját használjuk.In this example, the path of a single file is used. Ha több fájlt szeretne szerepeltetni a modell regisztrációjában model_path , állítsa a fájlokat tartalmazó mappa elérési útjára.To include multiple files in the model registration, set model_path to the path of a folder that contains the files. További információ: Run. register_model dokumentáció.For more information, see the Run.register_model documentation.

    • Modell regisztrálása egy azureml.train.automl.run.AutoMLRun objektumból: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)
      

      Ebben a példában a metric és iteration a paraméterek nincsenek megadva, ezért a rendszer a legjobb elsődleges metrikával rendelkező iterációt regisztrálja.In this example, the metric and iteration parameters aren't specified, so the iteration with the best primary metric will be registered. A model_id rendszer a futtatásból visszaadott értéket használja a modell neve helyett.The model_id value returned from the run is used instead of a model name.

      További információ: AutoMLRun. register_model dokumentáció.For more information, see the AutoMLRun.register_model documentation.

  • A parancssori felület használataUsing 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
    

    Tipp

    Ha hibaüzenet jelenik meg arról, hogy az ml-bővítmény nincs telepítve, a következő paranccsal telepítheti: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
    

    A --asset-path paraméter a modell Felhőbeli helyét jelöli.The --asset-path parameter refers to the cloud location of the model. Ebben a példában egyetlen fájl elérési útját használjuk.In this example, the path of a single file is used. Ha több fájlt szeretne szerepeltetni a modell regisztrációjában --asset-path , állítsa a fájlokat tartalmazó mappa elérési útjára.To include multiple files in the model registration, set --asset-path to the path of a folder that contains the files.

  • A Visual Studio Code használataUsing Visual Studio Code

    A Visual Studio Code bővítmény használatával bármilyen modell-fájl vagy mappa használatával regisztrálhat modelleket.Register models using any model files or folders by using the Visual Studio Code extension.

Modell regisztrálása helyi fájlbólRegister a model from a local file

A modell helyi elérési útjának megadásával regisztrálhat egy modellt.You can register a model by providing the local path of the model. Megadhatja egy mappa vagy egy fájl elérési útját.You can provide the path of either a folder or a single file. Ezzel a módszerrel regisztrálhatja Azure Machine Learning, majd letöltheti a betanított modelleket.You can use this method to register models trained with Azure Machine Learning and then downloaded. Ezt a módszert használhatja a Azure Machine Learningon kívül betanított modellek regisztrálására is.You can also use this method to register models trained outside of Azure Machine Learning.

Fontos

Csak olyan modelleket használjon, amelyeket megbízható forrásból hoz létre vagy szerez be.You should use only models that you create or obtain from a trusted source. A szerializált modelleket kódként kell kezelni, mivel a biztonsági réseket számos népszerű formátumban észlelték.You should treat serialized models as code, because security vulnerabilities have been discovered in a number of popular formats. Emellett a modelleket szándékosan, rosszindulatú szándékkal lehet kitanítani, hogy torzítatlan vagy pontatlan kimenetet szolgáltasson.Also, models might be intentionally trained with malicious intent to provide biased or inaccurate output.

  • Az SDK és a ONNX használataUsing 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",)
    

    Ha több fájlt szeretne szerepeltetni a modell regisztrációjában model_path , állítsa a fájlokat tartalmazó mappa elérési útjára.To include multiple files in the model registration, set model_path to the path of a folder that contains the files.

  • A parancssori felület használataUsing the CLI

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

    Ha több fájlt szeretne szerepeltetni a modell regisztrációjában -p , állítsa a fájlokat tartalmazó mappa elérési útjára.To include multiple files in the model registration, set -p to the path of a folder that contains the files.

Becsült idő: körülbelül 10 másodperc.Time estimate: Approximately 10 seconds.

További információkért tekintse meg a modell osztálydokumentációját.For more information, see the documentation for the Model class.

A Azure Machine Learningon kívül betanított modellek használatáról a következő témakörben talál további információt: meglévő modell üzembe helyezése.For more information on working with models trained outside Azure Machine Learning, see How to deploy an existing model.

Egy-és többmodelles végpontokSingle versus multi-model endpoints

Az Azure ML egyetlen végpont mögött egyetlen vagy több modell üzembe helyezését támogatja.Azure ML supports deploying single or multiple models behind a single endpoint.

A többmodelles végpontok egy megosztott tárolót használnak több modell üzemeltetéséhez.Multi-model endpoints use a shared container to host multiple models. Ez segít csökkenteni a költségeket, javítja a kihasználtságot, és lehetővé teszi, hogy a modulok összevonásával együtt egyesítse a modulokat.This helps to reduce overhead costs, improves utilization, and enables you to chain modules together into ensembles. Az üzembe helyezési parancsfájlban megadott modellek csatlakoztatása és elérhetővé tétele a kiszolgáló tároló lemezén történik – az igény szerinti memóriába betöltheti őket, a pontszám pedig a pontozási időpontban kért adott modell alapján.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.

Egy E2E példa, amely bemutatja, hogyan használható több modell egyetlen tárolós végpont mögött, lásd a következő példát :For an E2E example, which shows how to use multiple models behind a single containerized endpoint, see this example

Az üzembe helyezés előkészítésePrepare to deploy

A modell szolgáltatásként való üzembe helyezéséhez a következő összetevőkre van szükség:To deploy the model as a service, you need the following components:

  • Következtetési környezet definiálása.Define inference environment. Ez a környezet beágyazza a modellnek a következtetéshez való futtatásához szükséges függőségeket.This environment encapsulates the dependencies required to run your model for inference.
  • Pontozási kód definiálása.Define scoring code. Ez a szkript fogadja a kéréseket, a modell használatával szerzi be a kérelmeket, és visszaadja az eredményeket.This script accepts requests, scores the requests by using the model, and returns the results.
  • Adja meg a következtetési konfigurációt.Define inference configuration. A következtetési konfiguráció meghatározza a környezet konfigurációját, a belépési parancsfájlt és a modell szolgáltatásként való futtatásához szükséges egyéb összetevőket.The inference configuration specifies the environment configuration, entry script, and other components needed to run the model as a service.

Ha rendelkezik a szükséges összetevőkkel, megtekintheti azt a szolgáltatást, amely a modell üzembe helyezésének eredményeképpen jön létre a CPU-és memória-követelmények megismerése érdekében.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. a következtetési környezet meghatározása1. Define inference environment

A következtetések konfigurálásával megtudhatja, hogyan állíthatja be a modellt tartalmazó webes szolgáltatást.An inference configuration describes how to set up the web-service containing your model. Ezt később, a modell telepítésekor használják.It's used later, when you deploy the model.

A következtetések konfigurálásával Azure Machine Learning környezetek határozzák meg az üzemelő példányhoz szükséges szoftver-függőségeket.Inference configuration uses Azure Machine Learning environments to define the software dependencies needed for your deployment. A környezetek lehetővé teszik a képzéshez és a telepítéshez szükséges szoftver-függőségek létrehozását, kezelését és újrafelhasználását.Environments allow you to create, manage, and reuse the software dependencies required for training and deployment. Létrehozhat egy környezetet egyéni függőségi fájlokból, vagy használhatja a kurátori Azure Machine Learning környezetek egyikét.You can create an environment from custom dependency files or use one of the curated Azure Machine Learning environments. Az alábbi YAML egy Conda-függőségi fájlra mutat példát.The following YAML is an example of a Conda dependencies file for inference. Vegye figyelembe, hogy a azureml alapértelmezett értékeit kell megadnia a (z) >= 1.0.45 lépésszám-függőségként, mert tartalmazza a modell webszolgáltatásként való üzemeltetéséhez szükséges funkciókat.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. Ha automatikus séma-generálást szeretne használni, a belépési parancsfájlnak importálnia inference-schema kell a csomagokat is.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]

Fontos

Ha a függőség a Conda és a PIP (a PyPi) szolgáltatáson keresztül érhető el, a Microsoft a Conda-verzió használatát javasolja, mivel a Conda-csomagok jellemzően olyan előre elkészített bináris fájlokkal rendelkeznek, amelyek megbízhatóbb telepítést tesznek elérhetővé.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.

További információ: a Conda és a pip ismertetése.For more information, see Understanding Conda and Pip.

Ha szeretné megnézni, hogy a függőség elérhető-e a Conda conda search <package-name> -on keresztül, használja a parancsot, vagy https://anaconda.org/anaconda/repo használja https://anaconda.org/conda-forge/repoa csomag indexeit a és a értéknél.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.

A függőségek fájl használatával létrehozhat egy környezeti objektumot, és mentheti a munkaterületre későbbi használatra: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. pontozási kód definiálása2. Define scoring code

A bejegyzési parancsfájl fogadja az üzembe helyezett webszolgáltatásnak küldött és a modellnek átadott adatforrást.The entry script receives data submitted to a deployed web service and passes it to the model. Ezután a modell visszaadja a választ, és visszaadja az ügyfélnek.It then takes the response returned by the model and returns that to the client. A szkript a modellre jellemző.The script is specific to your model. Ismernie kell a modell által várt és visszaadott adatok értékét.It must understand the data that the model expects and returns.

A parancsfájl két olyan függvényt tartalmaz, amelyek betöltik és futtatják a modellt:The script contains two functions that load and run the model:

  • init(): Ez a függvény általában egy globális objektumba tölti be a modellt.init(): Typically, this function loads the model into a global object. Ez a függvény csak egyszer fut, amikor a webszolgáltatás Docker-tárolója elindult.This function is run only once, when the Docker container for your web service is started.

  • run(input_data): Ez a függvény a modellt használva előre jelez egy értéket a bemeneti adatok alapján.run(input_data): This function uses the model to predict a value based on the input data. A Futtatás bemenetei és kimenetei általában a JSON-t használják a szerializáláshoz és a deszerializáláshoz.Inputs and outputs of the run typically use JSON for serialization and deserialization. A nyers bináris adatmennyiségeket is használhatja.You can also work with raw binary data. Az adatokat átalakíthatja a modellbe való küldés előtt, vagy az ügyfélnek való visszatérés előtt.You can transform the data before sending it to the model or before returning it to the client.

A modell fájljainak betöltése a bejegyzési parancsfájlbaLoad model files in your entry script

A következő két módon kereshet modelleket a nevezési parancsfájlban:There are two ways to locate models in your entry script:

  • AZUREML_MODEL_DIR: Egy környezeti változó, amely a modell helyének elérési útját tartalmazza.AZUREML_MODEL_DIR: An environment variable containing the path to the model location.
  • Model.get_model_path: Egy API, amely visszaadja a modell elérési útját a regisztrált modell nevével.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 a szolgáltatás telepítése során létrehozott környezeti változó.AZUREML_MODEL_DIR is an environment variable created during service deployment. Ezt a környezeti változót használhatja a telepített modell (ek) helyének megkereséséhez.You can use this environment variable to find the location of the deployed model(s).

A következő táblázat a telepített modellek számától függően AZUREML_MODEL_DIR értékét ismerteti:The following table describes the value of AZUREML_MODEL_DIR depending on the number of models deployed:

Üzembe helyezésDeployment Környezeti változó értékeEnvironment variable value
Egyetlen modellSingle model A modellt tartalmazó mappa elérési útja.The path to the folder containing the model.
Több modellMultiple models Az összes modellt tartalmazó mappa elérési útja.The path to the folder containing all models. A modellek a mappa neve és verziója szerint találhatók ($MODEL_NAME/$VERSION)Models are located by name and version in this folder ($MODEL_NAME/$VERSION)

A modell regisztrálása és üzembe helyezése során a rendszer a modelleket a AZUREML_MODEL_DIR útvonalon helyezi el, és az eredeti fájlnevek megmaradnak.During model registration and deployment, Models are placed in the AZUREML_MODEL_DIR path, and their original filenames are preserved.

Ha szeretné beolvasni a parancsfájl elérési útját a bejegyzési parancsfájlban, akkor a környezeti változót a keresett fájl elérési útjával kell egyesíteni.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élda egyetlen modellreSingle 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')

Több modell – példaMultiple 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

Modell regisztrálása esetén meg kell adnia a modellnek a beállításjegyzékben való kezeléséhez használt modell nevét.When you register a model, you provide a model name that's used for managing the model in the registry. Ezt a nevet használja a Model. get_model_path () metódussal, hogy lekérje a modell fájljának vagy fájljainak elérési útját a helyi fájlrendszerben.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. Ha egy mappát vagy fájl-gyűjteményt regisztrál, az API a fájlokat tartalmazó könyvtár elérési útját adja vissza.If you register a folder or a collection of files, this API returns the path of the directory that contains those files.

Modell regisztrálása esetén a nevet adja meg.When you register a model, you give it a name. A név a modell elhelyezésének helyét adja meg helyileg vagy a szolgáltatás telepítése során.The name corresponds to where the model is placed, either locally or during service deployment.

Választható Modell-webszolgáltatás sémájának definiálása(Optional) Define model web service schema

Ha automatikusan szeretne létrehozni egy sémát a webszolgáltatás számára, adja meg a bemeneti és/vagy kimeneti adatokat a konstruktorban egy adott típusú objektumhoz.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. A rendszer a típust és a mintát használja a séma automatikus létrehozásához.The type and sample are used to automatically create the schema. A Azure Machine Learning Ezután létrehoz egy OpenAPI (hencegő) specifikációt a webszolgáltatás számára az üzembe helyezés során.Azure Machine Learning then creates an OpenAPI (Swagger) specification for the web service during deployment.

Ezek a típusok jelenleg támogatottak:These types are currently supported:

  • pandas
  • numpy
  • pyspark
  • Standard Python-objektumStandard Python object

A séma generálásához a függőségi fájlban adja meg inference-schema a nyílt forráskódú csomagot.To use schema generation, include the open-source inference-schema package in your dependencies file. A csomaggal kapcsolatos további információkért lásd: https://github.com/Azure/InferenceSchema.For more information on this package, see https://github.com/Azure/InferenceSchema. Adja meg a bemeneti és kimeneti minták formátumait input_sample a output_sample és a változóban, amelyek a webszolgáltatáshoz tartozó kérések és válaszok formátumait jelölik.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. Ezeket a mintákat a run() függvény bemeneti és kimeneti függvényében használhatja.Use these samples in the input and output function decorators on the run() function. A következő scikit példa a séma generálását használja.The following scikit-learn example uses schema generation.

Példa a bejegyzés parancsfájlraExample entry script

Az alábbi példa bemutatja, hogyan fogadhat és adhat vissza JSON-adattartalomot: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

Az alábbi példa bemutatja, hogyan határozhatja meg a bemeneti adatokat <key: value> szótárként egy DataFrame használatával.The following example demonstrates how to define the input data as a <key: value> dictionary by using a DataFrame. Ez a módszer a központilag telepített webszolgáltatás Power BI való felhasználására használható.This method is supported for consuming the deployed web service from Power BI. (További információ a webszolgáltatás Power BIból valóhasználatáról.)(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

További példákért tekintse meg a következő parancsfájlokat:For more examples, see the following scripts:

3. a következtetési konfiguráció megadása3. Define inference configuration

Az alábbi példa bemutatja egy környezet betöltését a munkaterületről, majd azt a következtetési konfigurációval használva: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)

További információ a környezetekről: környezetek létrehozása és kezelése képzéshez és üzembe helyezéshez.For more information on environments, see Create and manage environments for training and deployment.

További információ a konfigurációval kapcsolatban: InferenceConfig Class dokumentáció.For more information on inference configuration, see the InferenceConfig class documentation.

További információ a következtetési konfigurációval rendelkező egyéni Docker-rendszerképek használatáról: modell üzembe helyezése egyéni Docker-rendszerkép használatával.For information on using a custom Docker image with an inference configuration, see How to deploy a model using a custom Docker image.

CLI-példa InferenceConfigCLI example of InferenceConfig

A inferenceconfig.json dokumentumban szereplő bejegyzések a InferenceConfig osztály paramétereinek felelnek meg.The entries in the inferenceconfig.json document map to the parameters for the InferenceConfig class. A következő táblázat ismerteti a JSON-dokumentum entitásai közötti leképezést, valamint a metódus paramétereit:The following table describes the mapping between entities in the JSON document and the parameters for the method:

JSON-entitásJSON entity Metódus paramétereMethod parameter LeírásDescription
entryScript entry_script A rendszerképhez futtatandó kódot tartalmazó helyi fájl elérési útja.Path to a local file that contains the code to run for the image.
sourceDirectory source_directory Választható.Optional. Az összes fájlt tartalmazó mappák elérési útja a rendszerkép létrehozásához, amely megkönnyíti a mappában vagy almappában található fájlok elérését.Path to folders that contain all files to create the image, which makes it easy to access any files within this folder or subfolder. A webszolgáltatások függőségeiként feltölthet egy teljes mappát a helyi gépről.You can upload an entire folder from your local machine as dependencies for the Webservice. Megjegyzés: a entry_script, a conda_file és a extra_docker_file_steps útvonalak relatív elérési utak az source_directory elérési úthoz.Note: your entry_script, conda_file, and extra_docker_file_steps paths are relative paths to the source_directory path.
environment environment Választható.Optional. Azure Machine Learning környezet.Azure Machine Learning environment.

Azure Machine Learning környezet teljes specifikációit a következtetési konfigurációs fájlban is megadhatja.You can include full specifications of an Azure Machine Learning environment in the inference configuration file. Ha ez a környezet nem létezik a munkaterületen, akkor a Azure Machine Learning létrehozza azt.If this environment doesn't exist in your workspace, Azure Machine Learning will create it. Ellenkező esetben a Azure Machine Learning szükség esetén frissíti a környezetet.Otherwise, Azure Machine Learning will update the environment if necessary. A következő JSON egy példa: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"
    }
}

Meglévő Azure Machine Learning- környezetet is HASZNÁLHAT külön CLI-paraméterekben, és eltávolíthatja a "környezet" kulcsot a következtetési konfigurációs fájlból.You can also use an existing Azure Machine Learning environment in separated CLI parameters and remove the "environment" key from the inference configuration file. Használja az-e nevet a környezet neveként, a--EV pedig a környezet verzióját.Use -e for the environment name, and --ev for the environment version. Ha nem ad meg--EV-t, a rendszer a legújabb verziót fogja használni.If you don't specify --ev, the latest version will be used. Íme egy példa a következtetési konfigurációs fájlra:Here is an example of an inference configuration file:

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

A következő parancs bemutatja, hogyan helyezhet üzembe egy modellt az előző következtetési konfigurációs fájl (myInferenceConfig. JSON) használatával.The following command demonstrates how to deploy a model using the previous inference configuration file (named myInferenceConfig.json).

Egy meglévő Azure Machine Learning- környezet legújabb verzióját is használja (AzureML-minimal néven).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

A következő parancs bemutatja, hogyan helyezhet üzembe egy modellt a parancssori felület használatával: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

Ebben a példában a konfiguráció a következő beállításokat adja meg:In this example, the configuration specifies the following settings:

  • A modellhez Python szükséges.That the model requires Python.
  • A beléptetési parancsfájl, amely a központilag telepített szolgáltatásnak küldött webes kérelmek kezelésére szolgál.The entry script, which is used to handle web requests sent to the deployed service.
  • A következtetéshez szükséges Python-csomagokat ismertető Conda-fájl.The Conda file that describes the Python packages needed for inference.

További információ a következtetési konfigurációval rendelkező egyéni Docker-rendszerképek használatáról: modell üzembe helyezése egyéni Docker-rendszerkép használatával.For information on using a custom Docker image with an inference configuration, see How to deploy a model using a custom Docker image.

4. (nem kötelező) profil a modellben az erőforrások kihasználtságának meghatározásához4. (Optional) Profile your model to determine resource utilization

Miután regisztrálta a modelljét, és előkészítette az üzembe helyezéséhez szükséges egyéb összetevőket, megadhatja, hogy a telepített szolgáltatásnak milyen PROCESSZORral és memóriával kell rendelkeznie.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. A profilkészítés a modellt futtató szolgáltatást teszteli, és olyan információkat ad vissza, mint például a CPU-használat, a memóriahasználat és a válasz késése.Profiling tests the service that runs your model and returns information such as the CPU usage, memory usage, and response latency. Emellett javaslatot tesz a processzor és a memória számára az erőforrás-használat alapján.It also provides a recommendation for the CPU and memory based on resource usage.

A modell profiljának elvégzéséhez a következőkre lesz szüksége:In order to profile your model, you will need:

  • Egy regisztrált modell.A registered model.
  • A beléptetési parancsfájl és a környezeti környezet definíciója alapján megjelenő következtetési konfiguráció.An inference configuration based on your entry script and inference environment definition.
  • Egyoszlopos táblázatos adatkészlet, amelyben minden sor tartalmaz egy minta típusú kérelmeket jelölő karakterláncot.A single column tabular dataset, where each row contains a string representing sample request data.

Fontos

Ezen a ponton csak olyan szolgáltatások profilkészítését támogatjuk, amelyek a kérési adatok karakterláncnak számítanak, például: karakterlánc szerializált JSON, szöveg, karakterlánc szerializált rendszerkép stb. Az adatkészlet (string) egyes sorainak tartalmát a rendszer a HTTP-kérelem törzsébe helyezi el, és elküldi a modellnek a pontozást tartalmazó szolgáltatásnak.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.

Az alábbi példa bemutatja, hogyan hozhat létre egy bemeneti adatkészletet olyan szolgáltatás profiljához, amely a beérkező kérések adatait szerializált JSON-ként kívánja tartalmazni.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. Ebben az esetben létrehoztunk egy adatkészleten alapuló 100-példányt az azonos kérelem adattartalmából.In this case, we created a dataset based one hundred instances of the same request data content. A valós forgatókönyvekben azt javasoljuk, hogy használjon nagyobb adatkészleteket, amelyek különböző bemeneteket tartalmaznak, különösen akkor, ha a modell Erőforrás-kihasználtsága/viselkedése a bemenettől függ.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)

Ha már rendelkezik a mintavételi adatokat tartalmazó adatkészlettel, hozzon létre egy következtetési konfigurációt.Once you have the dataset containing sample request data ready, create an inference configuration. A következtetési konfiguráció a score.py és a környezeti definíción alapul.Inference configuration is based on the score.py and the environment definition. Az alábbi példa bemutatja, hogyan hozhatja létre a következtetési konfigurációt, és hogyan futtathatja a profilkészítést: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()

A következő parancs bemutatja, hogyan lehet profilt felvenni a parancssori felület használatával: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>

Tipp

A profilkészítés által visszaadott adatok megőrzéséhez használja a modell címkéit vagy tulajdonságait.To persist the information returned by profiling, use tags or properties for the model. A címkék vagy tulajdonságok használatával a modell beállításjegyzékében tárolja az adatait.Using tags or properties stores the data with the model in the model registry. Az alábbi példák azt mutatják be, hogyan adhat hozzá requestedCpu olyan requestedMemoryInGb új címkét, amely tartalmazza a és a információkat:The 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

Üzembe helyezés célhelyreDeploy to target

Az üzemelő példány a konfiguráció központi telepítési konfigurációjának használatával helyezi üzembe a modelleket.Deployment uses the inference configuration deployment configuration to deploy the models. A telepítési folyamat a számítási céltól függetlenül hasonló.The deployment process is similar regardless of the compute target. Az AK-ra való üzembe helyezés némileg eltérő, mert meg kell adnia egy hivatkozást az AK-fürthöz.Deploying to AKS is slightly different because you must provide a reference to the AKS cluster.

Számítási cél kiválasztásaChoose a compute target

A webszolgáltatás központi telepítésének üzemeltetéséhez a következő számítási célokat vagy számítási erőforrásokat használhatja:You can use the following compute targets, or compute resources, to host your web service deployment:

Számítási célCompute target Alkalmazási célUsed for GPU-támogatásGPU support FPGA-támogatásFPGA support LeírásDescription
Helyi webszolgáltatás Local web service Tesztelés/hibakeresésTesting/debugging     Korlátozott teszteléshez és hibaelhárításhoz használható.Use for limited testing and troubleshooting. A hardveres gyorsítás a helyi rendszer könyvtárainak használatából függ.Hardware acceleration depends on use of libraries in the local system.
Azure Machine Learning számítási példány  webszolgáltatásaAzure Machine Learning compute instance web service Tesztelés/hibakeresésTesting/debugging     Korlátozott teszteléshez és hibaelhárításhoz használható.Use for limited testing and troubleshooting.
Azure Kubernetes Service (AKS)Azure Kubernetes Service (AKS) Valós idejű következtetésReal-time inference Igen (webszolgáltatás üzembe helyezése)Yes (web service deployment) IgenYes Nagy léptékű üzembe helyezések esetén használható.Use for high-scale production deployments. Gyors válaszidőt és automatikus skálázást biztosít a telepített szolgáltatás számára.Provides fast response time and autoscaling of the deployed service. A fürt automatikus skálázása nem támogatott a Azure Machine Learning SDK-n keresztül.Cluster autoscaling isn't supported through the Azure Machine Learning SDK. Az AK-fürt csomópontjainak módosításához használja a Azure Portalban az AK-fürt felhasználói felületét.To change the nodes in the AKS cluster, use the UI for your AKS cluster in the Azure portal. A tervező számára az egyazon lehetőség áll rendelkezésre.AKS is the only option available for the designer.
Azure Container InstancesAzure Container Instances Tesztelés vagy fejlesztésTesting or development     Alacsony léptékű CPU-alapú számítási feladatokhoz használható, amelyek kevesebb mint 48 GB RAM memóriát igényelnek.Use for low-scale CPU-based workloads that require less than 48 GB of RAM.
Számítási fürtök Azure Machine LearningAzure Machine Learning compute clusters Előnézet Batch -következtetés(Preview) Batch inference Igen (gépi tanulási folyamat)Yes (machine learning pipeline)   Kötegelt pontozás futtatása kiszolgáló nélküli számítási feladatokhoz.Run batch scoring on serverless compute. A a normál és az alacsony prioritású virtuális gépeket támogatja.Supports normal and low-priority VMs.
Azure FunctionsAzure Functions Előnézet Valós idejű következtetés(Preview) Real-time inference      
Azure IoT EdgeAzure IoT Edge Előnézet IoT modul(Preview) IoT module     ML modellek üzembe helyezése és kiszolgálása a IoT-eszközökön.Deploy and serve ML models on IoT devices.
Azure Data Box EdgeAzure Data Box Edge IoT Edge keresztülVia IoT Edge   IgenYes ML modellek üzembe helyezése és kiszolgálása a IoT-eszközökön.Deploy and serve ML models on IoT devices.

Megjegyzés

Bár a számítási célok, például a helyi, Azure Machine Learning számítási példányok, és a Azure Machine Learning számítási fürtök támogatják a GPU-t a betanításhoz és kísérletezéshez, a GPU for bevezetést, Ha a szolgáltatást webszolgáltatásként telepítik , csak az Azure Kubernetes szolgáltatásban támogatott.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.

Ha a Machine learning-folyamattal való pontozást csak Azure Machine learning számításokban támogatja, GPU-t használ a következtetéshez.Using a GPU for inference when scoring with a machine learning pipeline is supported only on Azure Machine Learning Compute.

A telepítési konfiguráció megadásaDefine your deployment configuration

A modell üzembe helyezése előtt meg kell határoznia a telepítési konfigurációt.Before deploying your model, you must define the deployment configuration. A központi telepítési konfiguráció a webszolgáltatást futtató számítási célra vonatkozik.The deployment configuration is specific to the compute target that will host the web service. Ha például helyileg helyez üzembe egy modellt, meg kell adnia azt a portot, ahol a szolgáltatás fogadja a kérelmeket.For example, when you deploy a model locally, you must specify the port where the service accepts requests. A telepítési konfiguráció nem része a belépési parancsfájlnak.The deployment configuration isn't part of your entry script. A rendszer a modell és a beléptetési parancsfájlt futtató számítási cél jellemzőinek meghatározására szolgál.It's used to define the characteristics of the compute target that will host the model and entry script.

Előfordulhat, hogy a számítási erőforrást is létre kell hoznia, ha például még nem rendelkezik a munkaterülethez társított Azure Kubernetes Service-(ak-) példánnyal.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.

Az alábbi táblázat az egyes számítási célkitűzések központi telepítési konfigurációjának létrehozásához nyújt példát:The following table provides an example of creating a deployment configuration for each compute target:

Számítási célCompute target Üzembe helyezési konfiguráció – példaDeployment configuration example
HelyiLocal 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)

A helyi, Azure Container Instances és AK webszolgáltatásokhoz tartozó osztályok a következő helyekről azureml.core.webserviceimportálhatók: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

Központi telepítések biztonságossá tétele a TLS-velSecuring deployments with TLS

További információ a webszolgáltatások telepítésének biztonságossá tételéről: a TLS engedélyezése és üzembe helyezése.For more information on how to secure a web service deployment, see Enable TLS and deploy.

Helyi telepítésLocal deployment

Modell helyi üzembe helyezéséhez a Docker-t telepíteni kell a helyi gépre.To deploy a model locally, you need to have Docker installed on your local machine.

Az SDK használataUsing 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)

További információkért tekintse meg a LocalWebservice, a Model. Deploy ()és a webszolgáltatásokdokumentációját.For more information, see the documentation for LocalWebservice, Model.deploy(), and Webservice.

A parancssori felület használataUsing the CLI

Ha a parancssori felület használatával szeretne üzembe helyezni egy modellt, használja a következő parancsot.To deploy a model by using the CLI, use the following command. Cserélje mymodel:1 le a nevet a regisztrált modell nevére és verziójára: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

A deploymentconfig.json dokumentumtérkép bejegyzései a LocalWebservice. deploy_configurationparamétereit képezik le.The entries in the deploymentconfig.json document map to the parameters for LocalWebservice.deploy_configuration. A következő táblázat ismerteti a JSON-dokumentum entitásai és a metódus paramétereinek megfeleltetését:The following table describes the mapping between the entities in the JSON document and the parameters for the method:

JSON-entitásJSON entity Metódus paramétereMethod parameter LeírásDescription
computeType NANA A számítási cél.The compute target. Helyi célok esetén az értéknek a következőnek kell lennie local:.For local targets, the value must be local.
port port A helyi port, amelyen elérhetővé kívánja tenni a szolgáltatás HTTP-végpontját.The local port on which to expose the service's HTTP endpoint.

Ez a JSON egy példaként szolgáló telepítési konfiguráció a parancssori felülettel való használatra:This JSON is an example deployment configuration for use with the CLI:

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

További információ: az ml Model Deploy dokumentáció.For more information, see the az ml model deploy documentation.

A szolgáltatás állapotának ismertetéseUnderstanding service state

A modell telepítése során előfordulhat, hogy a szolgáltatás állapota megváltozik a teljes üzembe helyezése során.During model deployment, you may see the service state change while it fully deploys.

Az alábbi táblázat a különböző szolgáltatás-állapotokat ismerteti:The following table describes the different service states:

Webszolgáltatás állapotaWebservice state LeírásDescription Végső állapot?Final state?
TransitioningTransitioning A szolgáltatás üzembe helyezési folyamatban van.The service is in the process of deployment. NemNo
Nem kifogástalanUnhealthy A szolgáltatás telepítve van, de jelenleg nem érhető el.The service has deployed but is currently unreachable. NemNo
UnschedulableUnschedulable A szolgáltatás jelenleg nem telepíthető az erőforrások hiánya miatt.The service cannot be deployed at this time due to lack of resources. NemNo
SikertelenFailed Hiba vagy összeomlás miatt nem sikerült telepíteni a szolgáltatást.The service has failed to deploy due to an error or crash. IgenYes
KifogástalanHealthy A szolgáltatás kifogástalan állapotban van, és a végpont elérhető.The service is healthy and the endpoint is available. IgenYes

Számítási példány webszolgáltatás (dev/test)Compute instance web service (dev/test)

Lásd: modell üzembe helyezése Azure Machine learning számítási példányra.See Deploy a model to Azure Machine Learning compute instance.

Azure Container Instances (dev/test)Azure Container Instances (dev/test)

Lásd: Azure Container instances üzembe helyezése.See Deploy to Azure Container Instances.

Azure Kubernetes szolgáltatás (fejlesztési/tesztelési és éles üzem)Azure Kubernetes Service (dev/test and production)

Lásd: üzembe helyezés az Azure Kubernetes szolgáltatásban.See Deploy to Azure Kubernetes Service.

A/B tesztelés (vezérelt bevezetés)A/B Testing (controlled rollout)

További információkért lásd: ml modellek szabályozott bevezetése .See Controlled rollout of ML models for more information.

Webszolgáltatások felhasználásaConsume web services

Minden üzembe helyezett webszolgáltatás REST-végpontot biztosít, így bármilyen programozási nyelven létrehozhat ügyfélalkalmazások.Every deployed web service provides a REST endpoint, so you can create client applications in any programming language. Ha engedélyezte a szolgáltatás kulcs-alapú hitelesítését, meg kell adnia egy szolgáltatási kulcsot a kérelem fejlécében lévő jogkivonatként.If you've enabled key-based authentication for your service, you need to provide a service key as a token in your request header. Ha engedélyezte a jogkivonat-alapú hitelesítést a szolgáltatáshoz, meg kell adnia egy Azure Machine Learning JSON Web Token (JWT) tulajdonosi jogkivonatként a kérelem fejlécében.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.

Az elsődleges különbség az, hogy a kulcsok statikusak, és manuálisan is újra létrehozhatók, és a jogkivonatokat a lejárat után frissítenikell.The primary difference is that keys are static and can be regenerated manually, and tokens need to be refreshed upon expiration. A kulcs alapú hitelesítés az Azure Container instance és az Azure Kubernetes Service szolgáltatásban telepített webszolgáltatások esetében támogatott, és a jogkivonat-alapú hitelesítés csak az Azure Kubernetes Service-példányok esetében érhető el.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. További információért és a kód-példákért tekintse meg az útmutató a hitelesítéshez című témakört.See the how-to on authentication for more information and specific code samples.

Tipp

A séma JSON-dokumentum a szolgáltatás telepítése után kérhető le.You can retrieve the schema JSON document after you deploy the service. Használja a központilag telepített webszolgáltatás swagger_uri tulajdonságát (például service.swagger_uri) a helyi webszolgáltatás hencegő fájljához tartozó URI-azonosító lekéréséhez.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.

Kérelem – válasz felhasználásRequest-response consumption

Íme egy példa arra, hogyan hívhatja meg a szolgáltatást a Pythonban: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())

További információ: ügyfélalkalmazások létrehozása webszolgáltatások felhasználásához.For more information, see Create client applications to consume web services.

Webszolgáltatás sémája (OpenAPI-specifikáció)Web service schema (OpenAPI specification)

Ha a központi telepítéshez automatikus sémát használ, a swagger_uri tulajdonsághasználatával lekérheti a szolgáltatás OpenAPI-specifikációjának a címeit.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. (Például: print(service.swagger_uri).) Használja a GET kérelmet, vagy nyissa meg az URI-t egy böngészőben a specifikáció lekéréséhez.(For example, print(service.swagger_uri).) Use a GET request or open the URI in a browser to retrieve the specification.

A következő JSON-dokumentum egy példa egy központi telepítéshez létrehozott sémára (OpenAPI-specifikáció):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"
                }
            }
        }
    }
}

További információ: OpenAPI- specifikáció.For more information, see OpenAPI specification.

Egy olyan segédprogram esetében, amely a specifikációból tud ügyféloldali kódtárakat létrehozni, tekintse meg a következőt: hencegés-CODEGEN.For a utility that can create client libraries from the specification, see swagger-codegen.

Batch-következtetésBatch inference

A Azure Machine Learning számítási célokat Azure Machine Learning hozza létre és kezeli.Azure Machine Learning Compute targets are created and managed by Azure Machine Learning. A kötegelt előrejelzésekhez Azure Machine Learning folyamatokból is felhasználhatók.They can be used for batch prediction from Azure Machine Learning pipelines.

A Batch-következtetések Azure Machine Learning számítási feladatokkal való áttekintését lásd: a Batch-előrejelzések futtatása.For a walkthrough of batch inference with Azure Machine Learning Compute, see How to run batch predictions.

IoT Edge következtetésIoT Edge inference

A peremhálózati üzembe helyezésének támogatása előzetes verzióban érhető el.Support for deploying to the edge is in preview. További információ: Azure Machine learning telepítése IoT Edge modulként.For more information, see Deploy Azure Machine Learning as an IoT Edge module.

Webszolgáltatások frissítéseUpdate web services

Webszolgáltatások frissítéséhez használja a update metódust.To update a web service, use the update method. Frissítheti a webszolgáltatást egy új modell, egy új bejegyzési parancsfájl vagy egy következtetési konfigurációban megadható új függőségek használatára.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. További információkért tekintse meg a webszolgáltatások dokumentációját. frissítés.For more information, see the documentation for Webservice.update.

Fontos

A modell új verziójának létrehozásakor manuálisan kell frissítenie az összes használni kívánt szolgáltatást.When you create a new version of a model, you must manually update each service that you want to use it.

Az SDK-val nem lehet frissíteni a Azure Machine Learning Designer alkalmazásban közzétett webszolgáltatásokat.You can not use the SDK to update a web service published from the Azure Machine Learning designer.

Az SDK használataUsing the SDK

A következő kód bemutatja, hogyan használható az SDK a webszolgáltatások modelljének, környezetének és bejegyzési parancsfájljának frissítéséhez: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())

A parancssori felület használataUsing the CLI

A webszolgáltatás a ML parancssori felület használatával is frissíthető.You can also update a web service by using the ML CLI. Az alábbi példa bemutatja egy új modell regisztrálását, majd egy webszolgáltatás frissítését az új modell használatára: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

Tipp

Ebben a példában egy JSON-dokumentum segítségével továbbítja a modell adatait a regisztrációs parancsból az Update parancsba.In this example, a JSON document is used to pass the model information from the registration command into the update command.

Ha a szolgáltatást új bejegyzési parancsfájl vagy környezet használatára szeretné frissíteni, hozzon létre egy következtetési konfigurációs fájlt , és adja meg ic a paramétert.To update the service to use a new entry script or environment, create an inference configuration file and specify it with the ic parameter.

További információt az az ml Service Update dokumentációjában talál.For more information, see the az ml service update documentation.

Modellek folyamatos üzembe helyezéseContinuously deploy models

A modellek folyamatos üzembe helyezéséhez használja az Azure DevOpsMachine learning-bővítményét.You can continuously deploy models by using the Machine Learning extension for Azure DevOps. Az Azure DevOps Machine Learning bővítményével elindíthat egy központi telepítési folyamatot, amikor egy új gépi tanulási modell van regisztrálva egy Azure Machine Learning munkaterületen.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. Regisztráljon az Azure-folyamatokra, ami lehetővé teszi az alkalmazás folyamatos integrálását és megvalósítását bármilyen platformon vagy felhőben.Sign up for Azure Pipelines, which makes continuous integration and delivery of your application to any platform or cloud possible. (Vegye figyelembe, hogy az Azure-folyamatok nem egyeznek meg Machine learning folyamatokkal.)(Note that Azure Pipelines isn't the same as Machine Learning pipelines.)

  2. Hozzon létre egy Azure DevOps-projektet.Create an Azure DevOps project.

  3. Telepítse az Azure-folyamatok Machine learning-bővítményét.Install the Machine Learning extension for Azure Pipelines.

  4. A szolgáltatási kapcsolatok szolgáltatással hozzon létre egy egyszerű szolgáltatásnevet a Azure Machine Learning munkaterülethez, hogy hozzáférjen az összetevőkhöz.Use service connections to set up a service principal connection to your Azure Machine Learning workspace so you can access your artifacts. Nyissa meg a projekt beállításait, válassza a szolgáltatás kapcsolatailehetőséget, majd válassza a Azure Resource Manager:Go to project settings, select Service connections, and then select Azure Resource Manager:

    Azure Resource Manager kiválasztásaSelect Azure Resource Manager

  5. A hatókör szintje listán válassza a AzureMLWorkspacelehetőséget, majd adja meg a többi értéket:In the Scope level list, select AzureMLWorkspace, and then enter the rest of the values:

    AzureMLWorkspace kiválasztása

  6. A gépi tanulási modell Azure-folyamatokkal való folyamatos üzembe helyezéséhez a folyamatok területen válassza a kiadáslehetőséget.To continuously deploy your machine learning model by using Azure Pipelines, under pipelines, select release. Adjon hozzá egy új összetevőt, majd válassza ki a AzureML-modell összetevőt és a korábban létrehozott szolgáltatási kapcsolatokat.Add a new artifact, and then select the AzureML Model artifact and the service connection that you created earlier. A telepítés elindításához válassza ki a modellt és a verziót:Select the model and version to trigger a deployment:

    AzureML modell kiválasztásaSelect AzureML Model

  7. Engedélyezze a modell-triggert a modell-összetevőn.Enable the model trigger on your model artifact. Ha bekapcsolja a triggert, minden alkalommal, amikor a modell megadott verziója (azaz a legújabb verziója) regisztrálva van a munkaterületen, az Azure DevOps kiadási folyamat aktiválódik.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.

    Modell-trigger engedélyezéseEnable the model trigger

További példákért tekintse meg ezeket a mintákat a GitHubon:For more sample projects and examples, see these sample repos in GitHub:

Modell letöltéseDownload a model

Ha le szeretné tölteni a modellt a saját végrehajtási környezetében való használatra, ezt a következő SDK/CLI-parancsokkal teheti meg: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:

SDKSDK:

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

CLICLI:

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

Előnézet Nem kód modell telepítése(Preview) No-code model deployment

A nem kód modellek üzembe helyezése jelenleg előzetes verzióban érhető el, és a következő Machine learning-keretrendszereket támogatja:No-code model deployment is currently in preview and supports the following machine learning frameworks:

Tensorflow SavedModel formátumaTensorflow SavedModel format

A Tensorflow-modelleket SavedModel formátumban kell regisztrálni, hogy a kód nélküli üzembe helyezéssel működjön.Tensorflow models need to be registered in SavedModel format to work with no-code model deployment.

A SavedModel létrehozásával kapcsolatos információkért tekintse meg ezt a hivatkozást .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])

ONNX-modellekONNX models

A ONNX-modell regisztrálása és üzembe helyezése bármely ONNX-következtetési gráf esetében támogatott.ONNX model registration and deployment is supported for any ONNX inference graph. Az előfeldolgozási és a utófeldolgozás lépések jelenleg nem támogatottak.Preprocess and postprocess steps are not currently supported.

Íme egy példa arra, hogyan regisztrálhatók és telepíthetők egy MNIST ONNX-modell: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])

Ha a Pytorch-t használja, a Pytorch-ről a ONNX-re való exportáláskor a rendszer az átalakítással és korlátozásokkal kapcsolatos részleteket tartalmaz.If you're using Pytorch, Exporting models from PyTorch to ONNX has the details on conversion and limitations.

Scikit – modellek megismeréseScikit-learn models

Az összes beépített scikit-típushoz nem támogatott a programkód-modell üzembe helyezése.No code model deployment is supported for all built-in scikit-learn model types.

Íme egy példa arra, hogyan regisztrálhat és helyezhet üzembe egy sklearn-modellt további kód nélkül: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])

Megjegyzés: a predict_probat támogató modellek alapértelmezés szerint ezt a metódust fogják használni.NOTE: Models which support predict_proba will use that method by default. Ennek felülbírálásához a következőképpen módosíthatja a POST törzset: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)

Megjegyzés: ezek a függőségek az előre elkészített sklearn következtetési tárolóban szerepelnek:NOTE: These dependencies are included in the prebuilt sklearn inference container:

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

Csomagok modelljeiPackage models

Bizonyos esetekben előfordulhat, hogy létre kell hoznia egy Docker-rendszerképet a modell üzembe helyezése nélkül (Ha például telepíteni szeretné a 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). Vagy előfordulhat, hogy le szeretné tölteni a rendszerképet, és egy helyi Docker-telepítésre kell futtatnia.Or you might want to download the image and run it on a local Docker installation. Előfordulhat, hogy még le szeretné tölteni a rendszerkép létrehozásához használt fájlokat, megvizsgálhatja őket, módosíthatja azokat, és manuálisan is felépítheti a rendszerképet.You might even want to download the files used to build the image, inspect them, modify them, and build the image manually.

A modell csomagolása lehetővé teszi ezeket a dolgokat.Model packaging enables you to do these things. Minden olyan eszközt becsomagol, amely a modell webszolgáltatásként való üzemeltetéséhez szükséges, és lehetővé teszi egy teljesen felépített Docker-rendszerkép vagy a létrehozásához szükséges fájlok letöltését.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. A modell csomagolásának két módja van:There are two ways to use model packaging:

Csomagolt modell letöltése: Töltsön le egy Docker-rendszerképet, amely tartalmazza a modellt és más, a webszolgáltatásként való üzemeltetéséhez szükséges fájlokat.Download a packaged model: Download a Docker image that contains the model and other files needed to host it as a web service.

Docker létrehozása: A Docker-rendszerkép létrehozásához szükséges Docker, modell, bejegyzési parancsfájl és egyéb eszközök letöltése.Generate a Dockerfile: Download the Dockerfile, model, entry script, and other assets needed to build a Docker image. Ezután megvizsgálhatja a fájlokat, vagy módosíthatja a módosításokat a rendszerkép helyi létrehozása előtt.You can then inspect the files or make changes before you build the image locally.

Mindkét csomag használható helyi Docker-rendszerkép lekérésére.Both packages can be used to get a local Docker image.

Tipp

A csomagok létrehozása hasonló a modellek üzembe helyezéséhez.Creating a package is similar to deploying a model. Egy regisztrált modellt és egy következtetési konfigurációt használ.You use a registered model and an inference configuration.

Fontos

Egy teljesen felépített rendszerkép letöltéséhez vagy a rendszerkép helyi létrehozásához telepítenie kell a Docker -t a fejlesztői környezetbe.To download a fully built image or build an image locally, you need to have Docker installed in your development environment.

Csomagolt modell letöltéseDownload a packaged model

Az alábbi példa létrehoz egy rendszerképet, amely regisztrálva van az Azure Container registryben a munkaterülethez: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)

Miután létrehozta a csomagot, a használatával package.pull() lekérheti a rendszerképet a helyi Docker-környezetbe.After you create a package, you can use package.pull() to pull the image to your local Docker environment. A parancs kimenete megjeleníti a rendszerkép nevét.The output of this command will display the name of the image. Például:For example:

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

A modell letöltése után a docker images parancs használatával listázhatja a helyi rendszerképeket: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

Ha egy helyi tárolót szeretne elindítani a rendszerkép alapján, a következő parancs használatával indítson el egy nevesített tárolót a rendszerhéjból vagy a parancssorból.To start a local container based on this image, use the following command to start a named container from the shell or command line. Cserélje le <imageid> az értéket a docker images parancs által VISSZAadott rendszerkép-azonosítóra.Replace the <imageid> value with the image ID returned by the docker images command.

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

Ez a parancs elindítja a nevű myimagerendszerkép legújabb verzióját.This command starts the latest version of the image named myimage. Leképezi a 6789-es helyi portot a webszolgáltatást figyelő tárolóban lévő portra (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Emellett a nevet mycontainer a tárolóhoz rendeli, amely megkönnyíti a tároló leállítását.It also assigns the name mycontainer to the container, which makes the container easier to stop. A tároló elindítása után elküldheti a kérelmeket a http://localhost:6789/scorekövetkezőnek:.After the container is started, you can submit requests to http://localhost:6789/score.

Docker és függőségek létrehozásaGenerate a Dockerfile and dependencies

Az alábbi példa bemutatja, hogyan töltheti le a rendszerképek helyi létrehozásához szükséges Docker, modellt és egyéb eszközöket.The following example shows how to download the Dockerfile, model, and other assets needed to build an image locally. A generate_dockerfile=True paraméter azt jelzi, hogy a fájlokat nem teljesen felépített képként szeretné megadni.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)

Ez a kód letölti a rendszerképnek a imagefiles könyvtárba való felépítéséhez szükséges fájlokat.This code downloads the files needed to build the image to the imagefiles directory. A mentett fájlokban található Docker egy Azure Container registryben tárolt alaprendszerképre hivatkozik.The Dockerfile included in the saved files references a base image stored in an Azure container registry. Amikor létrehoz egy rendszerképet a helyi Docker-telepítéshez, a-beállításjegyzékben való hitelesítéshez a címnek, a felhasználónevet és a jelszót kell használnia.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. A következő lépésekkel hozhatja létre a rendszerképet egy helyi Docker-telepítés használatával:Use the following steps to build the image by using a local Docker installation:

  1. Egy rendszerhéjból vagy parancssori munkamenetből a következő paranccsal hitelesítheti a Docker-t az Azure Container Registry használatával.From a shell or command-line session, use the following command to authenticate Docker with the Azure container registry. Cserélje <address>le <username>a, <password> a és a értéket a által package.get_container_registry()lekért értékekre.Replace <address>, <username>, and <password> with the values retrieved by package.get_container_registry().

    docker login <address> -u <username> -p <password>
    
  2. A rendszerkép létrehozásához használja a következő parancsot.To build the image, use the following command. A <imagefiles> helyére írja be annak a könyvtárnak package.save() az elérési útját, amelyben a fájlokat mentette.Replace <imagefiles> with the path of the directory where package.save() saved the files.

    docker build --tag myimage <imagefiles>
    

    Ezzel a paranccsal állítható be a rendszerkép myimageneve.This command sets the image name to myimage.

A rendszerkép felépítésének ellenőrzéséhez használja az docker images parancsot.To verify that the image is built, use the docker images command. A myimage képet a következő listában kell látni: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

Ha új tárolót szeretne elindítani a rendszerkép alapján, használja a következő parancsot:To start a new container based on this image, use the following command:

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

Ez a parancs elindítja a nevű myimagerendszerkép legújabb verzióját.This command starts the latest version of the image named myimage. Leképezi a 6789-es helyi portot a webszolgáltatást figyelő tárolóban lévő portra (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Emellett a nevet mycontainer a tárolóhoz rendeli, amely megkönnyíti a tároló leállítását.It also assigns the name mycontainer to the container, which makes the container easier to stop. A tároló elindítása után elküldheti a kérelmeket a http://localhost:6789/scorekövetkezőnek:.After the container is started, you can submit requests to http://localhost:6789/score.

Példa az ügyfélre a helyi tároló teszteléséhezExample client to test the local container

A következő kód egy olyan Python-ügyfélre mutat példát, amely a tárolóval használható: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)

Más programozási nyelveken található ügyfelek esetében lásd: webszolgáltatásként üzembe helyezett modellek felhasználása.For example clients in other programming languages, see Consume models deployed as web services.

A Docker-tároló leállításaStop the Docker container

A tároló leállításához használja a következő parancsot egy másik rendszerhéjból vagy parancssorból:To stop the container, use the following command from a different shell or command line:

docker kill mycontainer

Az erőforrások eltávolításaClean up resources

Központilag telepített webszolgáltatás törléséhez használja service.delete()a következőt:.To delete a deployed web service, use service.delete(). Regisztrált modell törléséhez használja model.delete()a következőt:.To delete a registered model, use model.delete().

További információ: a webszolgáltatások dokumentációja. Delete () és Model. Delete ().For more information, see the documentation for WebService.delete() and Model.delete().

Speciális bejegyzési parancsfájl készítéseAdvanced entry script authoring

Bináris adatokBinary data

Ha a modellben bináris adatok (például rendszerkép) is szerepelnek, akkor score.py módosítania kell a központi telepítéshez használt fájlt, hogy fogadja a nyers http-kérelmeket.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. A nyers adat elfogadásához használja AMLRequest az osztályt a bejegyzési parancsfájlban @rawhttp , és adja hozzá run() a bedekorációt a függvényhez.To accept raw data, use the AMLRequest class in your entry script and add the @rawhttp decorator to the run() function.

Az alábbi példa egy olyan példát score.py mutat be, amely a bináris adatmennyiséget fogadja el: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)

Fontos

Az AMLRequest osztály a azureml.contrib névtérben található.The AMLRequest class is in the azureml.contrib namespace. A névtérben lévő entitások gyakran változnak, ahogy dolgozunk a szolgáltatás fejlesztésekor.Entities in this namespace change frequently as we work to improve the service. Az ebben a névtérben található bármit olyan előzetes verziónak kell tekinteni, amelyet a Microsoft nem támogat.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Ha ezt a helyi fejlesztési környezetben kell tesztelni, akkor a következő paranccsal telepítheti az összetevőket: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

Az AMLRequest osztály csak a score.py található nyers közzétett adat elérését teszi lehetővé, nincs ügyféloldali összetevő.The AMLRequest class only allows you to access the raw posted data in the score.py, there is no client-side component. Egy ügyfélről az adatok a szokásos módon kerülnek közzétételre.From a client, you post data as normal. Például a következő Python-kód beolvas egy képfájlt, és az adatokat:For example, the following Python code reads an image file and posts the data:

import requests
# Load image data
data = open('example.jpg', 'rb').read()
# Post raw data to scoring URI
res = request.post(url='<scoring-uri>', data=data, headers={'Content-Type': 'application/octet-stream'})

Több eredetű erőforrás-megosztás (CORS)Cross-origin resource sharing (CORS)

Az eltérő eredetű erőforrás-megosztás lehetővé teszi, hogy egy weblapon lévő erőforrásokat egy másik tartománytól lehessen kérni.Cross-origin resource sharing is a way to allow resources on a webpage to be requested from another domain. A CORS az ügyfél kérelmével elküldött HTTP-fejléceken keresztül működik, és a szolgáltatás válaszával tért vissza.CORS works via HTTP headers sent with the client request and returned with the service response. További információ a CORS és az érvényes fejlécekről: a wikipedia több eredetű erőforrás-megosztása .For more information on CORS and valid headers, see Cross-origin resource sharing in Wikipedia.

A modell telepítésének a CORS támogatására való konfigurálásához használja AMLResponse a osztályt a bejegyzési parancsfájlban.To configure your model deployment to support CORS, use the AMLResponse class in your entry script. Ez az osztály lehetővé teszi a fejlécek beállítását a válasz objektumon.This class allows you to set the headers on the response object.

A következő példa a bejegyzési parancsfájlból származó válasz Access-Control-Allow-Origin fejlécét állítja be:The following example sets the Access-Control-Allow-Origin header for the response from the entry script:

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

Fontos

Az AMLResponse osztály a azureml.contrib névtérben található.The AMLResponse class is in the azureml.contrib namespace. A névtérben lévő entitások gyakran változnak, ahogy dolgozunk a szolgáltatás fejlesztésekor.Entities in this namespace change frequently as we work to improve the service. Az ebben a névtérben található bármit olyan előzetes verziónak kell tekinteni, amelyet a Microsoft nem támogat.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Ha ezt a helyi fejlesztési környezetben kell tesztelni, akkor a következő paranccsal telepítheti az összetevőket: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

Figyelmeztetés

Azure Machine Learning csak a POST és a GET kérelmeket irányítja a pontozási szolgáltatást futtató tárolók számára.Azure Machine Learning will route only POST and GET requests to the containers running the scoring service. Ez hibákhoz vezethet, mert a böngészők a CORS-kérelmekre vonatkozó beállításokat használnak.This can cause errors due to browsers using OPTIONS requests to pre-flight CORS requests.

További lépésekNext steps