Implementar modelos com o serviço Azure Machine LearningDeploy models with the Azure Machine Learning service

Saiba como implantar o modelo de aprendizado de máquina como um serviço Web na nuvem do Azure ou para IoT Edge dispositivos.Learn how to deploy your machine learning model as a web service in the Azure cloud, or to IoT Edge devices.

O fluxo de trabalho é semelhante , independentemente de onde você implanta seu modelo:The workflow is similar regardless of where you deploy your model:

  1. Registe o modelo.Register the model.
  2. Prepare-se para implantar (especificar ativos, uso, destino de computação).Prepare to deploy (specify assets, usage, compute target).
  3. Implante o modelo no destino de computação.Deploy the model to the compute target.
  4. Teste o modelo implantado, também chamado de serviço Web.Test the deployed model, also called web service.

Para obter mais informações sobre os conceitos envolvidos no fluxo de trabalho de implantação, consulte gerenciar, implantar e monitorar modelos com o serviço Azure Machine Learning.For more information on the concepts involved in the deployment workflow, see Manage, deploy, and monitor models with Azure Machine Learning Service.

Pré-requisitosPrerequisites

Conectar-se ao seu espaço de trabalhoConnect to your workspace

O código a seguir demonstra como se conectar a um espaço de trabalho de serviço do Azure Machine Learning usando informações armazenadas em cache para o ambiente de desenvolvimento local:The following code demonstrates how to connect to an Azure Machine Learning service workspace using information cached to the local development environment:

Usando o SDKUsing the SDK

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

Para obter mais informações sobre como usar o SDK para se conectar a um espaço de trabalho, consulte o SDK do Azure Machine Learning para Python.For more information on using the SDK to connect to a workspace, see the Azure Machine Learning SDK for Python.

Usando a CLIUsing the CLI

Ao usar a CLI, use o -w parâmetro --workspace-name ou para especificar o espaço de trabalho para o comando.When using the CLI, use the -w or --workspace-name parameter to specify the workspace for the command.

Usando VS CodeUsing VS Code

Ao usar VS Code, o espaço de trabalho é selecionado usando uma interface gráfica.When using VS Code, the workspace is selected using a graphical interface. Para obter mais informações, consulte implantar e gerenciar modelos na documentação de extensão de vs Code.For more information, see Deploy and manage models in the VS Code extension documentation.

Registrar seu modeloRegister your model

Um modelo registrado é um contêiner lógico para um ou mais arquivos que compõem seu modelo.A registered model is a logical container for one or more files that make up your model. Por exemplo, se você tiver um modelo armazenado em vários arquivos, poderá registrá-los como um único modelo no espaço de trabalho.For example, if you have a model that is stored in multiple files, you can register them as a single model in the workspace. Após o registro, você pode baixar ou implantar o modelo registrado e receber todos os arquivos que foram registrados.After registration, you can then download or deploy the registered model and receive all the files that were registered.

Dica

Ao registrar um modelo, você fornece um caminho para um local de nuvem (de uma execução de treinamento) ou um diretório local.When registering a model, you provide either a path to a cloud location (from a training run) or a local directory. Esse caminho é apenas para localizar os arquivos para upload como parte do processo de registro; Ele não precisa corresponder ao caminho usado no script de entrada.This path is just to locate the files for upload as part of the registration process; it does not need to match the path used in the entry script. Para obter mais informações, consulte o que é get_model_path.For more information, see What is get_model_path.

Os modelos de aprendizado de máquina são registrados em seu espaço de trabalho do Azure Machine Learning.Machine learning models are registered in your Azure Machine Learning workspace. O modelo pode vir de Azure Machine Learning ou pode vir de outro lugar.The model can come from Azure Machine Learning or can come from somewhere else. Os exemplos a seguir demonstram como registrar um modelo:The following examples demonstrate how to register a model:

Registrar um modelo de uma execução de experimentoRegister a model from an Experiment Run

Os trechos de código nesta seção demonstram o registro de um modelo de uma execução de treinamento:The code snippets in this section demonstrate registering a model from a training run:

Importante

Esses trechos pressupõem que você executou anteriormente uma execução de treinamento e tem acesso run ao objeto (exemplo de SDK) ou ao valor de ID de execução (exemplo de CLI).These snippets assume that you have previously performed a training run and have access to the run object (SDK example) or run ID value (CLI example). Para obter mais informações sobre modelos de treinamento, consulte criar e usar destinos de computação para treinamento de modelo.For more information on training models, see Create and use compute targets for model training.

  • Usando o SDKUsing the SDK

    model = run.register_model(model_name='sklearn_mnist', model_path='outputs/sklearn_mnist_model.pkl')
    print(model.name, model.id, model.version, sep='\t')
    

    O model_path refere-se ao local da nuvem do modelo.The model_path refers to the cloud location of the model. Neste exemplo, o caminho para um único arquivo é usado.In this example, the path to a single file is used. Para incluir vários arquivos no registro do modelo, defina model_path para o diretório que contém os arquivos.To include multiple files in the model registration, set model_path to the directory that contains the files.

  • Usando a CLIUsing the CLI

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

    Dica

    Se você receber um erro inque a extensão ml não está instalada, use o seguinte comando para instalá-lo:If you get an error that the ml extension is not installed, use the following command to install it:

    az extension add -n azure-cli-ml
    

    O --asset-path refere-se ao local da nuvem do modelo.The --asset-path refers to the cloud location of the model. Neste exemplo, o caminho para um único arquivo é usado.In this example, the path to a single file is used. Para incluir vários arquivos no registro do modelo, defina --asset-path para o diretório que contém os arquivos.To include multiple files in the model registration, set --asset-path to the directory that contains the files.

  • Usando VS CodeUsing VS Code

    Registre modelos usando qualquer arquivo ou pasta de modelo com a extensão vs Code .Register models using any model files or folders with the VS Code extension.

Registrar um modelo de um arquivo localRegister a model from a local file

Você pode registrar um modelo fornecendo um caminho local para o modelo.You can register a model by providing a local path to the model. Você pode fornecer uma pasta ou um único arquivo.You can provide either a folder or a single file. Você pode usar esse método para registrar os dois modelos treinados com Azure Machine Learning serviço e, em seguida, baixados ou modelos treinados fora Azure Machine Learning.You can use this method to register both models trained with Azure Machine Learning service and then downloaded, or models trained outside Azure Machine Learning.

Importante

Você só deve usar modelos que você criar ou obter de uma fonte confiável.You should only use models that you create or obtain from a trusted source. Os modelos serializados devem ser tratados como código, pois as vulnerabilidades de segurança foram descobertas em vários formatos populares.Serialized models should be treated as code, as security vulnerabilities have been discovered in a number of popular formats. Além disso, os modelos podem ser intencionalmente treinados com intenção mal-intencionada para fornecer saída tendenciosa ou imprecisa.Further, models may be intentionally trained with malicious intent to provide biased or inaccurate output.

  • Exemplo de ONNX com o SDK do Python:ONNX example with the Python SDK:

    import os
    import urllib.request
    from azureml.core 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",)
    

    Para incluir vários arquivos no registro do modelo, defina model_path para o diretório que contém os arquivos.To include multiple files in the model registration, set model_path to the directory that contains the files.

  • Usando a CLIUsing the CLI

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

    Para incluir vários arquivos no registro do modelo, defina -p para o diretório que contém os arquivos.To include multiple files in the model registration, set -p to the directory that contains the files.

Tempo estimado: Aproximadamente 10 segundos.Time estimate: Approximately 10 seconds.

Para obter mais informações, consulte a documentação de referência para o classe de modelo.For more information, see the reference documentation for the Model class.

Para obter mais informações sobre como trabalhar com modelos treinados fora do Azure Machine Learning Service, consulte como implantar um modelo existente.For more information on working with models trained outside Azure Machine Learning service, see How to deploy an existing model.

Escolher um destino de computaçãoChoose a compute target

Os seguintes destinos de computação, ou recursos de computação, podem ser usados para hospedar a implantação do serviço Web.The following compute targets, or compute resources, can be used to host your web service deployment.

Destino de computaçãoCompute target UtilizaçãoUsage Suporte de GPUGPU support Suporte do FPGAFPGA support DescriçãoDescription
Serviço Web localLocal web service Teste/depuraçãoTesting/debug Eumaybe   Bom para teste e solução de problemas limitados.Good for limited testing and troubleshooting. A aceleração de hardware depende do uso de bibliotecas no sistema local.Hardware acceleration depends on using libraries in the local system.
Serviço Web da VM do notebookNotebook VM web service Teste/depuraçãoTesting/debug Eumaybe   Bom para teste e solução de problemas limitados.Good for limited testing and troubleshooting.
Serviço Kubernetes do Azure (AKS)Azure Kubernetes Service (AKS) Inferência em tempo realReal-time inference Okyes Okyes Ideal para implementações de produção de grande escala.Good for high-scale production deployments. Fornece tempo de resposta rápido e dimensionamento automático do serviço implantado.Provides fast response time and autoscaling of the deployed service. O dimensionamento automático do cluster não tem suporte por meio do SDK do Azure Machine Learning.Cluster autoscaling is not supported through the Azure Machine Learning SDK. Para alterar os nós no cluster AKS, use a interface do usuário do cluster do AKS no portal do Azure.To change the nodes in the AKS cluster, use the UI for your AKS cluster in the Azure portal. AKS é a única opção disponível para a interface visual.AKS is the only option available for the visual interface.
Azure Container Instances (ACI)Azure Container Instances (ACI) Teste ou desenvolvimentoTesting or dev     Boa para cargas de trabalho de baixa escala, com base na CPU que exigem < de 48 GB de RAMGood for low scale, CPU-based workloads requiring <48-GB RAM
Computação do Azure Machine LearningAzure Machine Learning Compute Apresentação Inferência de lote (Preview) Batch inference simyes   Executar a pontuação de lote em computação sem servidor.Run batch scoring on serverless compute. Dá suporte a VMs normais e de baixa prioridade.Supports normal and low-priority VMs.
Azure IoT EdgeAzure IoT Edge Apresentação Módulo IOT(Preview) IoT module     Implantar & servir modelos ML em dispositivos IoT.Deploy & serve ML models on IoT devices.
Azure Data Box EdgeAzure Data Box Edge via IoT Edgevia IoT Edge   simyes Implantar & servir modelos ML em dispositivos IoT.Deploy & serve ML models on IoT devices.

Preparar para implementarPrepare to deploy

A implantação do modelo requer várias coisas:Deploying the model requires several things:

  • Um script de entrada.An entry script. Esse script aceita solicitações, pontua a solicitação usando o modelo e retorna os resultados.This script accepts requests, scores the request using the model, and returns the results.

    Importante

    O script de entrada é específico para seu modelo; Ele deve entender o formato dos dados de solicitação de entrada, o formato dos dados esperados pelo seu modelo e o formato dos dados retornados aos clientes.The entry script is specific to your model; it must understand the format of the incoming request data, the format of the data expected by your model, and the format of the data returned to clients.

    Se os dados da solicitação estiverem em um formato que não pode ser usado pelo seu modelo, o script poderá transformá-lo em um formato aceitável.If the request data is in a format that is not usable by your model, the script can transform it into an acceptable format. Ele também pode transformar a resposta antes de retornar a ela para o cliente.It may also transform the response before returning to it to the client.

    Importante

    O SDK do Azure Machine Learning não fornece uma maneira de implantações de serviço Web ou de IoT Edge para acessar seu armazenamento de dados ou conjuntos.The Azure Machine Learning SDK does not provide a way for web service or IoT Edge deployments to access your datastore or data sets. Se você precisar que o modelo implantado acesse dados armazenados fora da implantação, como em uma conta de armazenamento do Azure, você deve desenvolver uma solução de código personalizado usando o SDK relevante.If you need the deployed model to access data stored outside the deployment, such as in an Azure Storage account, you must develop a custom code solution using the relevant SDK. Por exemplo, o SDK do armazenamento do Azure para Python.For example, the Azure Storage SDK for Python.

    Outra alternativa que pode funcionar para seu cenário é previsões de lote, que fornece acesso a repositórios de armazenamento durante a pontuação.Another alternative that may work for your scenario is batch predictions, which does provide access to datastores when scoring.

  • Dependências, como scripts auxiliares ou pacotes python/Conda necessários para executar o script ou modelo de entradaDependencies, such as helper scripts or Python/Conda packages required to run the entry script or model

  • A configuração de implantação para o destino de computação que hospeda o modelo implantado.The deployment configuration for the compute target that hosts the deployed model. Essa configuração descreve coisas como requisitos de memória e CPU necessários para executar o modelo.This configuration describes things like memory and CPU requirements needed to run the model.

Essas entidades são encapsuladas em uma __configuração__de inferência e uma configuração de implantação.These entities are encapsulated into an inference configuration, and a deployment configuration. A configuração de inferência referencia o script de entrada e outras dependências.The inference configuration references the entry script and other dependencies. Essas configurações são definidas programaticamente ao usar o SDK e como arquivos JSON ao usar a CLI para executar a implantação.These configurations are defined programmatically when using the SDK, and as JSON files when using the CLI to perform the deployment.

1. Definir o script de entrada & dependências1. Define your entry script & dependencies

O script de entrada recebe dados enviados para um serviço Web implantado e os transmite para o modelo.The entry script receives data submitted to a deployed web service, and passes it to the model. Em seguida, ele pega a resposta retornada pelo modelo e a retorna ao cliente.It then takes the response returned by the model and returns that to the client. O script é específico para seu modelo; Ele deve entender os dados esperados e retornados pelo modelo.The script is specific to your model; it must understand the data that the model expects and returns.

O script contém duas funções que carregam e executam o modelo:The script contains two functions that load and run the model:

  • init(): Normalmente, essa função carrega o modelo em um objeto global.init(): Typically this function loads the model into a global object. Essa função é executada apenas uma vez quando o contêiner do Docker para o serviço Web é iniciado.This function is run only once when the Docker container for your web service is started.

  • run(input_data): Essa função usa o modelo para prever um valor com base nos dados de entrada.run(input_data): This function uses the model to predict a value based on the input data. As entradas e saídas para a execução normalmente usam JSON para serialização e desserialização.Inputs and outputs to the run typically use JSON for serialization and de-serialization. Você também pode trabalhar com dados binários brutos.You can also work with raw binary data. Você pode transformar os dados antes de enviar para o modelo ou antes de retornar ao cliente.You can transform the data before sending to the model, or before returning to the client.

O que é o get_model_path?What is get_model_path?

Ao registrar um modelo, você fornece um nome de modelo usado para gerenciar o modelo no registro.When you register a model, you provide a model name used for managing the model in the registry. Use esse nome com o modelo. Obtenha _model_path () para recuperar o caminho dos arquivos de modelo no sistema de arquivos local.You use this name with the Model.get_model_path() to retrieve the path of the model file(s) on the local file system. Se você registrar uma pasta ou uma coleção de arquivos, essa API retornará o caminho para o diretório que contém esses arquivos.If you register a folder or a collection of files, this API returns the path to the directory that contains those files.

Ao registrar um modelo, você fornece um nome, que corresponde a onde o modelo é colocado, seja localmente ou durante a implantação do serviço.When you register a model, you give it a name, which corresponds to where the model is placed, either locally or during service deployment.

O exemplo abaixo retornará um caminho para um único arquivo chamado sklearn_mnist_model.pkl (que foi registrado com o nome sklearn_mnist):The below example will return a path to a single file called sklearn_mnist_model.pkl (which was registered with the name sklearn_mnist):

model_path = Model.get_model_path('sklearn_mnist')

Adicional Geração de esquema automática(Optional) Automatic schema generation

Para gerar automaticamente um esquema para o serviço Web, forneça um exemplo de entrada e/ou saída no construtor para um dos objetos de tipo definidos, e o tipo e o exemplo são usados para criar automaticamente o esquema.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, and the type and sample are used to automatically create the schema. Azure Machine Learning serviço, em seguida, cria uma especificação de openapi (Swagger) para o serviço Web durante a implantação.Azure Machine Learning service then creates an OpenAPI (Swagger) specification for the web service during deployment.

Atualmente, há suporte para os seguintes tipos:The following types are currently supported:

  • pandas
  • numpy
  • pyspark
  • objeto Python padrãostandard Python object

Para usar a geração de esquema, inference-schema inclua o pacote em seu arquivo de ambiente Conda.To use schema generation, include the inference-schema package in your conda environment file.

Arquivo de dependências de exemploExample dependencies file

O YAML a seguir é um exemplo de um arquivo de dependências Conda para inferência:The following YAML is an example of a Conda dependencies file for inference:

name: project_environment
dependencies:
  - python=3.6.2
  - pip:
    - azureml-defaults
    - scikit-learn==0.20.0
    - inference-schema[numpy-support]

Se você quiser usar a geração de esquema automática, seu script de entrada deverá inference-schema importar os pacotes.If you want to use automatic schema generation, your entry script must import the inference-schema packages.

Defina os formatos de exemplo de entrada e saída input_sample nas output_sample variáveis e, que representam os formatos de solicitação e resposta para o serviço Web.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. Use esses exemplos nos decoradores da função de entrada e saída na run() função.Use these samples in the input and output function decorators on the run() function. O exemplo scikit-Learn abaixo usa a geração de esquema.The scikit-learn example below uses schema generation.

Exemplo de script de entradaExample entry script

O exemplo a seguir demonstra como aceitar e retornar dados JSON:The following example demonstrates how to accept and return JSON data:

#example: scikit-learn and Swagger
import json
import numpy as np
from sklearn.externals import joblib
from sklearn.linear_model import Ridge
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


def init():
    global model
    # note here "sklearn_regression_model.pkl" is the name of the model registered under
    # this is a different behavior than before when the code is run locally, even though the code is the same.
    model_path = Model.get_model_path('sklearn_regression_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 datatype as long as it is JSON-serializable
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

O exemplo a seguir demonstra como definir os dados de entrada como <key: value> um dicionário, usando um dataframe.The following example demonstrates how to define the input data as a <key: value> dictionary, using a Dataframe. Esse método tem suporte para o consumo do serviço Web implantado do Power BI (saiba mais sobre como consumir o serviço Web do Power bi):This method is supported for consuming the deployed web service from Power BI (Learn more about how to consume the web service from Power BI):

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

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


def init():
    global model
    # replace model_name with your actual model name, if needed
    model_path = Model.get_model_path('model_name')
    # 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 a integer type sample. Use the data type that reflects this column in your data
    "input_name_3": 3
}])

# This is a 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 datatype as long as it is JSON-serializable
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

Para obter mais scripts de exemplo, consulte os exemplos a seguir:For more example scripts, see the following examples:

Dados bináriosBinary data

Se o seu modelo aceita dados binários, como uma imagem, tem de modificar o score.py ficheiro utilizado para a sua implementação para aceitar pedidos HTTP não processados.If your model accepts binary data, such as an image, you must modify the score.py file used for your deployment to accept raw HTTP requests. Para aceitar dados brutos, use AMLRequest a classe em seu script de entrada e @rawhttp adicione o decorador à run() função.To accept raw data, use the AMLRequest class in your entry script and add the @rawhttp decorator to the run() function.

Aqui está um exemplo de um score.py que aceita dados binários: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 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)

Importante

A AMLRequest classe está azureml.contrib no namespace.The AMLRequest class is in the azureml.contrib namespace. As coisas nesse namespace são alteradas com frequência enquanto trabalhamos para melhorar o serviço.Things in this namespace change frequently as we work to improve the service. Assim, qualquer coisa neste namespace deve ser considerada como uma versão prévia e não tem suporte total da Microsoft.As such, anything in this namespace should be considered as a preview, and not fully supported by Microsoft.

Se precisar testar isso em seu ambiente de desenvolvimento local, você poderá instalar os componentes usando o seguinte comando:If you need to test this on your local development environment, you can install the components by using the following command:

pip install azureml-contrib-services

CORS (compartilhamento de recursos entre origens)Cross-origin resource sharing (CORS)

O compartilhamento de recursos entre origens é uma maneira de permitir que recursos em uma página da Web sejam solicitados de outro domínio.Cross-origin resource sharing is a way to allow resources on a web page to be requested from another domain. O CORS funciona com base em cabeçalhos HTTP enviados com a solicitação do cliente e retornado com a resposta do serviço.CORS works based on HTTP headers sent with the client request and returned with the service response. Para obter mais informações sobre CORS e cabeçalhos válidos, consulte compartilhamento de recursos entre origens na Wikipédia.For more information on CORS and valid headers, see Cross-origin resource sharing on Wikipedia.

Para configurar sua implantação de modelo para dar suporte a CORS AMLResponse , use a classe em seu script de entrada.To configure your model deployment to support CORS, use the AMLResponse class in your entry script. Essa classe permite que você defina os cabeçalhos no objeto de resposta.This class allows you to set the headers on the response object.

O exemplo a seguir define Access-Control-Allow-Origin o cabeçalho para a resposta do script de entrada:The following example sets the Access-Control-Allow-Origin header for the response from the entry script:

from azureml.contrib.services.aml_response import AMLResponse

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

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

Importante

A AMLResponse classe está azureml.contrib no namespace.The AMLResponse class is in the azureml.contrib namespace. As coisas nesse namespace são alteradas com frequência enquanto trabalhamos para melhorar o serviço.Things in this namespace change frequently as we work to improve the service. Assim, qualquer coisa neste namespace deve ser considerada como uma versão prévia e não tem suporte total da Microsoft.As such, anything in this namespace should be considered as a preview, and not fully supported by Microsoft.

Se precisar testar isso em seu ambiente de desenvolvimento local, você poderá instalar os componentes usando o seguinte comando:If you need to test this on your local development environment, you can install the components by using the following command:

pip install azureml-contrib-services

2. Definir seu InferenceConfig2. Define your InferenceConfig

A configuração de inferência descreve como configurar o modelo para fazer previsões.The inference configuration describes how to configure the model to make predictions. Essa configuração não faz parte do seu script de entrada; Ele faz referência ao seu script de entrada e é usado para localizar todos os recursos exigidos pela implantação.This configuration is not part of your entry script; it references your entry script and is used to locate all the resources required by the deployment. Ele é usado mais tarde ao implantar o modelo de fato.It is used later when actually deploying the model.

O exemplo a seguir demonstra como criar uma configuração de inferência.The following example demonstrates how to create an inference configuration. Essa configuração especifica o tempo de execução, o script de entrada e (opcionalmente) o arquivo de ambiente Conda:This configuration specifies the runtime, the entry script, and (optionally) the conda environment file:

from azureml.core.model import InferenceConfig

inference_config = InferenceConfig(runtime="python",
                                   entry_script="x/y/score.py",
                                   conda_file="env/myenv.yml")

Para obter mais informações, consulte a referência de classe InferenceConfig .For more information, see the InferenceConfig class reference.

Para obter informações sobre como usar uma imagem personalizada do Docker com a configuração de inferência, consulte como implantar um modelo usando uma imagem personalizadado Docker.For information on using a custom Docker image with inference configuration, see How to deploy a model using a custom Docker image.

Exemplo de CLI de InferenceConfigCLI example of InferenceConfig

As entradas no inferenceconfig.json documento são mapeadas para os parâmetros da classe InferenceConfig .The entries in the inferenceconfig.json document map to the parameters for the InferenceConfig class. A tabela a seguir descreve o mapeamento entre entidades no documento JSON e os parâmetros para o método:The following table describes the mapping between entities in the JSON document and the parameters for the method:

Entidade JSONJSON entity Parâmetro do métodoMethod parameter DescriçãoDescription
entryScript entry_script Caminho para o arquivo local que contém o código a ser executado para a imagem.Path to local file that contains the code to run for the image.
runtime runtime Qual tempo de execução usar para a imagem.Which runtime to use for the image. Os tempos de execução com suporte atuais são ' Spark-py ' e ' Python '.Current supported runtimes are 'spark-py' and 'python'.
condaFile conda_file Opcional.Optional. Caminho para o arquivo local que contém uma definição de ambiente Conda a ser usada para a imagem.Path to local file containing a conda environment definition to use for the image.
extraDockerFileSteps extra_docker_file_steps Opcional.Optional. Caminho para o arquivo local que contém etapas adicionais do Docker a serem executadas durante a configuração da imagem.Path to local file containing additional Docker steps to run when setting up image.
sourceDirectory source_directory Opcional.Optional. Caminho para pastas que contém todos os arquivos para criar a imagem.Path to folders that contains all files to create the image.
enableGpu enable_gpu Opcional.Optional. Se o suporte à GPU deve ser habilitado na imagem.Whether to enable GPU support in the image. A imagem de GPU deve ser usada no serviço Microsoft Azure.The GPU image must be used on Microsoft Azure Service. Por exemplo, instâncias de contêiner do Azure, computação Azure Machine Learning, máquinas virtuais do Azure e serviço kubernetes do Azure.For example, Azure Container Instances, Azure Machine Learning Compute, Azure Virtual Machines, and Azure Kubernetes Service. O padrão é false.Defaults to False.
baseImage base_image Opcional.Optional. Uma imagem personalizada a ser usada como imagem base.A custom image to be used as base image. Se nenhuma imagem base for fornecida, a imagem base será usada com base em um determinado parâmetro de tempo de execução.If no base image is given, then the base image will be used based off of given runtime parameter.
baseImageRegistry base_image_registry Opcional.Optional. Registro de imagem que contém a imagem base.Image registry that contains the base image.
cudaVersion cuda_version Opcional.Optional. Versão do CUDA a ser instalada para imagens que precisam de suporte à GPU.Version of CUDA to install for images that need GPU support. A imagem de GPU deve ser usada em serviços de Microsoft Azure.The GPU image must be used on Microsoft Azure Services. Por exemplo, instâncias de contêiner do Azure, computação Azure Machine Learning, máquinas virtuais do Azure e serviço kubernetes do Azure.For example, Azure Container Instances, Azure Machine Learning Compute, Azure Virtual Machines, and Azure Kubernetes Service. As versões com suporte são 9,0, 9,1 e 10,0.Supported versions are 9.0, 9.1, and 10.0. Se ' enable_gpu ' for definido, o padrão será ' 9,1 '.If 'enable_gpu' is set, defaults to '9.1'.
description description Uma descrição para esta imagem.A description for this image.

O JSON a seguir é uma configuração de inferência de exemplo para uso com a CLI:The following JSON is an example inference configuration for use with the CLI:

{
    "entryScript": "score.py",
    "runtime": "python",
    "condaFile": "myenv.yml",
    "extraDockerfileSteps": null,
    "sourceDirectory": null,
    "enableGpu": false,
    "baseImage": null,
    "baseImageRegistry": null
}

O comando a seguir demonstra como implantar um modelo usando a CLI:The following command demonstrates how to deploy a model using the CLI:

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

Neste exemplo, a configuração contém os seguintes itens:In this example, the configuration contains the following items:

  • Que este modelo requer PythonThat this model requires Python
  • O script de entrada, que é usado para manipular solicitações da Web enviadas ao serviço implantadoThe entry script, which is used to handle web requests sent to the deployed service
  • O arquivo Conda que descreve os pacotes do python necessários para a inferênciaThe conda file that describes the Python packages needed to inference

Para obter informações sobre como usar uma imagem personalizada do Docker com a configuração de inferência, consulte como implantar um modelo usando uma imagem personalizadado Docker.For information on using a custom Docker image with inference configuration, see How to deploy a model using a custom Docker image.

3. Definir sua configuração de implantação3. Define your Deployment configuration

Antes de implantar o, você deve definir a configuração de implantação.Before deploying, you must define the deployment configuration. A configuração de implantação é específica para o destino de computação que hospedará o serviço Web.The deployment configuration is specific to the compute target that will host the web service. Por exemplo, ao implantar localmente, você deve especificar a porta onde o serviço aceita solicitações.For example, when deploying locally you must specify the port where the service accepts requests. A configuração de implantação não faz parte do seu script de entrada.The deployment configuration is not part of your entry script. Ele é usado para definir as características do destino de computação que hospedará o modelo e o script de entrada.It is used to define the characteristics of the compute target that will host the model and entry script.

Talvez você também precise criar o recurso de computação.You may also need to create the compute resource. Por exemplo, se você ainda não tiver um serviço kubernetes do Azure associado ao seu espaço de trabalho.For example, if you do not already have an Azure Kubernetes Service associated with your workspace.

A tabela a seguir fornece um exemplo de criação de uma configuração de implantação para cada destino de computação:The following table provides an example of creating a deployment configuration for each compute target:

Destino de computaçãoCompute target Exemplo de configuração de implantaçãoDeployment configuration example
LocalizaçãoLocal deployment_config = LocalWebservice.deploy_configuration(port=8890)
Instância de Contentor do AzureAzure Container Instance deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)
Serviço Kubernetes do AzureAzure Kubernetes Service deployment_config = AksWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)

Cada uma dessas classes para serviços Web locais, ACI e AKS podem ser importadas azureml.core.webservicede:Each of these classes for local, ACI, and AKS web services can be imported from azureml.core.webservice:

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

Dica

Antes de implantar seu modelo como um serviço, talvez você queira criar um perfil para determinar os requisitos de CPU e memória ideais.Prior to deploying your model as a service, you may want to profile it to determine optimal CPU and memory requirements. Você pode criar um perfil de seu modelo usando o SDK ou a CLI.You can profile your model using either the SDK or CLI. Para obter mais informações, consulte a referência de perfil de modelo de perfil () e AZ ml .For more information, see the profile() and az ml model profile reference.

Os resultados de criação de perfil de modelo são Run emitidos como um objeto.Model profiling results are emitted as a Run object. Para obter mais informações, consulte a referência de classe ModelProfile .For more information, see the ModelProfile class reference.

Implantar no destinoDeploy to target

A implantação usa a configuração de implantação de configuração de inferência para implantar os modelos.Deployment uses the inference configuration deployment configuration to deploy the models. O processo de implantação é semelhante, independentemente do destino de computação.The deployment process is similar regardless of the compute target. Implantar em AKS é ligeiramente diferente, pois você deve fornecer uma referência ao cluster AKS.Deploying to AKS is slightly different, as you must provide a reference to the AKS cluster.

Implantação localLocal deployment

Para implantar localmente, você precisa ter o Docker instalado no computador local.To deploy locally, you need to have Docker installed on your local machine.

Utilizar o SDKUsing the SDK

from azureml.core.webservice import LocalWebservice, Webservice

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

Para obter mais informações, consulte a documentação de referência para LocalWebservice, Model. Deployment ()e WebService.For more information, see the reference documentation for LocalWebservice, Model.deploy(), and Webservice.

Usando a CLIUsing the CLI

Para implantar usando a CLI, use o comando a seguir.To deploy using the CLI, use the following command. Substituir mymodel:1 pelo nome e versão do modelo registrado: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

As entradas no deploymentconfig.json documento são mapeadas para os parâmetros de LocalWebservice. deploy_configuration.The entries in the deploymentconfig.json document map to the parameters for LocalWebservice.deploy_configuration. A tabela a seguir descreve o mapeamento entre as entidades no documento JSON e os parâmetros para o método:The following table describes the mapping between the entities in the JSON document and the parameters for the method:

Entidade JSONJSON entity Parâmetro do métodoMethod parameter DescriçãoDescription
computeType NDNA O destino de computação.The compute target. Para local, o valor deve ser local.For local, the value must be local.
port port A porta local na qual expor o ponto de extremidade HTTP do serviço.The local port on which to expose the service's HTTP endpoint.

O JSON a seguir é um exemplo de configuração de implantação para uso com a CLI:The following JSON is an example deployment configuration for use with the CLI:

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

Para obter mais informações, consulte a referência de implantação do modelo AZ ml .For more information, see the az ml model deploy reference.

Serviço Web NotebookVM (DEVTEST)NotebookVM web service (DEVTEST)

Consulte implantar um modelo para VMs de notebook.See Deploy a model to Notebook VMs.

DEVTEST (instâncias de contêiner do Azure)Azure Container Instances (DEVTEST)

Consulte implantar em instâncias de contêiner do Azure.See Deploy to Azure Container Instances.

Serviço kubernetes do Azure (DEVTEST & produção)Azure Kubernetes Service (DEVTEST & PRODUCTION)

Consulte implantar no serviço kubernetes do Azure.See Deploy to Azure Kubernetes Service.

Consumir os serviços webConsume web services

Cada serviço Web implantado fornece uma API REST, para que você possa criar aplicativos cliente em uma variedade de linguagens de programação.Every deployed web service provides a REST API, so you can create client applications in a variety of programming languages. Se você habilitou a autenticação de chave para seu serviço, precisará fornecer uma chave de serviço como um token no cabeçalho da solicitação.If you have enabled key authentication for your service, you need to provide a service key as a token in your request header. Se você tiver habilitado a autenticação de token para seu serviço, será necessário fornecer um token Azure Machine Learning JWT como um token de portador no cabeçalho da solicitação.If you have enabled token authentication for your service, you need to provide an Azure Machine Learning JWT token as a bearer token in your request header.

Dica

Você pode recuperar o documento JSON do esquema depois de implantar o serviço.You can retrieve the schema JSON document after deploying the service. Use a Propriedade swagger_uri do serviço Web implantado, service.swagger_uricomo, para obter o URI para o arquivo Swagger do serviço Web local.Use the swagger_uri property from the deployed web service, such as service.swagger_uri, to get the URI to the local web service's Swagger file.

Consumo de solicitação-respostaRequest-response consumption

Aqui está um exemplo de como invocar seu serviço no Python:Here is 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())

Para obter mais informações, consulte criar aplicativos cliente para consumir WebServices.For more information, see Create client applications to consume webservices.

Esquema de serviço Web (especificação OpenAPI)Web service schema (OpenAPI specification)

Se você usou a geração de esquema automática com a implantação, você pode obter o endereço da especificação OpenAPI para o serviço usando a Propriedade swagger_uri.If you used the automatic schema generation with the deployment, you can get the address of the OpenAPI specification for the service by using the swagger_uri property. Por exemplo, print(service.swagger_uri).For example, print(service.swagger_uri). Use uma solicitação GET (ou abra o URI em um navegador) para recuperar a especificação.Use a GET request (or open the URI in a browser) to retrieve the specification.

O documento JSON a seguir é um exemplo de um esquema (especificação de OpenAPI) gerado para uma implantação: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 the Azure Machine Learning service 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"
                }
            }
        }
    }
}

Para obter mais informações sobre a especificação, consulte a especificação da API aberta.For more information on the specification, see the Open API specification.

Para um utilitário que pode criar bibliotecas de cliente a partir da especificação, consulte Swagger-CodeGen.For a utility that can create client libraries from the specification, see swagger-codegen.

Inferência de loteBatch inference

Azure Machine Learning destinos de computação são criados e gerenciados pelo serviço de Azure Machine Learning.Azure Machine Learning Compute targets are created and managed by the Azure Machine Learning service. Eles podem ser usados para previsão de lote de pipelines de Azure Machine Learning.They can be used for batch prediction from Azure Machine Learning Pipelines.

Para obter uma explicação sobre a inferência de lote com Azure Machine Learning computação, leia o artigo como executar previsões de lote .For a walkthrough of batch inference with Azure Machine Learning Compute, read the How to Run Batch Predictions article.

Inferência de IoT EdgeIoT Edge inference

O suporte para a implantação no Edge está em versão prévia.Support for deploying to the edge is in preview. Para obter mais informações, consulte o artigo implantar Azure Machine Learning como um módulo IOT Edge .For more information, see the Deploy Azure Machine Learning as an IoT Edge module article.

Atualizar serviços WebUpdate web services

Ao criar um novo modelo, você deve atualizar manualmente cada serviço do qual deseja usar o novo modelo.When you create a new model, you must manually update each service that you want to use the new model. Para atualizar o serviço web, utilize o update método.To update the web service, use the update method. O código a seguir demonstra como usar o SDK para atualizar o modelo para um serviço Web:The following code demonstrates how to use the SDK to update the model for a web service:

from azureml.core.webservice import Webservice
from azureml.core.model import Model

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

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

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

Você também pode atualizar um serviço Web usando a CLI do ML.You can also update a web service using the ML CLI. O exemplo a seguir demonstra como registrar um novo modelo e, em seguida, atualizar o serviço Web para usar o novo modelo:The following example demonstrates registering a new model, and then updating 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

Dica

Neste exemplo, um documento JSON é usado para passar as informações do modelo do comando de registro para o comando Update.In this example, a JSON document is used to pass the model information from the registration command into the update command.

Implantação de modelo contínuaContinuous model deployment

Você pode implantar modelos continuamente usando a extensão Machine Learning para o Azure DevOps.You can continuously deploy models using the Machine Learning extension for Azure DevOps. Usando a extensão de Machine Learning para DevOps do Azure, você pode disparar um pipeline de implantação quando um novo modelo de aprendizado de máquina é registrado no espaço de trabalho Azure Machine Learning serviço.By using the Machine Learning extension for Azure DevOps, you can trigger a deployment pipeline when a new machine learning model is registered in Azure Machine Learning service workspace.

  1. Inscreva-se para Azure pipelines, o que torna a integração contínua e a entrega de seu aplicativo a qualquer plataforma/qualquer nuvem possível.Sign up for Azure Pipelines, which makes continuous integration and delivery of your application to any platform/any cloud possible. Azure Pipelines difere dos pipelines ml.Azure Pipelines differs from ML pipelines.

  2. Crie um projeto DevOps do Azure.Create an Azure DevOps project.

  3. Instalar a extensão de Machine Learning para Azure pipelinesInstall the Machine Learning extension for Azure Pipelines

  4. Use conexões de serviço para configurar uma conexão de entidade de serviço com o espaço de trabalho do Azure Machine Learning Service para acessar todos os seus artefatos.Use service Connections to set up a service principal connection to your Azure Machine Learning service workspace to access all your artifacts. Vá para configurações do projeto, clique em conexões de serviço e selecione Azure Resource Manager.Go to project settings, click on service connections, and select Azure Resource Manager.

    view-service-connection

  5. Defina AzureMLWorkspace como o nível de escopo e preencha os parâmetros subsequentes.Define AzureMLWorkspace as the scope level and fill in the subsequent parameters.

    view-azure-resource-manager

  6. Em seguida, para implantar continuamente o modelo de aprendizado de máquina usando o Azure Pipelines, em pipelines, selecione liberar.Next, to continuously deploy your machine learning model using the Azure Pipelines, under pipelines select release. Adicione um novo artefato, selecione artefato do modelo do AzureML e a conexão de serviço que foi criada na etapa anterior.Add a new artifact, select AzureML Model artifact and the service connection that was created in the earlier step. Selecione o modelo e a versão para disparar uma implantação.Select the model and version to trigger a deployment.

    select-AzureMLmodel-artifact

  7. Habilite o gatilho de modelo em seu artefato de modelo.Enable the model trigger on your model artifact. Ativando o gatilho, toda vez que a versão especificada (ou seja,By turning on the trigger, every time the specified version (i.e a versão mais recente) desse modelo é registrar em seu espaço de trabalho, um pipeline de versão do Azure DevOps é disparado.the newest version) of that model is register in your workspace, an Azure DevOps release pipeline is triggered.

    enable-model-trigger

Para obter mais exemplos e projetos de exemplo, consulte o seguinte exemplo de repositórios:For more sample projects and examples, see the following sample repos:

Limpar recursosClean up resources

Para eliminar um serviço web implementado, utilize service.delete().To delete a deployed web service, use service.delete(). Para eliminar um modelo registado, utilize model.delete().To delete a registered model, use model.delete().

Para obter mais informações, consulte a documentação de referência para WebService. Delete ()e Model. Delete ().For more information, see the reference documentation for WebService.delete(), and Model.delete().

Passos seguintesNext steps