Implantar modelos com Azure Machine LearningDeploy models with Azure Machine Learning

APLICA-SE A: simedição Basic simedição Enterprise                    (Atualizar para a edição Enterprise)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

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

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

  1. Registre o modelo.Register the model.
  2. Prepare-se para implantar.Prepare to deploy. (Especifique ativos, uso e destino de computação.)(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 a 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 Azure Machine Learning.For more information on the concepts involved in the deployment workflow, see Manage, deploy, and monitor models with Azure Machine Learning.

Pré-requisitosPrerequisites

Conectar-se ao workspaceConnect to your workspace

O código a seguir mostra como se conectar a um espaço de trabalho Azure Machine Learning usando informações armazenadas em cache para o ambiente de desenvolvimento local:The following code shows how to connect to an Azure Machine Learning workspace by 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 a documentação Azure Machine Learning SDK para Python .For more information on using the SDK to connect to a workspace, see the Azure Machine Learning SDK for Python documentation.

  • Usando a CLIUsing the CLI

    Ao usar a CLI, use o parâmetro -w ou --workspace-name 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, você seleciona o espaço de trabalho usando uma interface gráfica.When you use VS Code, you select the workspace by 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's stored in multiple files, you can register them as a single model in the workspace. Depois de registrar os arquivos, você pode baixar ou implantar o modelo registrado e receber todos os arquivos que você registrou.After you register the files, you can then download or deploy the registered model and receive all the files that you registered.

Dica

Ao registrar um modelo, você fornece o caminho de um local de nuvem (de uma execução de treinamento) ou um diretório local.When you register a model, you provide the path of either 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.This path is just to locate the files for upload as part of the registration process. Ele não precisa corresponder ao caminho usado no script de entrada.It doesn't need to match the path used in the entry script. Para obter mais informações, consulte Localizar arquivos de modelo em seu script de entrada.For more information, see Locate model files in your entry script.

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 de outro lugar.The model can come from Azure Machine Learning or 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 como registrar um modelo de uma execução de treinamento:The code snippets in this section demonstrate how to register a model from a training run:

Importante

Para usar esses trechos de código, você precisa ter executado anteriormente uma execução de treinamento e precisa ter acesso ao objeto de Run (exemplo de SDK) ou ao valor da ID de execução (exemplo de CLI).To use these snippets, you need to have previously performed a training run and you need to have access to the Run object (SDK example) or the run ID value (CLI example). Para obter mais informações sobre modelos de treinamento, consulte Configurar destinos de computação para treinamento de modelo.For more information on training models, see Set up compute targets for model training.

  • Usando o SDKUsing the SDK

    Ao usar o SDK para treinar um modelo, você pode receber um objeto de execução ou um objeto AutoMLRun , dependendo de como você treinou o modelo.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. Cada objeto pode ser usado para registrar um modelo criado por uma execução de experimento.Each object can be used to register a model created by an experiment run.

    • Registrar um modelo de um objeto azureml.core.Run:Register a model from an azureml.core.Run object:

      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 parâmetro model_path refere-se ao local da nuvem do modelo.The model_path parameter refers to the cloud location of the model. Neste exemplo, o caminho de um único arquivo é usado.In this example, the path of a single file is used. Para incluir vários arquivos no registro do modelo, defina model_path como o caminho de uma pasta que contém os arquivos.To include multiple files in the model registration, set model_path to the path of a folder that contains the files. Para obter mais informações, consulte a documentação executar. register_model .For more information, see the Run.register_model documentation.

    • Registrar um modelo de um objeto azureml.train.automl.run.AutoMLRun:Register a model from an azureml.train.automl.run.AutoMLRun object:

          description = 'My AutoML Model'
          model = run.register_model(description = description)
      
          print(run.model_id)
      

      Neste exemplo, os parâmetros metric e iteration não são especificados, portanto, a iteração com a melhor métrica primária será registrada.In this example, the metric and iteration parameters aren't specified, so the iteration with the best primary metric will be registered. O valor de model_id retornado da execução é usado em vez de um nome de modelo.The model_id value returned from the run is used instead of a model name.

      Para obter mais informações, consulte a documentação do AutoMLRun. register_model .For more information, see the AutoMLRun.register_model documentation.

  • 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 uma mensagem de erro informando que a extensão ml não está instalada, use o seguinte comando para instalá-la: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
    

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

  • Usando VS CodeUsing VS Code

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

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

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

Importante

Você deve usar apenas os modelos que criar ou obter de uma fonte confiável.You should use only models that you create or obtain from a trusted source. Você deve tratar modelos serializados como código, pois as vulnerabilidades de segurança foram descobertas em vários formatos populares.You should treat serialized models as code, because 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.Also, models might be intentionally trained with malicious intent to provide biased or inaccurate output.

  • Usando o SDK e o ONNXUsing the SDK and ONNX

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

    Para incluir vários arquivos no registro do modelo, defina model_path como o caminho de uma pasta que contém os arquivos.To include multiple files in the model registration, set model_path to the path of a folder 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 como o caminho de uma pasta que contém os arquivos.To include multiple files in the model registration, set -p to the path of a folder that contains the files.

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

Para obter mais informações, consulte a documentação da classe Model.For more information, see the documentation for the Model class.

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

Escolher um destino de computaçãoChoose a compute target

Você pode usar os seguintes destinos de computação ou recursos de computação para hospedar a implantação do serviço Web:You can use the following compute targets, or compute resources, to host your web service deployment:

Destino de computaçãoCompute target Usado paraUsed for Suporte de GPUGPU support Suporte do FPGAFPGA support DescriçãoDescription
Serviço de da Web localLocal web service Teste/depuraçãoTesting/debugging     Use para teste e solução de problemas limitados.Use for limited testing and troubleshooting. A aceleração de hardware depende do uso de bibliotecas no sistema local.Hardware acceleration depends on use of libraries in the local system.
Azure Machine Learning instância de computação serviço Web Azure Machine Learning compute instance web service Teste/depuraçãoTesting/debugging     Use para teste e solução de problemas limitados.Use for limited testing and troubleshooting.
AKS (Serviço de Kubernetes do Azure)Azure Kubernetes Service (AKS) Inferência em tempo realReal-time inference Sim (implantação de serviço Web)Yes (web service deployment) SimYes Use para implantações de produção de grande escala.Use 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 isn't 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 o designer.AKS is the only option available for the designer.
Instâncias de Contêiner do AzureAzure Container Instances Teste ou desenvolvimentoTesting or development     Use para cargas de trabalho baseadas em CPU de baixa escala que exigem menos de 48 GB de RAM.Use for low-scale CPU-based workloads that require less than 48 GB of RAM.
Azure Machine Learning clusters de computaçãoAzure Machine Learning compute clusters Apresentação Inferência de do lote(Preview) Batch inference Sim (pipeline de Machine Learning)Yes (machine learning pipeline)   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.
Funções do AzureAzure Functions Apresentação Inferência em tempo real(Preview) Real-time inference      
Azure IoT EdgeAzure IoT Edge Apresentação Módulo de de IoT(Preview) IoT module     Implante e sirva modelos de ML em dispositivos IoT.Deploy and serve ML models on IoT devices.
Borda da caixa de dados do AzureAzure Data Box Edge Via IoT EdgeVia IoT Edge   SIMYes Implante e sirva modelos de ML em dispositivos IoT.Deploy and serve ML models on IoT devices.

Observação

Embora os destinos de computação, como local, Azure Machine Learning instância de computação, e Azure Machine Learning clusters de computação ofereçam suporte à GPU para treinamento e experimentação, usar GPU para inferência quando implantado como um serviço Web tem suporte apenas no serviço kubernetes do Azure.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.

Usar uma GPU para inferência quando a pontuação com um pipeline de aprendizado de máquina tem suporte apenas em Azure Machine Learning computação.Using a GPU for inference when scoring with a machine learning pipeline is supported only on Azure Machine Learning Compute.

Preparar-se para implantarPrepare to deploy

Para implantar o modelo, você precisa dos seguintes itens:To deploy the model, you need the following items:

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

    Importante

    • O script de entrada é específico para seu modelo.The entry script is specific to your model. 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.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's not usable by your model, the script can transform it into an acceptable format. Ele também pode transformar a resposta antes de retorná-la ao cliente.It can also transform the response before returning it to the client.

    • O SDK do Azure Machine Learning não fornece uma maneira para serviços Web ou implantações de IoT Edge para acessar seu armazenamento de dados ou conjuntos de dados.The Azure Machine Learning SDK doesn't provide a way for web services or IoT Edge deployments to access your data store or datasets. Se o modelo implantado precisar acessar dados armazenados fora da implantação, como dados em uma conta de armazenamento do Azure, você deverá desenvolver uma solução de código personalizada usando o SDK relevante.If your deployed model needs to access data stored outside the deployment, like data in an Azure storage account, you must develop a custom code solution by using the relevant SDK. Por exemplo, o SDK do armazenamento do Azure para Python.For example, the Azure Storage SDK for Python.

      Uma alternativa que pode funcionar para seu cenário é a previsão de lote, que fornece acesso a armazenamentos de dados durante a pontuação.An alternative that might work for your scenario is batch prediction, which does provide access to data stores during scoring.

  • Dependências, como scripts auxiliares ou pacotes python/Conda necessários para executar o script ou modelo de entrada.Dependencies, like 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.

Esses itens são encapsulados em uma configuração de inferência e uma configuração de implantação.These items 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. Você define essas configurações programaticamente ao usar o SDK para executar a implantação.You define these configurations programmatically when you use the SDK to perform the deployment. Você os define em arquivos JSON ao usar a CLI.You define them in JSON files when you use the CLI.

1. definir seu script de entrada e dependências1. Define your entry script and 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. Ele então envia de volta ao cliente a resposta retornada pelo modelo.It then takes the response returned by the model and returns that to the client. O script é específico para seu modelo.The script is specific to your model. Ele deve entender os dados esperados e retornados pelo modelo.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 da execução normalmente usam JSON para serialização e desserialização.Inputs and outputs of the run typically use JSON for serialization and deserialization. Você também pode trabalhar com os dados binários brutos.You can also work with raw binary data. Você pode transformar os dados antes de enviá-los para o modelo ou antes de retorná-los para o cliente.You can transform the data before sending it to the model or before returning it to the client.

Localizar arquivos de modelo em seu script de entradaLocate model files in your entry script

Há duas maneiras de localizar modelos em seu script de entrada:There are two ways to locate models in your entry script:

  • AZUREML_MODEL_DIR: uma variável de ambiente que contém o caminho para o local do modelo.AZUREML_MODEL_DIR: An environment variable containing the path to the model location.
  • Model.get_model_path: uma API que retorna o caminho para o arquivo de modelo usando o nome do modelo registrado.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 é uma variável de ambiente criada durante a implantação do serviço.AZUREML_MODEL_DIR is an environment variable created during service deployment. Você pode usar essa variável de ambiente para localizar o local dos modelos implantados.You can use this environment variable to find the location of the deployed model(s).

A tabela a seguir descreve o valor de AZUREML_MODEL_DIR dependendo do número de modelos implantados:The following table describes the value of AZUREML_MODEL_DIR depending on the number of models deployed:

ImplantaçãoDeployment Valor da variável de ambienteEnvironment variable value
Modelo únicoSingle model O caminho para a pasta que contém o modelo.The path to the folder containing the model.
Vários modelosMultiple models O caminho para a pasta que contém todos os modelos.The path to the folder containing all models. Os modelos estão localizados por nome e versão nesta pasta ($MODEL_NAME/$VERSION)Models are located by name and version in this folder ($MODEL_NAME/$VERSION)

Para obter o caminho para um arquivo em um modelo, combine a variável de ambiente com o nome de o arquivo que você está procurando.To get the path to a file in a model, combine the environment variable with the filename you're looking for. Os nomes de arquivo dos arquivos de modelo são preservados durante o registro e a implantação.The filenames of the model files are preserved during registration and deployment.

Exemplo de modelo únicoSingle model example

model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_regression_model.pkl')

Exemplo de vários modelosMultiple model example

model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_model/1/sklearn_regression_model.pkl')
get_model_pathget_model_path

Ao registrar um modelo, você fornece um nome de modelo que é usado para gerenciar o modelo no registro.When you register a model, you provide a model name that's used for managing the model in the registry. Use esse nome com o método Model. get_model_path () para recuperar o caminho do arquivo de modelo ou arquivos no sistema de arquivos local.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. Se você registrar uma pasta ou uma coleção de arquivos, essa API retornará o caminho do diretório que contém esses arquivos.If you register a folder or a collection of files, this API returns the path of the directory that contains those files.

Ao registrar um modelo, você lhe dá um nome.When you register a model, you give it a name. O nome corresponde ao local em que o modelo é colocado, seja localmente ou durante a implantação do serviço.The name corresponds to where the model is placed, either locally or during service deployment.

Importante

Se você usou o Machine Learning automatizado para treinar um modelo, um valor model_id é usado como o nome do modelo.If you used automated machine learning to train a model, a model_id value is used as the model name. Para obter um exemplo de registro e implantação de um modelo treinado com o Machine Learning automatizado, consulte Azure/MachineLearningNotebooks no github.For an example of registering and deploying a model trained with automated machine learning, see Azure/MachineLearningNotebooks on GitHub.

O exemplo a seguir retornará um caminho para um único arquivo chamado sklearn_mnist_model.pkl (que foi registrado com o nome sklearn_mnist):The following 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.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. O tipo e o exemplo são usados para criar automaticamente o esquema.The type and sample are used to automatically create the schema. Azure Machine Learning, em seguida, cria uma especificação de openapi (Swagger) para o serviço Web durante a implantação.Azure Machine Learning then creates an OpenAPI (Swagger) specification for the web service during deployment.

Atualmente, esses tipos têm suporte:These types are currently supported:

  • pandas
  • numpy
  • pyspark
  • Objeto Python padrãoStandard Python object

Para usar a geração de esquema, inclua o pacote de inference-schema em seu arquivo de ambiente Conda.To use schema generation, include the inference-schema package in your Conda environment file. Para obter mais informações sobre este pacote, consulte https://github.com/Azure/InferenceSchema.For more information on this package, see https://github.com/Azure/InferenceSchema.

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
  - scikit-learn=0.20.0
  - pip:
    - azureml-defaults
    - inference-schema[numpy-support]

Importante

Se sua dependência estiver disponível por meio de Conda e PIP (de PyPi), a Microsoft recomenda usar a versão Conda, já que os pacotes Conda normalmente são fornecidos com binários pré-criados que tornam a instalação mais confiável.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.

Para obter mais informações, consulte Understanding Conda and Pip.For more information, see Understanding Conda and Pip.

Para verificar se sua dependência está disponível por meio do Conda, use o comando conda search <package-name> ou use os índices de pacote em https://anaconda.org/anaconda/repo e https://anaconda.org/conda-forge/repo.To check if your dependency is available through Conda, use the conda search <package-name> command, or use the package indexes at https://anaconda.org/anaconda/repo and https://anaconda.org/conda-forge/repo.

Se você quiser usar a geração de esquema automática, seu script de entrada deverá importar os pacotes de inference-schema.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 nas variáveis input_sample e output_sample, 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 função run().Use these samples in the input and output function decorators on the run() function. O exemplo a seguir scikit-Learn usa a geração de esquema.The following scikit-learn example 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
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

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

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

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


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


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

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


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

Para obter mais exemplos, consulte os seguintes scripts:For more examples, see the following scripts:

Dados bináriosBinary data

Se o modelo aceitar dados binários, como uma imagem, você deverá modificar o arquivo de score.py usado para sua implantação para aceitar solicitações HTTP brutas.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. Para aceitar dados brutos, use a classe AMLRequest em seu script de entrada e adicione o decorador de @rawhttp à função run().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 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)

Importante

A classe AMLRequest está no namespace azureml.contrib.The AMLRequest class is in the azureml.contrib namespace. As entidades neste namespace são alteradas com frequência enquanto trabalhamos para melhorar o serviço.Entities in this namespace change frequently as we work to improve the service. Qualquer coisa neste namespace deve ser considerada uma versão prévia que não tem suporte total da Microsoft.Anything in this namespace should be considered a preview that's 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 in 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 por meio de cabeçalhos HTTP enviados com a solicitação do cliente e retornado com a resposta do serviço.CORS works via 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 in Wikipedia.

Para configurar sua implantação de modelo para dar suporte a CORS, use a classe AMLResponse 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 o cabeçalho Access-Control-Allow-Origin 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 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)

Importante

A classe AMLResponse está no namespace azureml.contrib.The AMLResponse class is in the azureml.contrib namespace. As entidades neste namespace são alteradas com frequência enquanto trabalhamos para melhorar o serviço.Entities in this namespace change frequently as we work to improve the service. Qualquer coisa neste namespace deve ser considerada uma versão prévia que não tem suporte total da Microsoft.Anything in this namespace should be considered a preview that's 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 in 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.This configuration isn't part of your entry script. Ele faz referência ao seu script de entrada e é usado para localizar todos os recursos exigidos pela implantação.It references your entry script and is used to locate all the resources required by the deployment. Ele é usado posteriormente, quando você implanta o modelo.It's used later, when you deploy the model.

A configuração de inferência pode usar ambientes Azure Machine Learning para definir as dependências de software necessárias para sua implantação.Inference configuration can use Azure Machine Learning environments to define the software dependencies needed for your deployment. Os ambientes permitem que você crie, gerencie e reutilize as dependências de software necessárias para treinamento e implantação.Environments allow you to create, manage, and reuse the software dependencies required for training and deployment. O exemplo a seguir demonstra como carregar um ambiente do seu espaço de trabalho e usá-lo com a configuração de inferência:The following example demonstrates loading an environment from your workspace and then using it with the inference configuration:

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

deploy_env = Environment.get(workspace=ws,name="myenv",version="1")
inference_config = InferenceConfig(entry_script="x/y/score.py",
                                   environment=deploy_env)

Para obter mais informações sobre ambientes, consulte criar e gerenciar ambientes para treinamento e implantação.For more information on environments, see Create and manage environments for training and deployment.

Você também pode especificar diretamente as dependências sem usar um ambiente.You can also directly specify the dependencies without using an environment. O exemplo a seguir demonstra como criar uma configuração de inferência que carrega as dependências de software de um arquivo Conda:The following example demonstrates how to create an inference configuration that loads software dependencies from a Conda 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 documentação da classe InferenceConfig .For more information, see the InferenceConfig class documentation.

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

Exemplo de CLI de InferenceConfigCLI example of InferenceConfig

As entradas no documento inferenceconfig.json 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 um arquivo local que contém o código a ser executado para a imagem.Path to a local file that contains the code to run for the image.
runtime runtime Opcional.Optional. 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. Se environment for definido, isso será ignorado.If environment is set, this gets ignored.
condaFile conda_file Opcional.Optional. Caminho para um arquivo local que contém uma definição de ambiente Conda a ser usada para a imagem.Path to a local file that contains a Conda environment definition to use for the image. Se environment for definido, isso será ignorado.If environment is set, this gets ignored.
extraDockerFileSteps extra_docker_file_steps Opcional.Optional. Caminho para um arquivo local que contém etapas adicionais do Docker para executar ao configurar a imagem.Path to a local file that contains additional Docker steps to run when setting up the image. Se environment for definido, isso será ignorado.If environment is set, this gets ignored.
sourceDirectory source_directory Opcional.Optional. Caminho para pastas que contêm todos os arquivos para criar a imagem.Path to folders that contain 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 GPU deve ser usada em um serviço do Azure, como instâncias de contêiner do Azure, Azure Machine Learning computação, máquinas virtuais do Azure e serviço kubernetes do Azure.The GPU image must be used on an Azure service, like Azure Container Instances, Azure Machine Learning Compute, Azure Virtual Machines, and Azure Kubernetes Service. O padrão é falso.The default is False. Se environment for definido, isso será ignorado.If environment is set, this gets ignored.
baseImage base_image Opcional.Optional. Imagem personalizada a ser usada como uma imagem de base.Custom image to be used as a base image. Se nenhuma imagem base for fornecida, a imagem será baseada no parâmetro de tempo de execução fornecido.If no base image is provided, the image will be based on the provided runtime parameter. Se environment for definido, isso será ignorado.If environment is set, this gets ignored.
baseImageRegistry base_image_registry Opcional.Optional. Registro de imagem que contém a imagem base.Image registry that contains the base image. Se environment for definido, isso será ignorado.If environment is set, this gets ignored.
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 GPU deve ser usada em um serviço do Azure, como instâncias de contêiner do Azure, Azure Machine Learning computação, máquinas virtuais do Azure e serviço kubernetes do Azure.The GPU image must be used on an Azure service, like 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, the default is 9.1. Se environment for definido, isso será ignorado.If environment is set, this gets ignored.
description description Uma descrição para a imagem.A description for the image. Se environment for definido, isso será ignorado.If environment is set, this gets ignored.
environment environment Opcional.Optional. Azure Machine Learning ambiente.Azure Machine Learning environment.

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 JSON a seguir é um exemplo de configuração de inferência que usa um ambiente de Azure Machine Learning existente com uma versão específica para uso com a CLI:The following JSON is an example inference configuration that uses an existing Azure Machine Learning environment with a specific version for use with the CLI:

{
    "entryScript": "score.py",
    "environment":{
        "name": "myenv",
        "version": "1"
    },
    "condaFile": "myenv.yml",
    "sourceDirectory": null
}

O JSON a seguir é uma configuração de inferência de exemplo que usa um ambiente de Azure Machine Learning existente com a versão mais recente para uso com a CLI:The following JSON is an example inference configuration that uses an existing Azure Machine Learning environment with latest version for use with the CLI:

{
    "entryScript": "score.py",
    "environment":{
        "name": "myenv",
        "version": null
    },
    "condaFile": "myenv.yml",
    "sourceDirectory": null
}

O comando a seguir demonstra como implantar um modelo usando a CLI: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

Neste exemplo, a configuração especifica as seguintes configurações:In this example, the configuration specifies the following settings:

  • Se o modelo requer Python.That the model requires Python.
  • O script de entrada, que é usado para manipular solicitações da Web enviadas ao serviço implantado.The 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ência.The Conda file that describes the Python packages needed for inference.

Para obter informações sobre como usar uma imagem personalizada do Docker com uma configuração de inferência, consulte como implantar um modelo usando uma imagem personalizada do Docker.For information on using a custom Docker image with an 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 seu modelo, você deve definir a configuração de implantação.Before deploying your model, 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 um modelo localmente, você deve especificar a porta onde o serviço aceita solicitações.For example, when you deploy a model locally, you must specify the port where the service accepts requests. A configuração de implantação não faz parte do script de entrada.The deployment configuration isn't 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's 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, se, por exemplo, você ainda não tiver uma instância do AKS (serviço kubernetes do Azure) associada ao seu espaço de trabalho.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.

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
LocalLocal deployment_config = LocalWebservice.deploy_configuration(port=8890)
Instâncias de Contêiner do AzureAzure Container Instances deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)
Serviço do Kubernetes do AzureAzure Kubernetes Service deployment_config = AksWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)

As classes para local, instâncias de contêiner do Azure e serviços Web AKS podem ser importadas de azureml.core.webservice: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

Criação de perfilProfiling

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.Before you deploy your model as a service, you might want to profile it to determine optimal CPU and memory requirements. Você pode usar o SDK ou a CLI para criar um perfil para o modelo.You can use either the SDK or the CLI to profile your model. Os exemplos a seguir mostram como criar um perfil de um modelo usando o SDK.The following examples show how to profile a model by using the SDK.

Importante

Quando você usa a criação de perfil, a configuração de inferência que você fornece não pode fazer referência a um ambiente de Azure Machine Learning.When you use profiling, the inference configuration that you provide can't reference an Azure Machine Learning environment. Em vez disso, defina as dependências de software usando o parâmetro conda_file do objeto InferenceConfig.Instead, define the software dependencies by using the conda_file parameter of the InferenceConfig object.

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

profile = Model.profile(ws, "profilemymodel", [model], inference_config, test_data)
profile.wait_for_profiling(True)
profiling_results = profile.get_results()
print(profiling_results)

Esse código exibe um resultado semelhante à seguinte saída:This code displays a result similar to the following output:

{'cpu': 1.0, 'memoryInGB': 0.5}

Os resultados de criação de perfil de modelo são emitidos como um objeto Run.Model profiling results are emitted as a Run object.

Para saber mais sobre como usar a criação de perfil da CLI, confira perfil de modelo AZ ml.For information on using profiling from the CLI, see az ml model profile.

Para obter mais informações, consulte estes documentos:For more information, see these documents:

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. A implantação em AKS é um pouco diferente, pois você deve fornecer uma referência ao cluster AKS.Deploying to AKS is slightly different because you must provide a reference to the AKS cluster.

Protegendo implantações com SSLSecuring deployments with SSL

Para obter mais informações sobre como proteger uma implantação de serviço Web, consulte usar SSL para proteger um serviço Web.For more information on how to secure a web service deployment, see Use SSL to secure a web service.

Implantação localLocal deployment

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

Usar o SDKUsing the SDK

zzszzs

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 LocalWebservice, Model. Deployment ()e WebService.For more information, see the documentation for LocalWebservice, Model.deploy(), and Webservice.

Usando a CLIUsing the CLI

Para implantar um modelo usando a CLI, use o comando a seguir.To deploy a model by using the CLI, use the following command. Substitua 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 documento deploymentconfig.json 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 destinos locais, o valor deve ser local.For local targets, 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.

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

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

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

Serviço Web de VM do notebook (desenvolvimento/teste)Notebook VM web service (dev/test)

Consulte implantar um modelo para Azure Machine Learning VM do notebook.See Deploy a model to Azure Machine Learning Notebook VM.

Instâncias de contêiner do Azure (desenvolvimento/teste)Azure Container Instances (dev/test)

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

Serviço kubernetes do Azure (desenvolvimento/teste e produção)Azure Kubernetes Service (dev/test and production)

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

Consumir 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 seu cabeçalho de solicitação.If you've 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've 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 you deploy the service. Use a propriedade swagger_uri do serviço Web implantado (por exemplo, service.swagger_uri) para obter o URI para o arquivo Swagger do serviço Web local.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.

Consumo de solicitação-respostaRequest-response consumption

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

Para obter mais informações, consulte criar aplicativos cliente para consumir serviços Web.For more information, see Create client applications to consume web services.

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

Se você usou a geração de esquema automática com sua implantação, você pode obter o endereço da especificação OpenAPI para o serviço usando a propriedade swagger_uri.If you used automatic schema generation with your deployment, you can get the address of the OpenAPI specification for the service by using the swagger_uri property. (Por exemplo, print(service.swagger_uri).) Use uma solicitação GET ou abra o URI em um navegador para recuperar a especificação.(For example, print(service.swagger_uri).) 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 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"
                }
            }
        }
    }
}

Para obter mais informações, consulte especificação de openapi.For more information, see OpenAPI 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 Azure Machine Learning.Azure Machine Learning Compute targets are created and managed by Azure Machine Learning. 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, consulte como executar previsões de lote.For a walkthrough of batch inference with Azure Machine Learning Compute, see How to run batch predictions.

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 implantar Azure Machine Learning como um módulo IOT Edge.For more information, see Deploy Azure Machine Learning as an IoT Edge module.

Atualizar serviços WebUpdate web services

Para atualizar um serviço Web, use o método update.To update a web service, use the update method. Você pode atualizar o serviço Web para usar um novo modelo, um novo script de entrada ou novas dependências que podem ser especificadas em uma configuração de inferência.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. Para obter mais informações, consulte a documentação do WebService. Update.For more information, see the documentation for Webservice.update.

Importante

Ao criar uma nova versão de um modelo, você deve atualizar manualmente cada serviço que deseja usá-lo.When you create a new version of a model, you must manually update each service that you want to use it.

Usando o SDKUsing the SDK

O código a seguir mostra como usar o SDK para atualizar o modelo, o ambiente e o script de entrada para um serviço Web: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())

Usando a CLIUsing the CLI

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

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.

Para atualizar o serviço para usar um novo script ou ambiente de entrada, crie um arquivo de configuração de inferência e especifique-o com o parâmetro ic.To update the service to use a new entry script or environment, create an inference configuration file and specify it with the ic parameter.

Para obter mais informações, consulte a documentação de atualização do serviço AZ ml .For more information, see the az ml service update documentation.

Implantar modelos continuamenteContinuously deploy models

Você pode implantar modelos continuamente usando a extensão Machine Learning para o Azure DevOps.You can continuously deploy models by using the Machine Learning extension for Azure DevOps. Você pode usar a extensão Machine Learning do Azure DevOps para disparar um pipeline de implantação quando um novo modelo de aprendizado de máquina for registrado em um espaço de trabalho do Azure Machine Learning.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. Inscreva-se para Azure pipelines, que torna a integração contínua e a entrega de seu aplicativo a qualquer plataforma ou nuvem possível.Sign up for Azure Pipelines, which makes continuous integration and delivery of your application to any platform or cloud possible. (Observe que Azure Pipelines não é o mesmo que Machine Learning pipelines.)(Note that Azure Pipelines isn't the same as Machine Learning pipelines.)

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

  3. Instale a extensão de Machine Learning para Azure pipelines.Install 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 seu espaço de trabalho Azure Machine Learning para que você possa acessar seus artefatos.Use service connections to set up a service principal connection to your Azure Machine Learning workspace so you can access your artifacts. Vá para configurações do projeto, selecione conexões de serviçoe, em seguida, selecione Azure Resource Manager:Go to project settings, select Service connections, and then select Azure Resource Manager:

    selecionar Azure Resource ManagerSelect Azure Resource Manager

  5. Na lista nível de escopo , selecione AzureMLWorkspacee, em seguida, insira o restante dos valores:In the Scope level list, select AzureMLWorkspace, and then enter the rest of the values:

    Selecionar AzureMLWorkspace

  6. Para implantar continuamente o modelo de aprendizado de máquina usando Azure Pipelines, em pipelines, selecione liberar.To continuously deploy your machine learning model by using Azure Pipelines, under pipelines, select release. Adicione um novo artefato e, em seguida, selecione o artefato do modelo do AzureML e a conexão de serviço que você criou anteriormente.Add a new artifact, and then select the AzureML Model artifact and the service connection that you created earlier. Selecione o modelo e a versão para disparar uma implantação:Select the model and version to trigger a deployment:

    selecionar modelo do AzureMLSelect AzureML Model

  7. Habilite o gatilho de modelo em seu artefato de modelo.Enable the model trigger on your model artifact. Quando você ativa o gatilho, toda vez que a versão especificada (ou seja, a versão mais recente) desse modelo é registrada em seu espaço de trabalho, um pipeline de versão do Azure DevOps é disparado.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.

    habilitar o gatilho de modeloEnable the model trigger

Para obter mais exemplos e projetos de exemplo, consulte estes repositórios de exemplo no GitHub:For more sample projects and examples, see these sample repos in GitHub:

Baixar um modeloDownload a model

Se você quiser baixar seu modelo para usá-lo em seu próprio ambiente de execução, poderá fazer isso com os seguintes comandos SDK/CLI:If you want to download your model to use it in your own execution environment, you can do so with the following SDK / CLI commands:

SDK:SDK:

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

CLI:CLI:

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

Apresentação Implantação de modelo sem código(Preview) No-code model deployment

No momento, a implantação de modelo sem código está em versão prévia e dá suporte às seguintes estruturas de Machine Learning:No-code model deployment is currently in preview and supports the following machine learning frameworks:

Tensorflow SavedModel FormatTensorflow SavedModel format

Os modelos Tensorflow precisam ser registrados no formato SavedModel para trabalhar com a implantação de modelo sem código.Tensorflow models need to be registered in SavedModel format to work with no-code model deployment.

Consulte este link para obter informações sobre como criar um SavedModel.Please see this link for information on how to create a SavedModel.

from azureml.core import Model

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

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

Modelos ONNXONNX models

O registro e a implantação do modelo de ONNX têm suporte para qualquer grafo de inferência ONNX.ONNX model registration and deployment is supported for any ONNX inference graph. Atualmente, não há suporte para as etapas de pré-processamento e postprocess.Preprocess and postprocess steps are not currently supported.

Aqui está um exemplo de como registrar e implantar um modelo MNIST ONNX:Here is an example of how to register and deploy an MNIST ONNX model:

from azureml.core import Model

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

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

Modelos do Scikit-learnScikit-learn models

Não há suporte para implantação de modelo de código para todos os tipos de modelo scikit-Learn internos.No code model deployment is supported for all built-in scikit-learn model types.

Aqui está um exemplo de como registrar e implantar um modelo sklearn sem código extra: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])

Observação: essas dependências estão incluídas no contêiner de inferência de sklearn predefinido:NOTE: These dependencies are included in the prebuilt sklearn inference container:

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

Modelos de pacotePackage models

Em alguns casos, talvez você queira criar uma imagem do Docker sem implantar o modelo (se, por exemplo, você planeja implantar no serviço Azure app).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). Ou talvez você queira baixar a imagem e executá-la em uma instalação local do Docker.Or you might want to download the image and run it on a local Docker installation. Talvez você queira até mesmo baixar os arquivos usados para criar a imagem, inspecioná-los, modificá-los e criar a imagem manualmente.You might even want to download the files used to build the image, inspect them, modify them, and build the image manually.

O empacotamento de modelo permite que você faça essas coisas.Model packaging enables you to do these things. Ele empacota todos os ativos necessários para hospedar um modelo como um serviço Web e permite que você baixe uma imagem do Docker totalmente criada ou os arquivos necessários para criar um.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. Há duas maneiras de usar o empacotamento de modelo:There are two ways to use model packaging:

Baixar um modelo empacotado: Baixe uma imagem do Docker que contém o modelo e outros arquivos necessários para hospedá-lo como um serviço Web.Download a packaged model: Download a Docker image that contains the model and other files needed to host it as a web service.

Gerar um Dockerfile: Baixe o Dockerfile, o modelo, o script de entrada e outros ativos necessários para criar uma imagem do Docker.Generate a Dockerfile: Download the Dockerfile, model, entry script, and other assets needed to build a Docker image. Você pode inspecionar os arquivos ou fazer alterações antes de criar a imagem localmente.You can then inspect the files or make changes before you build the image locally.

Ambos os pacotes podem ser usados para obter uma imagem local do Docker.Both packages can be used to get a local Docker image.

Dica

A criação de um pacote é semelhante à implantação de um modelo.Creating a package is similar to deploying a model. Você usa um modelo registrado e uma configuração de inferência.You use a registered model and an inference configuration.

Importante

Para baixar uma imagem totalmente criada ou criar uma imagem localmente, você precisa ter o Docker instalado em seu ambiente de desenvolvimento.To download a fully built image or build an image locally, you need to have Docker installed in your development environment.

Baixar um modelo empacotadoDownload a packaged model

O exemplo a seguir cria uma imagem, que é registrada no registro de contêiner do Azure para seu espaço de trabalho: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)

Depois de criar um pacote, você pode usar package.pull() para efetuar pull da imagem para o ambiente do Docker local.After you create a package, you can use package.pull() to pull the image to your local Docker environment. A saída desse comando exibirá o nome da imagem.The output of this command will display the name of the image. Por exemplo:For example:

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

Depois de baixar o modelo, use o comando docker images para listar as imagens locais: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.43GB

Para iniciar um contêiner local com base nessa imagem, use o comando a seguir para iniciar um contêiner nomeado do Shell ou da linha de comando.To start a local container based on this image, use the following command to start a named container from the shell or command line. Substitua o valor <imageid> pela ID da imagem retornada pelo comando docker images.Replace the <imageid> value with the image ID returned by the docker images command.

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

Esse comando inicia a versão mais recente da imagem chamada myimage.This command starts the latest version of the image named myimage. Ele mapeia a porta local 6789 para a porta no contêiner em que o serviço Web está escutando (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Ele também atribui o nome mycontainer ao contêiner, o que torna o contêiner mais fácil de parar.It also assigns the name mycontainer to the container, which makes the container easier to stop. Depois que o contêiner for iniciado, você poderá enviar solicitações para http://localhost:6789/score.After the container is started, you can submit requests to http://localhost:6789/score.

Gerar um Dockerfile e dependênciasGenerate a Dockerfile and dependencies

O exemplo a seguir mostra como baixar o Dockerfile, o modelo e outros ativos necessários para criar uma imagem localmente.The following example shows how to download the Dockerfile, model, and other assets needed to build an image locally. O parâmetro generate_dockerfile=True indica que você deseja os arquivos, não uma imagem totalmente compilada.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)

Esse código baixa os arquivos necessários para criar a imagem no diretório imagefiles.This code downloads the files needed to build the image to the imagefiles directory. O Dockerfile incluído nos arquivos salvos faz referência a uma imagem base armazenada em um registro de contêiner do Azure.The Dockerfile included in the saved files references a base image stored in an Azure container registry. Ao criar a imagem na instalação local do Docker, você precisa usar o endereço, o nome de usuário e a senha para se autenticar no registro.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. Use as etapas a seguir para criar a imagem usando uma instalação local do Docker:Use the following steps to build the image by using a local Docker installation:

  1. Em uma sessão de linha de comando ou Shell, use o comando a seguir para autenticar o Docker com o registro de contêiner do Azure.From a shell or command-line session, use the following command to authenticate Docker with the Azure container registry. Substitua <address>, <username>e <password> pelos valores recuperados por package.get_container_registry().Replace <address>, <username>, and <password> with the values retrieved by package.get_container_registry().

    docker login <address> -u <username> -p <password>
    
  2. Para criar a imagem, use o comando a seguir.To build the image, use the following command. Substitua <imagefiles> pelo caminho do diretório em que package.save() salvou os arquivos.Replace <imagefiles> with the path of the directory where package.save() saved the files.

    docker build --tag myimage <imagefiles>
    

    Esse comando define o nome da imagem como myimage.This command sets the image name to myimage.

Para verificar se a imagem foi criada, use o comando docker images.To verify that the image is built, use the docker images command. Você deve ver a imagem myimage na lista:You should see the myimage image in the list:

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

Para iniciar um novo contêiner com base nessa imagem, use o seguinte comando:To start a new container based on this image, use the following command:

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

Esse comando inicia a versão mais recente da imagem chamada myimage.This command starts the latest version of the image named myimage. Ele mapeia a porta local 6789 para a porta no contêiner em que o serviço Web está escutando (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). Ele também atribui o nome mycontainer ao contêiner, o que torna o contêiner mais fácil de parar.It also assigns the name mycontainer to the container, which makes the container easier to stop. Depois que o contêiner for iniciado, você poderá enviar solicitações para http://localhost:6789/score.After the container is started, you can submit requests to http://localhost:6789/score.

Exemplo de cliente para testar o contêiner localExample client to test the local container

O código a seguir é um exemplo de um cliente Python que pode ser usado com o contêiner: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)

Por exemplo, clientes em outras linguagens de programação, consulte consumir modelos implantados como serviços Web.For example clients in other programming languages, see Consume models deployed as web services.

Parar o contêiner do DockerStop the Docker container

Para parar o contêiner, use o seguinte comando de um shell ou linha de comando diferente:To stop the container, use the following command from a different shell or command line:

docker kill mycontainer

Limpar recursosClean up resources

Para excluir um serviço Web implantado, use service.delete().To delete a deployed web service, use service.delete(). Para excluir um modelo registrado, use model.delete().To delete a registered model, use model.delete().

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

Próximos passosNext steps