Implementación de modelos con Azure Machine LearningDeploy models with Azure Machine Learning

Se aplica a: síBasic Edition síEnterprise Edition                    (Actualización a Enterprise Edition)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Aprenda a implementar el modelo de Machine Learning como un servicio web en la nube de Azure o en dispositivos de Azure IoT Edge.Learn how to deploy your machine learning model as a web service in the Azure cloud or to Azure IoT Edge devices.

El flujo de trabajo es siempre parecido independientemente de donde implemente el modelo:The workflow is similar no matter where you deploy your model:

  1. Registre el modelo.Register the model.
  2. Prepárese para la implementación.Prepare to deploy. (Especifique los recursos, el uso y el destino de proceso).(Specify assets, usage, compute target.)
  3. Implemente el modelo en el destino de proceso.Deploy the model to the compute target.
  4. Pruebe el modelo implementado, también denominado servicio web.Test the deployed model, also called a web service.

Para más información sobre los conceptos implicados en el flujo de trabajo de implementación, consulte Administración, implementación y supervisión de modelos con Azure Machine Learning.For more information on the concepts involved in the deployment workflow, see Manage, deploy, and monitor models with Azure Machine Learning.

Requisitos previosPrerequisites

Conexión con su área de trabajoConnect to your workspace

En el código siguiente se muestra cómo conectarse a un área de trabajo de Azure Machine Learning con la información almacenada en caché del entorno de desarrollo local:The following code shows how to connect to an Azure Machine Learning workspace by using information cached to the local development environment:

  • Uso del SDKUsing the SDK

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

    Para más información sobre el uso del SDK para conectarse a un área de trabajo, consulte la documentación del SDK de 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 documentation.

  • Uso de la CLIUsing the CLI

    Al usar la CLI, use el parámetro -w o --workspace-name para especificar el área de trabajo para el comando.When using the CLI, use the -w or --workspace-name parameter to specify the workspace for the command.

  • Uso de Visual Studio CodeUsing VS Code

    Cuando use VS Code, seleccione el área de trabajo mediante una interfaz gráfica.When you use VS Code, you select the workspace by using a graphical interface. Para más información, consulte Implementación y administración de modelos en la documentación de la extensión de VS Code.For more information, see Deploy and manage models in the VS Code extension documentation.

Registro del modeloRegister your model

Un modelo registrado es un contenedor lógico para uno o varios archivos que componen el modelo.A registered model is a logical container for one or more files that make up your model. Por ejemplo, si tiene un modelo que se almacena en varios archivos, puede registrarlos como un único modelo en el área de trabajo.For example, if you have a model that's stored in multiple files, you can register them as a single model in the workspace. Después de registrar los archivos, puede descargar o implementar el modelo registrado y recibir todos los archivos que registró.After you register the files, you can then download or deploy the registered model and receive all the files that you registered.

Sugerencia

Al registrar un modelo, se proporciona una ruta de acceso de una ubicación en la nube (desde una ejecución de entrenamiento) o de un directorio local.When you register a model, you provide the path of either a cloud location (from a training run) or a local directory. Esta ruta de acceso es solo para localizar los archivos que se van a cargar como parte del proceso de registro.This path is just to locate the files for upload as part of the registration process. No es necesario que coincida con la ruta de acceso que se usa en el script de entrada.It doesn't need to match the path used in the entry script. Para obtener más información, consulte Locate model files in your entry script (Localización de archivos de modelo en el script de entrada).For more information, see Locate model files in your entry script.

Los modelos de Machine Learning se registran en el área de trabajo de Azure Machine Learning.Machine learning models are registered in your Azure Machine Learning workspace. El modelo puede proceder de Azure Machine Learning o de otro lugar.The model can come from Azure Machine Learning or from somewhere else. En los ejemplos siguientes se muestra cómo registrar un modelo.The following examples demonstrate how to register a model.

Registro de un modelo a partir de una ejecución de experimentoRegister a model from an experiment run

En los fragmentos de código de esta sección se muestra cómo registrar un modelo a partir de una ejecución de entrenamiento:The code snippets in this section demonstrate how to register a model from a training run:

Importante

Para usar estos fragmentos de código, necesita haber realizado previamente una ejecución de entrenamiento y tener acceso al objeto Run (ejemplo del SDK) o al valor de identificador de ejecución (ejemplo de la 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 más información sobre los modelos de entrenamiento, consulte Configuración y uso de destinos de proceso para el entrenamiento del modelo.For more information on training models, see Set up compute targets for model training.

  • Uso del SDKUsing the SDK

    Al usar el SDK para entrenar un modelo, puede recibir un objeto Run o AutoMLRun, en función de cómo haya entrenado el 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 se puede usar para registrar un modelo creado por una ejecución del experimento.Each object can be used to register a model created by an experiment run.

    • Registre un modelo desde un 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')
      

      El parámetro model_path hace referencia a la ubicación del modelo en la nube.The model_path parameter refers to the cloud location of the model. En este ejemplo, se usa la ruta de acceso de un único archivo.In this example, the path of a single file is used. Para incluir varios archivos en el registro del modelo, establezca model_path en la ruta de acceso de una carpeta que contiene los archivos.To include multiple files in the model registration, set model_path to the path of a folder that contains the files. Para obtener más información, consulte la documentación Run.register_model.For more information, see the Run.register_model documentation.

    • Registre un modelo desde un 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)
      

      En este ejemplo, los parámetros metric y iteration, no se especifican, por lo que se registrará la iteración con la mejor métrica principal.In this example, the metric and iteration parameters aren't specified, so the iteration with the best primary metric will be registered. Se utiliza el valor model_id devuelto de la ejecución en lugar de un nombre de modelo.The model_id value returned from the run is used instead of a model name.

      Para más información, consulte la documentación de AutoMLRun.register_model.For more information, see the AutoMLRun.register_model documentation.

  • Uso de la CLIUsing the CLI

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

    Sugerencia

    Si recibe un mensaje de error que indican que la extensión ml no está instalada, use el siguiente comando para instalarla: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
    

    El parámetro --asset-path hace referencia a la ubicación del modelo en la nube.The --asset-path parameter refers to the cloud location of the model. En este ejemplo, se usa la ruta de acceso de un único archivo.In this example, the path of a single file is used. Para incluir varios archivos en el registro del modelo, establezca --asset-path en la ruta de acceso de una carpeta que contiene los archivos.To include multiple files in the model registration, set --asset-path to the path of a folder that contains the files.

  • Uso de Visual Studio CodeUsing VS Code

    Registre los modelos usando todas las carpetas o archivos de modelo mediante la extensión VS Code.Register models using any model files or folders by using the VS Code extension.

Registrar un modelo desde un archivo localRegister a model from a local file

Puede registrar un modelo proporcionando la ruta de acceso local de dicho modelo.You can register a model by providing the local path of the model. Puede proporcionar la ruta de acceso de una carpeta o un único archivo.You can provide the path of either a folder or a single file. Puede usar este método para registrar los modelos entrenados con Azure Machine Learning y, luego, descargados.You can use this method to register models trained with Azure Machine Learning and then downloaded. También puede usar este método para registrar modelos entrenados fuera de Azure Machine Learning.You can also use this method to register models trained outside of Azure Machine Learning.

Importante

Solo debe usar los modelos que cree u obtenga de un origen de confianza.You should use only models that you create or obtain from a trusted source. Debe tratar los modelos serializados como código, porque se han descubierto vulnerabilidades de seguridad en varios formatos conocidos.You should treat serialized models as code, because security vulnerabilities have been discovered in a number of popular formats. También, los modelos se pueden entrenar intencionadamente con intenciones malintencionadas para proporcionar resultados inexactos o sesgados.Also, models might be intentionally trained with malicious intent to provide biased or inaccurate output.

  • Uso del SDK y 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 varios archivos en el registro del modelo, establezca model_path en la ruta de acceso de una carpeta que contiene los archivos.To include multiple files in the model registration, set model_path to the path of a folder that contains the files.

  • Uso de la CLIUsing the CLI

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

    Para incluir varios archivos en el registro del modelo, establezca -p en la ruta de acceso de una carpeta que contiene los archivos.To include multiple files in the model registration, set -p to the path of a folder that contains the files.

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

Para más información, consulte la documentación de la clase Model.For more information, see the documentation for the Model class.

Para más información sobre cómo trabajar con modelos entrenados al margen de Azure Machine Learning, consulte el artículo sobre cómo implementar un modelo existente.For more information on working with models trained outside Azure Machine Learning, see How to deploy an existing model.

Elección de un destino de procesoChoose a compute target

Puede usar los siguientes destinos o recursos de proceso para hospedar la implementación del servicio web:You can use the following compute targets, or compute resources, to host your web service deployment:

Destino de procesoCompute target Usado paraUsed for Compatibilidad con GPUGPU support Compatibilidad con FPGAFPGA support DESCRIPCIÓNDescription
Servicio web localLocal web service Pruebas y depuraciónTesting/debugging     Se usa para pruebas limitadas y solución de problemas.Use for limited testing and troubleshooting. La aceleración de hardware depende del uso de bibliotecas en el sistema local.Hardware acceleration depends on use of libraries in the local system.
Servicio web de la instancia de proceso de Azure Machine LearningAzure Machine Learning compute instance web service Pruebas y depuraciónTesting/debugging     Se usa para pruebas limitadas y solución de problemas.Use for limited testing and troubleshooting.
Azure Kubernetes Service (AKS)Azure Kubernetes Service (AKS) Inferencia en tiempo realReal-time inference (implementación del servicio web)Yes (web service deployment) Yes Se usa para las implementaciones de producción a gran escala.Use for high-scale production deployments. Proporciona un tiempo de respuesta rápido y el escalado automático del servicio implementado.Provides fast response time and autoscaling of the deployed service. No se admite el escalado automático de clúster a través del SDK de Azure Machine Learning.Cluster autoscaling isn't supported through the Azure Machine Learning SDK. Para cambiar los nodos del clúster de AKS, use la interfaz de usuario para el clúster de AKS en Azure Portal.To change the nodes in the AKS cluster, use the UI for your AKS cluster in the Azure portal. AKS es la única opción disponible para el diseñador.AKS is the only option available for the designer.
Azure Container InstancesAzure Container Instances Pruebas o desarrolloTesting or development     Se usa para cargas de trabajo basadas en CPU a pequeña escala que requieren menos de 48 GB de RAM.Use for low-scale CPU-based workloads that require less than 48 GB of RAM.
Clústeres de proceso de Azure Machine LearningAzure Machine Learning compute clusters Inferencia de lote (versión preliminar)(Preview) Batch inference (canalización de aprendizaje automático)Yes (machine learning pipeline)   Ejecute la puntuación por lotes en un proceso sin servidor.Run batch scoring on serverless compute. Admite máquinas virtuales de prioridad normal y baja.Supports normal and low-priority VMs.
Azure IoT EdgeAzure IoT Edge Módulo de IoT (versión preliminar)(Preview) IoT module     Implementación y entrega de modelos de Machine Learning en dispositivos IoT.Deploy and serve ML models on IoT devices.
Azure Data Box EdgeAzure Data Box Edge A través de IoT EdgeVia IoT Edge   Yes Implementación y entrega de modelos de Machine Learning en dispositivos IoT.Deploy and serve ML models on IoT devices.

Nota

Aunque los destinos de proceso, como la instancia local de proceso de Azure Machine Learning y los clústeres de proceso de Azure Machine Learning, admiten GPU para el aprendizaje y la experimentación, el uso de la GPU para la inferencia cuando se implementa como un servicio web solo se admite en Azure Kubernetes Service.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.

El uso de una GPU para la inferencia cuando se realiza la puntuación con una canalización de aprendizaje automático solo se admite en el Proceso de Azure Machine Learning.Using a GPU for inference when scoring with a machine learning pipeline is supported only on Azure Machine Learning Compute.

Preparación de la actualizaciónPrepare to deploy

Para implementar el modelo, necesita los siguientes elementos:To deploy the model, you need the following items:

  • Un script de entrada.An entry script. Este script acepta solicitudes, puntúa las solicitudes mediante el modelo y devuelve los resultados.This script accepts requests, scores the requests by using the model, and returns the results.

    Importante

    • El script de entrada es específico para su modelo.The entry script is specific to your model. Debe comprender el formato de los datos de la solicitud entrante, el formato de los datos que espera el modelo y el formato de los datos que se devuelven a los 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.

      Si los datos de la solicitud están en un formato que el modelo no puede usar, el script puede transformarlos a un formato aceptable.If the request data is in a format that's not usable by your model, the script can transform it into an acceptable format. También puede transformar la respuesta antes de devolverla al cliente.It can also transform the response before returning it to the client.

    • El SDK de Azure Machine Learning no proporciona una manera para que las implementaciones de servicios web o IoT Edge tengan acceso al almacén de datos o a los conjuntos de datos.The Azure Machine Learning SDK doesn't provide a way for web services or IoT Edge deployments to access your data store or datasets. Si el modelo implementado necesita acceder a los datos almacenados fuera de la implementación, como los datos de una cuenta de almacenamiento de Azure, debe desarrollar una solución de código personalizada mediante el SDK pertinente.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 ejemplo, el SDK de Azure Storage para Python.For example, the Azure Storage SDK for Python.

      Otra alternativa que puede funcionar para su escenario son las predicciones por lotes, que proporcionan acceso a los almacenes de datos durante la puntuación.An alternative that might work for your scenario is batch prediction, which does provide access to data stores during scoring.

  • Dependencias, como scripts de asistente o paquetes de Python/Conda, necesarias para ejecutar el modelo o el script de entrada.Dependencies, like helper scripts or Python/Conda packages required to run the entry script or model.

  • La configuración de la implementación del destino de proceso que hospeda el modelo implementado.The deployment configuration for the compute target that hosts the deployed model. Esta configuración describe los aspectos, como los requisitos de memoria y CPU, necesarios para ejecutar el modelo.This configuration describes things like memory and CPU requirements needed to run the model.

Estos elementos se encapsulan en una configuración de inferencia y una configuración de implementación.These items are encapsulated into an inference configuration and a deployment configuration. La configuración de inferencia hace referencia al script de entrada y a otras dependencias.The inference configuration references the entry script and other dependencies. Estas configuraciones se definen mediante programación cuando se usa el SDK para realizar la implementación.You define these configurations programmatically when you use the SDK to perform the deployment. Se definen en archivos JSON cuando se usa la CLI.You define them in JSON files when you use the CLI.

1. Definición de los scripts y dependencias de entrada1. Define your entry script and dependencies

El script de entrada recibe los datos enviados a un servicio web implementado y los pasa al modelo.The entry script receives data submitted to a deployed web service and passes it to the model. A continuación, toma la respuesta devuelta por el modelo y la envía al cliente.It then takes the response returned by the model and returns that to the client. El script es específico para su modelo.The script is specific to your model. Debe entender los datos que el modelo espera y devuelve.It must understand the data that the model expects and returns.

El script contiene dos funciones que cargan y ejecutan el modelo:The script contains two functions that load and run the model:

  • init(): normalmente, esta función carga el modelo en un objeto global.init(): Typically, this function loads the model into a global object. Esta función solo se ejecuta una vez cuando se inicia el contenedor de Docker para el servicio web.This function is run only once, when the Docker container for your web service is started.

  • run(input_data): esta función usa el modelo para predecir un valor basado en los datos de entrada.run(input_data): This function uses the model to predict a value based on the input data. Las entradas y salidas de la ejecución suelen usar el formato JSON para la serialización y deserialización.Inputs and outputs of the run typically use JSON for serialization and deserialization. También puede trabajar con datos binarios sin formato.You can also work with raw binary data. Puede transformar los datos antes de enviarlos al modelo o antes de devolverlos al cliente.You can transform the data before sending it to the model or before returning it to the client.

Localización de archivos de modelo en el script de entradaLocate model files in your entry script

Hay dos maneras de buscar modelos en el script de entrada:There are two ways to locate models in your entry script:

  • AZUREML_MODEL_DIR: variable de entorno que contiene la ruta de acceso a la ubicación del modelo.AZUREML_MODEL_DIR: An environment variable containing the path to the model location.
  • Model.get_model_path: API que devuelve la ruta de acceso al archivo de modelo mediante el nombre del 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 es una variable de entorno que se crea durante la implementación del servicio.AZUREML_MODEL_DIR is an environment variable created during service deployment. Puede usar esta variable de entorno para buscar la ubicación de los modelos implementados.You can use this environment variable to find the location of the deployed model(s).

En la tabla siguiente se describe el valor de AZUREML_MODEL_DIR en función del número de modelos implementados:The following table describes the value of AZUREML_MODEL_DIR depending on the number of models deployed:

ImplementaciónDeployment Valor de la variable de entornoEnvironment variable value
Modelo únicoSingle model Ruta de acceso a la carpeta que contiene el modelo.The path to the folder containing the model.
Varios modelosMultiple models Ruta de acceso a la carpeta que contiene todos los modelos.The path to the folder containing all models. Los modelos se encuentran por nombre y versión en esta carpeta ($MODEL_NAME/$VERSION).Models are located by name and version in this folder ($MODEL_NAME/$VERSION)

Para obtener la ruta de acceso a un archivo en un modelo, combine la variable de entorno con el nombre del archivo que está buscando.To get the path to a file in a model, combine the environment variable with the filename you're looking for. Los nombres de archivo de los archivos de modelo se conservan durante el registro y la implementación.The filenames of the model files are preserved during registration and deployment.

Ejemplo de modelo únicoSingle model example

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

Ejemplo de varios 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

Cuando registra un modelo, puede proporcionar un nombre de modelo que se usa para administrar este en el registro.When you register a model, you provide a model name that's used for managing the model in the registry. Usará este nombre con el método Model.get_model_path() para recuperar la ruta de acceso del archivo del modelo en el sistema de archivos 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. Si registra una carpeta o una colección de archivos, esta API devolverá la ruta de acceso del directorio que contiene esos archivos.If you register a folder or a collection of files, this API returns the path of the directory that contains those files.

Al registrar un modelo, se le asigna un nombre.When you register a model, you give it a name. El nombre se corresponde con la ubicación donde se coloque el modelo, ya sea localmente o durante la implementación del servicio.The name corresponds to where the model is placed, either locally or during service deployment.

Importante

Si usó aprendizaje automático automatizado para entrenar un modelo, se utiliza un valor model_id como nombre del modelo.If you used automated machine learning to train a model, a model_id value is used as the model name. Para ver un ejemplo de registro e implementación de un modelo entrenado con aprendizaje automático automatizado, consulte Azure/MachineLearningNotebooks en GitHub.For an example of registering and deploying a model trained with automated machine learning, see Azure/MachineLearningNotebooks on GitHub.

El ejemplo siguiente devolverá una ruta de acceso a un único archivo denominado sklearn_mnist_model.pkl (que se registró con el nombre 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')

Generación automática de esquemas (Opcional)(Optional) Automatic schema generation

Para generar automáticamente un esquema para el servicio web, proporcione un ejemplo de la entrada y salida del constructor de uno de los 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. El tipo y ejemplo se usan para crear automáticamente el esquema.The type and sample are used to automatically create the schema. Azure Machine Learning creará, a continuación, una especificación de OpenAPI (Swagger) para el servicio web durante la implementación.Azure Machine Learning then creates an OpenAPI (Swagger) specification for the web service during deployment.

Actualmente se admiten estos tipos:These types are currently supported:

  • pandas
  • numpy
  • pyspark
  • Objeto estándar de PythonStandard Python object

Para usar la generación de esquemas, incluya el paquete inference-schema en el archivo de entorno de Conda.To use schema generation, include the inference-schema package in your Conda environment file. Para más información sobre este paquete, consulte https://github.com/Azure/InferenceSchema.For more information on this package, see https://github.com/Azure/InferenceSchema.

Ejemplo de archivo de dependenciasExample dependencies file

El siguiente código YAML es un ejemplo de un archivo de dependencias de Conda para inferencia: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

Si la dependencia está disponible tanto a través de Conda como de PIP (de PyPi), Microsoft recomienda usar la versión de Conda, ya que los paquetes de Conda normalmente incluyen archivos binarios pregenerados que hacen que la instalación sea más confiable.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 obtener más información, consulte la descripción de Conda y PIP.For more information, see Understanding Conda and Pip.

Para comprobar si la dependencia está disponible a través de Conda, use el comando conda search <package-name> o los índices de paquetes en https://anaconda.org/anaconda/repo y 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.

Si desea usar la generación automática de esquemas, el script de entrada debe importar los paquetes inference-schema.If you want to use automatic schema generation, your entry script must import the inference-schema packages.

Defina los formatos de ejemplo de entrada y salida de las variables input_sample y output_sample, que representan los formatos de solicitud y respuesta del servicio 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 estos ejemplos en los decoradores de entrada y salida de la función run().Use these samples in the input and output function decorators on the run() function. El siguiente ejemplo de Scikit-learn usa generación de esquemas.The following scikit-learn example uses schema generation.

Script de entrada de ejemploExample entry script

En el siguiente ejemplo se muestra cómo aceptar y devolver datos 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

En el ejemplo siguiente se muestra cómo definir datos de entrada como un diccionario <key: value> mediante DataFrame.The following example demonstrates how to define the input data as a <key: value> dictionary by using a DataFrame. Este método se admite para consumir el servicio Web implementado desde Power BI.This method is supported for consuming the deployed web service from Power BI. (Obtenga más información sobre cómo consumir el servicio web desde 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 más ejemplos, consulte los siguientes scripts:For more examples, see the following scripts:

Datos binariosBinary data

Si el modelo acepta datos binarios, como una imagen, debe modificar el archivo score.py usado para la implementación para aceptar solicitudes HTTP sin procesar.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 aceptar los datos sin procesar, use la clase AMLRequest en el script de entrada y agregue el elemento decorador @rawhttp a la función run().To accept raw data, use the AMLRequest class in your entry script and add the @rawhttp decorator to the run() function.

Este es un ejemplo de score.py que acepta datos binarios: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

La clase AMLRequest está en el espacio de nombres azureml.contrib.The AMLRequest class is in the azureml.contrib namespace. Las entidades de este espacio de nombres cambian con frecuencia mientras trabajamos para mejorar el servicio.Entities in this namespace change frequently as we work to improve the service. Todo el contenido de este espacio de nombres debe considerarse una versión preliminar que no es completamente compatible con Microsoft.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Si necesita probar esto en su entorno de desarrollo local, puede instalar los componentes mediante el comando siguiente: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

Uso compartido de recursos entre orígenes (CORS)Cross-origin resource sharing (CORS)

Uso compartido de recursos entre orígenes es una manera de permitir que los recursos en una página web se soliciten desde otro dominio.Cross-origin resource sharing is a way to allow resources on a web page to be requested from another domain. CORS funciona a través de los encabezados HTTP enviados con la solicitud del cliente y se devuelven con la respuesta del servicio.CORS works via HTTP headers sent with the client request and returned with the service response. Para más información sobre CORS y los encabezados válidos, consulte Intercambio de recursos de origen cruzado en Wikipedia.For more information on CORS and valid headers, see Cross-origin resource sharing in Wikipedia.

Para configurar la implementación del modelo para que admita CORS, use la clase AMLResponse en el script de entrada.To configure your model deployment to support CORS, use the AMLResponse class in your entry script. Esta clase permite establecer los encabezados en el objeto de respuesta.This class allows you to set the headers on the response object.

En el ejemplo siguiente se establece el encabezado Access-Control-Allow-Origin para la respuesta desde el 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

La clase AMLResponse está en el espacio de nombres azureml.contrib.The AMLResponse class is in the azureml.contrib namespace. Las entidades de este espacio de nombres cambian con frecuencia mientras trabajamos para mejorar el servicio.Entities in this namespace change frequently as we work to improve the service. Todo el contenido de este espacio de nombres debe considerarse una versión preliminar que no es completamente compatible con Microsoft.Anything in this namespace should be considered a preview that's not fully supported by Microsoft.

Si necesita probar esto en su entorno de desarrollo local, puede instalar los componentes mediante el comando siguiente: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. Definición de InferenceConfig2. Define your InferenceConfig

La configuración de inferencia describe cómo configurar el modelo para realizar predicciones.The inference configuration describes how to configure the model to make predictions. Esta configuración no forma parte del script de entrada.This configuration isn't part of your entry script. Hace referencia a su script de entrada y se usa para localizar todos los recursos que requiere la implementación.It references your entry script and is used to locate all the resources required by the deployment. Se usa más adelante, cuando se implementa el modelo.It's used later, when you deploy the model.

La configuración de inferencia puede usar entornos de Azure Machine Learning para definir las dependencias de software necesarias para la implementación.Inference configuration can use Azure Machine Learning environments to define the software dependencies needed for your deployment. Los entornos permiten crear, administrar y reutilizar las dependencias de software necesarias para el entrenamiento y la implementación.Environments allow you to create, manage, and reuse the software dependencies required for training and deployment. En el ejemplo siguiente se muestra cómo cargar un entorno desde el área de trabajo y luego usarlo con la configuración de inferencia: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 obtener más información sobre los entornos, consulte el tema sobre la creación y administración de entornos de entrenamiento e implementación.For more information on environments, see Create and manage environments for training and deployment.

También puede especificar directamente las dependencias sin usar un entorno.You can also directly specify the dependencies without using an environment. En el ejemplo siguiente se muestra cómo crear una configuración de inferencia que carga las dependencias de software desde un archivo de 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 más información, consulte la documentación de la clase InferenceConfig.For more information, see the InferenceConfig class documentation.

Para información sobre el uso de una imagen personalizada de Docker con una configuración de inferencia, consulte Cómo implementar un modelo con una imagen personalizada de Docker.For information on using a custom Docker image with an inference configuration, see How to deploy a model using a custom Docker image.

Ejemplo de la CLI de InferenceConfigCLI example of InferenceConfig

Las entidades del documento inferenceconfig.json se asignan a los parámetros de la clase InferenceConfig.The entries in the inferenceconfig.json document map to the parameters for the InferenceConfig class. En la tabla siguiente se describe la asignación entre las entidades del documento JSON y los parámetros del método:The following table describes the mapping between entities in the JSON document and the parameters for the method:

Entidad JSONJSON entity Parámetro del métodoMethod parameter DESCRIPCIÓNDescription
entryScript entry_script Ruta de acceso al archivo local que contiene el código que se ejecuta para la imagen.Path to a local file that contains the code to run for the image.
runtime runtime el runtime que se usará para la imagen.Which runtime to use for the image. Los runtimes admitidos actualmente son spark-py y python.Current supported runtimes are spark-py and python.
condaFile conda_file Opcional.Optional. Ruta de acceso a un archivo local que contiene una definición de entorno de Conda que se usará para la imagen.Path to a local file that contains a Conda environment definition to use for the image.
extraDockerFileSteps extra_docker_file_steps Opcional.Optional. Ruta de acceso a un archivo local que contiene los pasos de Docker adicionales que se deben ejecutar al configurar la imagen.Path to a local file that contains additional Docker steps to run when setting up the image.
sourceDirectory source_directory Opcional.Optional. Ruta de acceso a las carpetas que contienen todos los archivos para crear la imagen.Path to folders that contain all files to create the image.
enableGpu enable_gpu Opcional.Optional. Determina si se habilita la compatibilidad con GPU en la imagen.Whether to enable GPU support in the image. La imagen GPU se debe usar en un servicio de Azure como Azure Container Instances, Proceso de Azure Machine Learning, Azure Virtual Machines y Azure Kubernetes Service.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. El valor predeterminado es False.The default is False.
baseImage base_image Opcional.Optional. Una imagen personalizada que se usará como imagen base.Custom image to be used as a base image. Si no se proporciona ninguna imagen base, la imagen se basará en el parámetro runtime proporcionado.If no base image is provided, the image will be based on the provided runtime parameter.
baseImageRegistry base_image_registry Opcional.Optional. registro de imágenes que contiene la imagen base.Image registry that contains the base image.
cudaVersion cuda_version Opcional.Optional. versión de CUDA que se debe instalar para las imágenes que requieren compatibilidad con GPU.Version of CUDA to install for images that need GPU support. La imagen GPU se debe usar en un servicio de Azure como Azure Container Instances, Proceso de Azure Machine Learning, Azure Virtual Machines y Azure Kubernetes Service.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. Las versiones compatibles son 9.0, 9.1 y 10.0.Supported versions are 9.0, 9.1, and 10.0. Si se establece enable_gpu, el valor predeterminado es 9.1.If enable_gpu is set, the default is 9.1.
description description Una descripción de la imagen.A description for the image.

El siguiente JSON es un ejemplo de la configuración de inferencia que se puede usar con la 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
}

El comando siguiente muestra cómo implementar un modelo mediante la 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

En este ejemplo, la configuración especifica la siguiente configuración:In this example, the configuration specifies the following settings:

  • Este modelo requiere Python.That the model requires Python.
  • El script de entrada, que se usa para controlar las solicitudes web que se envían al servicio implementado.The entry script, which is used to handle web requests sent to the deployed service.
  • El archivo de Conda que describe los paquetes de Python necesarios para realizar la inferencia.The Conda file that describes the Python packages needed for inference.

Para información sobre el uso de una imagen personalizada de Docker con una configuración de inferencia, consulte Cómo implementar un modelo con una imagen personalizada de 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. Definición de la configuración de la implementación3. Define your deployment configuration

Antes de implementar el modelo, debe definir la configuración de esta.Before deploying your model, you must define the deployment configuration. La configuración de implementación es específica del destino de proceso que hospedará el servicio web.The deployment configuration is specific to the compute target that will host the web service. Por ejemplo, cuando implementa un modelo de forma local, debe especificar el puerto en el que el servicio aceptará las solicitudes.For example, when you deploy a model locally, you must specify the port where the service accepts requests. La configuración de la implementación no forma parte del script de entrada.The deployment configuration isn't part of your entry script. Se usa para definir las características del destino de proceso que hospedará el modelo y el script de entrada.It's used to define the characteristics of the compute target that will host the model and entry script.

Es posible que también tenga que crear el recurso de proceso si, por ejemplo, aún no tiene una instancia de Azure Kubernetes Service (AKS) asociada con el área de trabajo.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.

La tabla siguiente proporciona un ejemplo de creación de una configuración de implementación para cada destino de proceso:The following table provides an example of creating a deployment configuration for each compute target:

Destino de procesoCompute target Ejemplo de configuración de implementaciónDeployment configuration example
LocalLocal deployment_config = LocalWebservice.deploy_configuration(port=8890)
Azure Container InstancesAzure Container Instances deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)
Azure Kubernetes ServiceAzure Kubernetes Service deployment_config = AksWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)

Las clases de servicios web locales, de Azure Container Instances y AKS se puede importar desde 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

Generación de perfilesProfiling

Antes de implementar el modelo como un servicio, puede que desee generar un perfil para determinar los requisitos de CPU y memoria óptimos.Before you deploy your model as a service, you might want to profile it to determine optimal CPU and memory requirements. Puede usar el SDK o la CLI para generar perfiles del modelo.You can use either the SDK or the CLI to profile your model. En los siguientes ejemplos se muestra cómo crear un perfil de un modelo mediante el SDK.The following examples show how to profile a model by using the SDK.

Importante

Al usar la generación de perfiles, la configuración de inferencia que proporciona no puede hacer referencia a un entorno de Azure Machine Learning.When you use profiling, the inference configuration that you provide can't reference an Azure Machine Learning environment. En su lugar, defina las dependencias de software mediante el parámetro conda_file del 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)

Este código muestra un resultado similar a la siguiente salida:This code displays a result similar to the following output:

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

Los resultados de la generación de perfiles del modelo se emiten como un objeto Run.Model profiling results are emitted as a Run object.

Para obtener información sobre el uso de la generación de perfiles desde la CLI, consulte el perfil de modelo az ml.For information on using profiling from the CLI, see az ml model profile.

Para más información, consulte estos documentos:For more information, see these documents:

Implementación en el destinoDeploy to target

La implementación usa la configuración de implementación de la configuración de inferencia para implementar los modelos.Deployment uses the inference configuration deployment configuration to deploy the models. El proceso de implementación es similar, independientemente del destino de proceso.The deployment process is similar regardless of the compute target. La implementación en AKS es ligeramente diferente, ya que debe proporcionar una referencia al clúster de AKS.Deploying to AKS is slightly different because you must provide a reference to the AKS cluster.

Implementación localLocal deployment

Para implementar un modelo de forma local, debe tener Docker instalado en la máquina local.To deploy a model locally, you need to have Docker installed on your local machine.

Uso del 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 más información, consulte la documentación de LocalWebservice, Model.deploy() y Webservice.For more information, see the documentation for LocalWebservice, Model.deploy(), and Webservice.

Uso de la CLIUsing the CLI

Para implementar un modelo con la CLI, use el siguiente comando.To deploy a model by using the CLI, use the following command. Reemplace mymodel:1 por el nombre y la versión del 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

Las entradas del documento deploymentconfig.json se asignan a los parámetros de LocalWebservice.deploy_configuration.The entries in the deploymentconfig.json document map to the parameters for LocalWebservice.deploy_configuration. En la tabla siguiente se describe la asignación entre las entidades del documento JSON y los parámetros del método:The following table describes the mapping between the entities in the JSON document and the parameters for the method:

Entidad JSONJSON entity Parámetro del métodoMethod parameter DESCRIPCIÓNDescription
computeType N/DNA El destino de proceso.The compute target. Para los destinos locales, el valor tiene que ser local.For local targets, the value must be local.
port port Puerto local en el que se va a exponer el punto de conexión HTTP del servicio.The local port on which to expose the service's HTTP endpoint.

Este elemento JSON es un ejemplo de la configuración de implementación que se puede usar con la CLI:This JSON is an example deployment configuration for use with the CLI:

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

Para más información, consulte la documentación de az ml model deploy.For more information, see the az ml model deploy documentation.

Servicio web de máquina virtual de Notebook (desarrollo/pruebas)Notebook VM web service (dev/test)

Consulte Implementación de un modelo en las máquinas virtuales de Azure Machine Learning Notebook.See Deploy a model to Azure Machine Learning Notebook VM.

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

Consulte Implementación en Azure Container Instances.See Deploy to Azure Container Instances.

Azure Kubernetes Service (desarrollo/pruebas y producción)Azure Kubernetes Service (dev/test and production)

Consulte Implementación en Azure Kubernetes Service.See Deploy to Azure Kubernetes Service.

Consumo de servicios webConsume web services

Cada servicio web implementado proporciona una API REST, por lo que puede crear aplicaciones cliente en diversos lenguajes de programación.Every deployed web service provides a REST API, so you can create client applications in a variety of programming languages. Si ha habilitado la autenticación por clave para el servicio, deberá proporcionar una clave de servicio como token en el encabezado de la solicitud.If you've enabled key authentication for your service, you need to provide a service key as a token in your request header. Si ha habilitado la autenticación por tokens, deberá proporcionar un token JWT de Azure Machine Learning como token de portador en el encabezado de solicitud.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.

Sugerencia

Puede recuperar el documento JSON del esquema después de implementar el servicio.You can retrieve the schema JSON document after you deploy the service. Use la propiedad swagger_uri del servicio web implementado (por ejemplo, service.swagger_uri) para obtener el URI del archivo Swagger del servicio 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 solicitud-respuestaRequest-response consumption

Este es un ejemplo de cómo invocar el servicio en 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 más información, consulte Consumir un modelo de Azure Machine Learning que está implementado como un servicio web.For more information, see Create client applications to consume web services.

Esquema de servicio web (especificación de OpenAPI)Web service schema (OpenAPI specification)

Si ha usado la generación automática de esquemas con la implementación, puede obtener la dirección de la especificación de OpenAPI para el servicio mediante la propiedad 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 ejemplo, print(service.swagger_uri)). Use una solicitud GET o abra el URI en un explorador para recuperar la especificación.(For example, print(service.swagger_uri).) Use a GET request or open the URI in a browser to retrieve the specification.

El siguiente documento JSON es un ejemplo de un esquema (especificación de OpenAPI) generado para una implementación: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 más información, consulte la especificación de OpenAPI.For more information, see OpenAPI specification.

Para obtener una utilidad que puede crear bibliotecas de cliente a partir de la especificación, consulte swagger-codegen.For a utility that can create client libraries from the specification, see swagger-codegen.

Inferencia por lotesBatch inference

Los destinos de proceso de Azure Machine Learning se crean y administran mediante Azure Machine Learning.Azure Machine Learning Compute targets are created and managed by Azure Machine Learning. Estos se pueden usar para la predicción por lotes en canalizaciones de Azure Machine Learning.They can be used for batch prediction from Azure Machine Learning pipelines.

Para ver un tutorial sobre la inferencia por lotes con Proceso de Azure Machine Learning, consulte Cómo ejecutar predicciones por lotes.For a walkthrough of batch inference with Azure Machine Learning Compute, see How to run batch predictions.

Inferencia de IoT EdgeIoT Edge inference

La compatibilidad con implementaciones en el perímetro está en versión preliminar.Support for deploying to the edge is in preview. Para más información, consulte Implementación de Azure Machine Learning como un módulo de IoT Edge.For more information, see Deploy Azure Machine Learning as an IoT Edge module.

Actualización de servicios webUpdate web services

Para actualizar un servicio web, utilice el método update.To update a web service, use the update method. Puede actualizar el servicio web para que use un nuevo modelo, un nuevo script de entrada o nuevas dependencias que se pueden especificar en una configuración de inferencia.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 más información, consulte la documentación de Webservice.update.For more information, see the documentation for Webservice.update.

Importante

Cuando crea una nueva versión del modelo, debe actualizar manualmente cada servicio que quiera que la use.When you create a new version of a model, you must manually update each service that you want to use it.

Uso del SDKUsing the SDK

El código siguiente muestra cómo usar el SDK para actualizar el modelo, entorno y script de entrada para un servicio 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())

Uso de la CLIUsing the CLI

También puede actualizar un servicio Web con la CLI de ML.You can also update a web service by using the ML CLI. En el ejemplo siguiente se muestra cómo registrar un nuevo modelo y luego actualizar el servicio web para usarlo: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

Sugerencia

En este ejemplo, se usa un documento JSON para pasar la información del modelo del comando de registro al comando de actualización.In this example, a JSON document is used to pass the model information from the registration command into the update command.

Para actualizar el servicio de modo que use un nuevo entorno o script de entrada, cree un archivo de configuración de inferencia y especifíquelo con el 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 más información, consulte la documentación de az ml service update.For more information, see the az ml service update documentation.

Implementación de modelos de forma continuadaContinuously deploy models

Puede implementar continuamente modelos mediante la extensión de Machine Learning para Azure DevOps.You can continuously deploy models by using the Machine Learning extension for Azure DevOps. Puede usar la extensión de Machine Learning para Azure DevOps para desencadenar una canalización de implementación cuando se registra un nuevo modelo de aprendizaje automático en el área de trabajo de 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. Regístrese en Azure Pipelines, lo que hace posible la integración continua y la entrega de la aplicación en cualquier plataforma o nube.Sign up for Azure Pipelines, which makes continuous integration and delivery of your application to any platform or cloud possible. (Tenga en cuenta que Azure Pipelines no es lo mismo que las canalizaciones de Machine Learning).(Note that Azure Pipelines isn't the same as Machine Learning pipelines.)

  2. Cree un proyecto de Azure DevOps.Create an Azure DevOps project.

  3. Instale la extensión de Machine Learning para Azure Pipelines.Install the Machine Learning extension for Azure Pipelines.

  4. Use las conexiones de servicio para configurar una conexión de entidad de servicio para el área de trabajo de Azure Machine Learning para tener acceso a los artefactos.Use service connections to set up a service principal connection to your Azure Machine Learning workspace so you can access your artifacts. Vaya a configuración del proyecto, seleccione Conexiones de servicio y, luego, seleccione Azure Resource Manager:Go to project settings, select Service connections, and then select Azure Resource Manager:

    Selección de Azure Resource ManagerSelect Azure Resource Manager

  5. En la lista Nivel de ámbito, seleccione AzureMLWorkspace y luego escriba el resto de los valores:In the Scope level list, select AzureMLWorkspace, and then enter the rest of the values:

    Selección de AzureMLWorkspace

  6. Para implementar continuamente el modelo de aprendizaje automático mediante Azure Pipelines, seleccione Versión en Canalizaciones.To continuously deploy your machine learning model by using Azure Pipelines, under pipelines, select release. Agregue un artefacto nuevo y seleccione el artefacto del modelo de AzureML y la conexión de servicio que creó en el paso anterior.Add a new artifact, and then select the AzureML Model artifact and the service connection that you created earlier. Seleccione el modelo y la versión para desencadenar una implementación:Select the model and version to trigger a deployment:

    Selección del modelo de AzureMLSelect AzureML Model

  7. Habilite el desencadenador del modelo en el artefacto del modelo.Enable the model trigger on your model artifact. Al activar el desencadenador, cada vez que se registra la versión especificada (es decir, la versión más reciente) de ese modelo en el área de trabajo, se desencadena una canalización de versión de Azure DevOps.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.

    Habilitación del desencadenador de modeloEnable the model trigger

Para más ejemplos y proyectos de muestra, consulte estos repositorios de ejemplo en GitHub:For more sample projects and examples, see these sample repos in GitHub:

Descarga de un modeloDownload a model

Si desea descargar el modelo para usarlo en su propio entorno de ejecución, puede hacerlo con los comandos de SDK/CLI siguientes: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

Modelos de paquetesPackage models

En algunos casos, es posible que desee crear una imagen de Docker sin implementar el modelo (si, por ejemplo, pretende implementar en Azure App Service).In some cases, you might want to create a Docker image without deploying the model (if, for example, you plan to deploy to Azure App Service). O bien, puede que desee descargar la imagen y ejecutarla en una instalación local de Docker.Or you might want to download the image and run it on a local Docker installation. Incluso, puede que desee descargar los archivos usados para compilar la imagen, inspeccionarlos, modificarlos y compilar la imagen manualmente.You might even want to download the files used to build the image, inspect them, modify them, and build the image manually.

El empaquetado de modelos permite hacer estas cosas.Model packaging enables you to do these things. Empaqueta todos los recursos necesarios para hospedar un modelo como servicio web y le permite descargar una imagen de Docker totalmente compilada o los archivos necesarios para compilar una.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. Hay dos maneras de usar el empaquetado del modelos:There are two ways to use model packaging:

Descarga de un modelo empaquetado: descargue una imagen de Docker que contiene el modelo y otros archivos necesarios para hospedarla como servicio web.Download a packaged model: Download a Docker image that contains the model and other files needed to host it as a web service.

Generar un Dockerfile: descargue el Dockerfile, el modelo, el script de entrada y otros recursos necesarios para compilar una imagen de Docker.Generate a Dockerfile: Download the Dockerfile, model, entry script, and other assets needed to build a Docker image. Después, puede inspeccionar los archivos o realizar cambios antes de compilar la imagen localmente.You can then inspect the files or make changes before you build the image locally.

Ambos paquetes se pueden usar para obtener una imagen de Docker local.Both packages can be used to get a local Docker image.

Sugerencia

La creación de un paquete es similar a la implementación de un modelo.Creating a package is similar to deploying a model. Se usa un modelo registrado y una configuración de inferencia.You use a registered model and an inference configuration.

Importante

Para descargar una imagen completamente compilada o compilar una imagen localmente, debe tener Docker instalado en el entorno de desarrollo.To download a fully built image or build an image locally, you need to have Docker installed in your development environment.

Descarga del modelo empaquetadoDownload a packaged model

En el ejemplo siguiente se muestra cómo compilar una imagen, que se registra en el registro de contenedor de Azure del área de trabajo: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)

Después de crear un paquete, puede usar package.pull() para extraer la imagen en el entorno de Docker local.After you create a package, you can use package.pull() to pull the image to your local Docker environment. La salida de este comando mostrará el nombre de la imagen.The output of this command will display the name of the image. Por ejemplo:For example:

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

Después de descargar el modelo, use el comando docker images para ver en una lista las imágenes locales: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 un contenedor local basándose en esta imagen, use el siguiente comando para iniciar un contenedor con nombre desde el shell o desde la línea de comandos.To start a local container based on this image, use the following command to start a named container from the shell or command line. Reemplace el valor <imageid> por el identificador de la imagen que el comando docker images devuelve.Replace the <imageid> value with the image ID returned by the docker images command.

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

Este comando inicia la versión más reciente de la imagen con nombre myimage.This command starts the latest version of the image named myimage. Asigna el puerto local 6789 al puerto del contenedor en el que el servicio web está escuchando (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). También asigna el nombre mycontainer al contenedor, lo que facilita la detención de este.It also assigns the name mycontainer to the container, which makes the container easier to stop. Una vez iniciado el contenedor, puede enviar solicitudes a http://localhost:6789/score.After the container is started, you can submit requests to http://localhost:6789/score.

Generación de un Dockerfile y dependenciasGenerate a Dockerfile and dependencies

En el ejemplo siguiente se muestra cómo descargar el Dockerfile, el modelo y otros recursos necesarios para compilar una imagen localmente.The following example shows how to download the Dockerfile, model, and other assets needed to build an image locally. El parámetro generate_dockerfile=True indica que quiere los archivos, no una imagen completamente 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)

Este código descarga los archivos necesarios para compilar la imagen en el directorio imagefiles.This code downloads the files needed to build the image to the imagefiles directory. El Dockerfile incluido en los archivos guardados hace referencia a una imagen base almacenada en un registro de contenedor de Azure.The Dockerfile included in the saved files references a base image stored in an Azure container registry. Al compilar la imagen en la instalación de Docker local, necesita usar la dirección, el nombre de usuario y la contraseña para autenticarse en el 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. Siga estos pasos para compilar la imagen mediante una instalación local de Docker:Use the following steps to build the image by using a local Docker installation:

  1. Desde un shell o una sesión de línea de comandos, use el comando siguiente para autenticar Docker con el registro de contenedor de Azure.From a shell or command-line session, use the following command to authenticate Docker with the Azure container registry. Reemplace <address>, <username> y <password> por los valores recuperados con 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 compilar la imagen, utilice el siguiente comando.To build the image, use the following command. Reemplace <imagefiles> por la ruta de acceso del directorio donde package.save() guardó los archivos.Replace <imagefiles> with the path of the directory where package.save() saved the files.

    docker build --tag myimage <imagefiles>
    

    Este comando establece el nombre de la imagen en myimage.This command sets the image name to myimage.

Para comprobar la imagen está compilada, use el comando docker images.To verify that the image is built, use the docker images command. Debería ver la imagen myimage en la 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 un nuevo contenedor basado en esta imagen, use el comando siguiente:To start a new container based on this image, use the following command:

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

Este comando inicia la versión más reciente de la imagen con nombre myimage.This command starts the latest version of the image named myimage. Asigna el puerto local 6789 al puerto del contenedor en el que el servicio web está escuchando (5001).It maps local port 6789 to the port in the container on which the web service is listening (5001). También asigna el nombre mycontainer al contenedor, lo que facilita la detención de este.It also assigns the name mycontainer to the container, which makes the container easier to stop. Una vez iniciado el contenedor, puede enviar solicitudes a http://localhost:6789/score.After the container is started, you can submit requests to http://localhost:6789/score.

Cliente de ejemplo para probar el contenedor localExample client to test the local container

El código siguiente es un ejemplo de un cliente de Python que se puede usar con el contenedor: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)

Para ver clientes de ejemplo en otros lenguajes de programación, vea Consumir modelos implementados como servicios web.For example clients in other programming languages, see Consume models deployed as web services.

Detención del contenedor de DockerStop the Docker container

Para detener el contenedor, use el siguiente comando desde una línea de comandos o un shell diferente:To stop the container, use the following command from a different shell or command line:

docker kill mycontainer

Limpieza de recursosClean up resources

Para eliminar un servicio web implementado, use service.delete().To delete a deployed web service, use service.delete(). Para eliminar un modelo registrado, use model.delete().To delete a registered model, use model.delete().

Para más información, consulte la documentación para WebService.delete() y Model.delete().For more information, see the documentation for WebService.delete() and Model.delete().

(Versión preliminar) Implementación de modelo sin código(Preview) No-code model deployment

La implementación del modelo sin código se encuentra actualmente en versión preliminar y admite los siguientes marcos de aprendizaje automático:No-code model deployment is currently in preview and supports the following machine learning frameworks:

Formato Tensorflow SavedModelTensorflow SavedModel format

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 de ONNXONNX models

El registro y la implementación del modelo ONNX se admiten en cualquier gráfico de inferencia de ONNX.ONNX model registration and deployment is supported for any ONNX inference graph. Los pasos de preprocesamiento y postproceso no se admiten actualmente.Preprocess and postprocess steps are not currently supported.

Este es un ejemplo de cómo registrar e implementar un modelo de 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 de Scikit-learnScikit-learn models

Se admite la implementación de modelo sin código para todos los tipos de modelos integrados de Scikit-learn.No code model deployment is supported for all built-in scikit-learn model types.

Este es un ejemplo de cómo registrar e implementar un modelo de sklearn sin código adicional: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])

NOTA: Estas dependencias se incluyen en el contenedor de inferencia sklearn integrado previamente:NOTE: These dependencies are included in the prebuilt sklearn inference container:

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

Pasos siguientesNext steps