Usar un modelo existente con Azure Machine LearningUse an existing model 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)

Obtenga información sobre cómo usar un modelo de Machine Learning existente con Azure Machine Learning.Learn how to use an existing machine learning model with Azure Machine Learning.

Si tiene un modelo de Machine Learning que fue entrenado fuera de Azure Machine Learning, aún puede usar el servicio para implementar el modelo como un servicio web o en un dispositivo de IoT Edge.If you have a machine learning model that was trained outside Azure Machine Learning, you can still use the service to deploy the model as a web service or to an IoT Edge device.

Sugerencia

En este artículo se proporciona información básica sobre registrar e implementar un modelo existente.This article provides basic information on registering and deploying an existing model. Una vez implementado, Azure Machine Learning supervisa el modelo.Once deployed, Azure Machine Learning provides monitoring for your model. También permite almacenar los datos de entrada enviados a la implementación, que puede usarse para realizar análisis de desplazamiento de datos o para entrenar nuevas versiones del modelo.It also allows you to store input data sent to the deployment, which can be used for data drift analysis or training new versions of the model.

Para obtener más información sobre los conceptos y términos usados aquí, consulte Manage, deploy, and monitor machine learning models (Administrar, implementar y supervisar los modelos de Machine Learning).For more information on the concepts and terms used here, see Manage, deploy, and monitor machine learning models.

Para obtener información general sobre el proceso de implementación, consulte Implementación de modelos con Azure Machine Learning.For general information on the deployment process, see Deploy models with Azure Machine Learning.

Requisitos previosPrerequisites

  • Un área de trabajo de Azure Machine Learning.An Azure Machine Learning workspace. Para obtener más información, consulte Create a workspace (Crear un área de trabajo).For more information, see Create a workspace.

    Sugerencia

    Los ejemplos de Python de este artículo asumen que la variable ws está configurada en su área de trabajo de Azure Machine Learning.The Python examples in this article assume that the ws variable is set to your Azure Machine Learning workspace.

    Los ejemplos de CLI usan un marcador de posición de myworkspace y myresourcegroup.The CLI examples use a placeholder of myworkspace and myresourcegroup. Reemplácelos con el nombre de su área de trabajo y el grupo de recursos que lo contiene.Replace these with the name of your workspace and the resource group that contains it.

  • El SDK de Azure Machine Learning.The Azure Machine Learning SDK.

  • La CLI de Azure y la extensión de la CLI de Machine Learning.The Azure CLI and Machine Learning CLI extension.

  • Un modelo entrenado.A trained model. El modelo debe almacenarse en uno o varios archivos del entorno de desarrollo.The model must be persisted to one or more files on your development environment.

    Nota

    Para demostrar el registro de un modelo entrenado fuera de Azure Machine Learning, los fragmentos de código de ejemplo que se indican en este artículo usan los modelos que creó en el proyecto de análisis de opinión de Twitter de Paolo Ripamonti: https://www.kaggle.com/paoloripamonti/twitter-sentiment-analysis.To demonstrate registering a model trained outside Azure Machine Learning, the example code snippets in this article use the models created by Paolo Ripamonti's Twitter sentiment analysis project: https://www.kaggle.com/paoloripamonti/twitter-sentiment-analysis.

Registrar los modelosRegister the model(s)

Al registrar un modelo, podrá almacenar, editar y realizar un seguimiento de los metadatos correspondientes a los modelos de su área de trabajo.Registering a model allows you to store, version, and track metadata about models in your workspace. En los siguientes ejemplos de Python y CLI, el directorio models contiene los archivos model.h5, model.w2v, encoder.pkl y tokenizer.pkl.In the following Python and CLI examples, the models directory contains the model.h5, model.w2v, encoder.pkl, and tokenizer.pkl files. En este ejemplo se cargan los archivos contenidos en el directorio models como un nuevo registro de modelo denominado sentiment:This example uploads the files contained in the models directory as a new model registration named sentiment:

from azureml.core.model import Model
# Tip: When model_path is set to a directory, you can use the child_paths parameter to include
#      only some of the files from the directory
model = Model.register(model_path = "./models",
                       model_name = "sentiment",
                       description = "Sentiment analysis model trained outside Azure Machine Learning",
                       workspace = ws)

Para obtener más información, consulte la referencia Model.register().For more information, see the Model.register() reference.

az ml model register -p ./models -n sentiment -w myworkspace -g myresourcegroup

Para obtener más información, consulte la referencia az ml model register.For more information, see the az ml model register reference.

Para obtener más información sobre el registro de modelos en general, consulte Manage, deploy, and monitor machine learning models (Administrar, implementar y supervisar los modelos de Machine Learning).For more information on model registration in general, see Manage, deploy, and monitor machine learning models.

Definir la configuración de inferenciaDefine inference configuration

La configuración de inferencia define el entorno que se usa para ejecutar el modelo implementado.The inference configuration defines the environment used to run the deployed model. La configuración de inferencia hace referencia a las siguientes entidades, las cuales se usan para ejecutar el modelo cuando se implementa:The inference configuration references the following entities, which are used to run the model when it's deployed:

  • Un script de entrada.An entry script. Este archivo (denominado score.py) carga el modelo cuando se inicia el servicio implementado.This file (named score.py) loads the model when the deployed service starts. También se encarga de recibir datos, pasarlos al modelo y devolver una respuesta.It is also responsible for receiving data, passing it to the model, and then returning a response.
  • Un entorno de Azure Machine Learning.An Azure Machine Learning environment. Un entorno define las dependencias de software necesarias para ejecutar el modelo y el script de entrada.An environment defines the software dependencies needed to run the model and entry script.

En el ejemplo siguiente se muestra cómo usar el SDK para crear un entorno y, a continuación, usarlo con una configuración de inferencia:The following example shows how to use the SDK to create an environment and then use it with an inference configuration:

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

# Create the environment
myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Define the packages needed by the model and scripts
conda_dep.add_conda_package("tensorflow")
conda_dep.add_conda_package("numpy")
conda_dep.add_conda_package("scikit-learn")
conda_dep.add_pip_package("keras")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

inference_config = InferenceConfig(entry_script="score.py",
                                   environment=myenv)

Para más información, consulte los siguientes artículos.For more information, see the following articles:

La CLI carga la configuración de inferencia de un archivo YAML:The CLI loads the inference configuration from a YAML file:

{
   "entryScript": "score.py",
   "runtime": "python",
   "condaFile": "myenv.yml"
}

Con la CLI, el entorno de Conda se define en el archivo myenv.yml al que hace referencia la configuración de inferencia.With the CLI, the conda environment is defined in the myenv.yml file referenced by the inference configuration. El siguiente código YAML es el contenido de este archivo:The following YAML is the contents of this file:

name: inference_environment
dependencies:
- python=3.6.2
- tensorflow
- numpy
- scikit-learn
- pip:
    - azureml-defaults
    - keras

Para más información sobre la configuración de inferencia, consulte Implementación de modelos con Azure Machine Learning.For more information on inference configuration, see Deploy models with Azure Machine Learning.

Script de entradaEntry script

El script de entrada tiene solo dos funciones requeridas: init() y run(data).The entry script has only two required functions, init() and run(data). Estas funciones se usan para inicializar el servicio en el inicio y ejecutar el modelo usando para ello los datos de solicitud que pase un cliente.These functions are used to initialize the service at startup and run the model using request data passed in by a client. El resto del script se encarga de cargar y ejecutar los modelos.The rest of the script handles loading and running the model(s).

Importante

No hay un script de entrada genérico que funcione para todos los modelos.There isn't a generic entry script that works for all models. Siempre es específico para el modelo que se usa.It is always specific to the model that is used. Debe comprender cómo cargar el modelo, el formato de datos que espera el modelo y cómo puntuar los datos mediante ese modelo.It must understand how to load the model, the data format that the model expects, and how to score data using the model.

El siguiente código de Python es un script de entrada de ejemplo (score.py):The following Python code is an example entry script (score.py):

import os
import pickle
import json
import time
from keras.models import load_model
from keras.preprocessing.sequence import pad_sequences
from gensim.models.word2vec import Word2Vec

# SENTIMENT
POSITIVE = "POSITIVE"
NEGATIVE = "NEGATIVE"
NEUTRAL = "NEUTRAL"
SENTIMENT_THRESHOLDS = (0.4, 0.7)
SEQUENCE_LENGTH = 300

# Called when the deployed service starts
def init():
    global model
    global tokenizer
    global encoder
    global w2v_model

    # Get the path where the deployed model can be found.
    model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), './models')
    # load models
    model = load_model(model_path + '/model.h5')
    w2v_model = Word2Vec.load(model_path + '/model.w2v')

    with open(model_path + '/tokenizer.pkl','rb') as handle:
        tokenizer = pickle.load(handle)

    with open(model_path + '/encoder.pkl','rb') as handle:
        encoder = pickle.load(handle)

# Handle requests to the service
def run(data):
    try:
        # Pick out the text property of the JSON request.
        # This expects a request in the form of {"text": "some text to score for sentiment"}
        data = json.loads(data)
        prediction = predict(data['text'])
        #Return prediction
        return prediction
    except Exception as e:
        error = str(e)
        return error

# Determine sentiment from score
def decode_sentiment(score, include_neutral=True):
    if include_neutral:
        label = NEUTRAL
        if score <= SENTIMENT_THRESHOLDS[0]:
            label = NEGATIVE
        elif score >= SENTIMENT_THRESHOLDS[1]:
            label = POSITIVE
        return label
    else:
        return NEGATIVE if score < 0.5 else POSITIVE

# Predict sentiment using the model
def predict(text, include_neutral=True):
    start_at = time.time()
    # Tokenize text
    x_test = pad_sequences(tokenizer.texts_to_sequences([text]), maxlen=SEQUENCE_LENGTH)
    # Predict
    score = model.predict([x_test])[0]
    # Decode sentiment
    label = decode_sentiment(score, include_neutral=include_neutral)

    return {"label": label, "score": float(score),
       "elapsed_time": time.time()-start_at}  

Para más información sobre los scripts de entrada, consulte Implementación de modelos con Azure Machine Learning.For more information on entry scripts, see Deploy models with Azure Machine Learning.

Definir la implementaciónDefine deployment

El paquete Webservice contiene las clases que se usan en la implementación.The Webservice package contains the classes used for deployment. La clase que use determinará dónde se implementa el modelo.The class you use determines where the model is deployed. Por ejemplo, para implementar un servicio web en Azure Kubernetes Service, use AksWebService.deploy_configuration() para crear la configuración de implementación.For example, to deploy as a web service on Azure Kubernetes Service, use AksWebService.deploy_configuration() to create the deployment configuration.

El código Python siguiente define una configuración de implementación para una implementación local.The following Python code defines a deployment configuration for a local deployment. Esta configuración implementa el modelo como un servicio web en el equipo local.This configuration deploys the model as a web service to your local computer.

Importante

Asimismo, una implementación local requiere una instalación de Docker que funcione en el equipo local:A local deployment requires a working installation of Docker on your local computer:

from azureml.core.webservice import LocalWebservice

deployment_config = LocalWebservice.deploy_configuration()

Para obtener más información sobre, consulte la referencia LocalWebservice.deploy_configuration().For more information, see the LocalWebservice.deploy_configuration() reference.

La CLI carga la configuración de implementación de un archivo YAML:The CLI loads the deployment configuration from a YAML file:

{
    "computeType": "LOCAL"
}

La implementación en un destino de proceso diferente, como Azure Kubernetes Service en la nube de Azure, es tan fácil como cambiar la configuración de la implementación.Deploying to a different compute target, such as Azure Kubernetes Service in the Azure cloud, is as easy as changing the deployment configuration. Para obtener más información, consulte How and where to deploy models (Cómo y dónde implementar modelos).For more information, see How and where to deploy models.

Implementación del modeloDeploy the model

En el ejemplo siguiente se carga la información en el modelo registrado denominado sentiment y, a continuación, se implementa como un servicio denominado sentiment.The following example loads information on the registered model named sentiment, and then deploys it as a service named sentiment. Durante la implementación, la configuración de inferencia y la configuración de implementación se usan para crear y configurar el entorno de servicio:During deployment, the inference configuration and deployment configuration are used to create and configure the service environment:

from azureml.core.model import Model

model = Model(ws, name='sentiment')
service = Model.deploy(ws, 'myservice', [model], inference_config, deployment_config)

service.wait_for_deployment(True)
print(service.state)
print("scoring URI: " + service.scoring_uri)

Para obtener más información, consulte la referencia Model.deploy().For more information, see the Model.deploy() reference.

Para implementar el modelo de la CLI, use el comando siguiente.To deploy the model from the CLI, use the following command. Este comando implementa la versión 1 del modelo registrado (sentiment:1) mediante la configuración de implementación y la inferencia almacenadas en los archivos inferenceConfig.json y deploymentConfig.json:This command deploys version 1 of the registered model (sentiment:1) using the inference and deployment configuration stored in the inferenceConfig.json and deploymentConfig.json files:

az ml model deploy -n myservice -m sentiment:1 --ic inferenceConfig.json --dc deploymentConfig.json

Para obtener más información, consulte la referencia az ml model deploy.For more information, see the az ml model deploy reference.

Para obtener más información sobre la implementación, consulte How and where to deploy models (Cómo y dónde implementar modelos).For more information on deployment, see How and where to deploy models.

Consumo de solicitud-respuestaRequest-response consumption

Después de la implementación, se muestra el URI de puntuación.After deployment, the scoring URI is displayed. Los clientes pueden usar este URI para enviar solicitudes al servicio.This URI can be used by clients to submit requests to the service. En el ejemplo siguiente se muestra un cliente básico de Python que envía datos al servicio y muestra la respuesta:The following example is a basic Python client that submits data to the service and displays the response:

import requests
import json

scoring_uri = 'scoring uri for your service'
headers = {'Content-Type':'application/json'}

test_data = json.dumps({'text': 'Today is a great day!'})

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

Para obtener más información sobre cómo consumir el servicio implementado, consulte Create a client (Crear un cliente).For more information on how to consume the deployed service, see Create a client.

Pasos siguientesNext steps