Implementa modelos

Puedes alojar tus modelos entrenados en la nube con Cloud ML Engine y usarlos para entregar predicciones. En esta página, se explica cómo implementar tu modelo. Para obtener información general sobre el proceso de predicción, consulta la página de descripción general de las predicciones.

Tanto si entrenas tus modelos en la nube como si los entrenas en otro sitio, puedes implementar los modelos de TensorFlow en Cloud ML Engine y usarlos para entregar predicciones.

Antes de comenzar

Una vez que hayas entrenado tu modelo, debes hacerle ajustes importantes antes de implementarlo en Cloud ML Engine para realizar predicciones.

  • Exporta tu modelo a un modelo guardado.

  • Exporta un grafo específicamente para la predicción y asegúrate de que el tamaño del archivo de tu modelo guardado no supere el límite predeterminado de 250 MB de Cloud ML Engine.

  • Almacena tu modelo guardado en Cloud Storage.

Obtén información sobre los grafos de entrenamiento y cómo entregarlos

Cuando hayas entrenado tu modelo y lo hayas exportado como un modelo guardado, debes seguir algunos pasos importantes antes de poder obtener predicciones.

Existen algunas diferencias clave entre un grafo de entrenamiento y uno de entrega. Los grafos de entrenamiento contienen funciones que no son apropiadas para la entrega, como las siguientes:

  • lectores de archivos
  • colas de entrada
  • capas de retirados
  • funciones de pérdida
  • optimizadores

Debido a que el proceso de entrega de predicciones tiene requisitos distintos al proceso de entrenamiento, la práctica recomendada es exportar un grafo separado específicamente para entregar predicciones.

Obtén información sobre el modelo guardado

Un modelo guardado es el formato recomendado de TensorFlow para guardar modelos. Además, es el formato necesario para implementar los modelos entrenados de TensorFlow en Cloud ML Engine. Exportar tu modelo entrenado como un modelo guardado almacena tu grafo de entrenamiento con los activos, las variables y los metadatos en un formato que Cloud ML Engine puede usar y restablecer para las predicciones.

Después de exportar un modelo guardado, tendrás un directorio de modelos guardados con estos elementos:

Cuando implementas tu modelo guardado en Cloud ML Engine, debes incluir todo el directorio del modelo guardado, no solo el archivo del búfer de protocolo que contiene tu grafo y sus metadatos. Ese archivo suele tener una extensión .pb o .pbtxt.

El modelo guardado te permite almacenar diferentes versiones de un grafo que comparten los mismos activos y variables (o puntos de control). Por ejemplo, puedes desarrollar dos versiones del mismo grafo, una que se ejecute en CPU y otra que se ejecute en GPU.

Obtén más información sobre la estructura del directorio de un modelo guardado.

Comprueba y ajusta el tamaño del modelo

Tu modelo guardado debe tener 250 MB o menos para poder implementarlo en Cloud ML Engine. Esto incluye todos los activos y variables del directorio del modelo guardado, no solo el archivo del búfer de protocolo del modelo guardado (es decir, saved_model.pb o saved_model.pbtxt).

Para verificar el tamaño del modelo mientras lo estás desarrollando, exporta un modelo guardado y comprueba el tamaño del archivo del directorio.

Si tu modelo guardado supera el límite de 250 MB, lleva a cabo estos pasos:

Reduce el tamaño de tu modelo

Reducir el tamaño de tu modelo involucra lo siguiente:

  • Compilar un grafo nuevo usando solo aquello que se necesita para la predicción.
  • Reducir la precisión de las ponderaciones y los datos.

Tomar estas medidas permite reducir el tamaño del modelo guardado a menos de 250 MB y disminuir la latencia de las predicciones. Los beneficios incluyen un mejor rendimiento, y no tener que solicitar y esperar un aumento de cuota.

Compila un grafo de predicción óptimo

El entrenamiento produce muchos puntos de control que no se usan para entregar predicciones. Asegúrate de subir un directorio que solo contenga el modelo que implementarás y no incluya esos artefactos.

Por ejemplo, si exportas resúmenes durante el proceso de entrenamiento para verlos en TensorBoard, asegúrate de que no estén en tu modelo guardado. Los resúmenes de TensorBoard no son necesarios para un grafo de predicción.

Cuando uses un Estimador para el entrenamiento y la predicción, puedes utilizar la función export_savedmodel y obtener un modelo guardado. De lo contrario, puedes usar SavedModelBuilder para exportar un modelo. Consulta el ejemplo de MNIST, que muestra cómo exportar un modelo con SavedModelBuilder con las firmas y etiquetas correctas.

Reduce la precisión para disminuir el tamaño del archivo

Reducir la precisión de las variables y los datos de entrada es una alternativa que reduce significativamente el tamaño de tu modelo, pero tiene cierto costo en la precisión de las predicciones. Los datos de alta precisión se almacenan de forma menos eficiente que los datos de baja precisión. Aunque los datos de baja precisión son una fuente de ruido, una red neuronal puede “ignorar” ese ruido y, aun así, producir predicciones bastante precisas.

Si el uso de estos métodos produce una pérdida demasiado grande en la precisión de las predicciones para tu caso práctico, intenta solicitar un aumento de cuota

  • Reduce el tamaño del archivo disminuyendo el tamaño de las ponderaciones, que adoptan como predeterminados números de punto flotante que son difíciles de almacenar de manera eficiente. Estas ponderaciones almacenadas de forma ineficiente son las que más contribuyen al tamaño total del archivo de modelo.

  • Cuantiza tus datos continuos para reducir el tamaño de tu modelo hasta un 75% sin sacrificar una cantidad significativa de precisión.

  • Usa variables menos precisas. Por ejemplo, cambia el tipo de datos (dtype) de int64 a int32.

  • Reduce el tamaño de otros atributos de entrada en la carpeta assets del directorio de tu modelo guardado. Por ejemplo, usa tamaños de vocabulario menores para los datos de texto.

Herramientas para inspeccionar los grafos y modelos guardados

TensorFlow te proporciona una interfaz de línea de comandos que puedes usar para verificar el estado de ciertos aspectos de tu modelo guardado, como los formatos de entrada y SignatureDefs. Obtén más información sobre la CLI de modelos guardados.

La Herramienta de transformación de grafo de TensorFlow se puede usar para optimizar tu modelo antes de implementarlo. Aunque se explica cómo usar esta herramienta en el contexto de la implementación móvil, también se puede usar con el fin de optimizar modelos para la implementación no móvil.

Obtén más información sobre cómo usar la herramienta de transformación de grafo.

Crea funciones de entrada de entrega

Cuando exportas un grafo de entrega, un paso clave es definir la función de entrada de entrega. Puedes hacerlo en los siguientes momentos del proceso de entrenamiento general:

  • Durante el final del proceso de entrenamiento.
  • Como un proceso separado después de que el entrenamiento esté completo.

Obtén más información sobre las funciones de entrada de entrega.

Crea un grafo de entrega durante el entrenamiento

Esto suele hacerse al final del proceso de entrenamiento, pero de todos modos está relacionado con el entrenamiento.

  1. Define una función de entrada de entrega. El siguiente código de ejemplo es de nuestra muestra del censo:

    def json_serving_input_fn():
        """Build the serving inputs."""
        inputs = {}
        for feat in featurizer.INPUT_COLUMNS:
            inputs[feat.name] = tf.placeholder(shape=[None], dtype=feat.dtype)
    
        return tf.estimator.export.ServingInputReceiver(inputs, inputs)
    
    
  2. Exporta un modelo guardado desde tu Estimador con export_savedmodel pasando la ruta a tu modelo como el parámetro export_dir_base, y el nombre de tu función de entrega como el parámetro serving_input_fn. En el ejemplo del censo, el tipo de Estimador que se usó fue tf.contrib.learn.DNNLinearCombinedClassifier.

Crea un grafo de entrega separado del entrenamiento

Si ya has entrenado tu modelo, puedes obtener predicciones sin volver a entrenarlo. Este proceso es muy similar a la creación de un grafo de entrega durante el entrenamiento. La principal diferencia es que creas un grafo de entrega en una secuencia de comandos de Python separada que ejecutas cuando el entrenamiento haya finalizado. La idea es crear el Estimator con el mismo model_dir que se usó durante el entrenamiento, y luego llamar a export_savedmodel, como se describió anteriormente.

  1. Define una función de entrada de entrega en tu secuencia de comandos de Python de manera similar a como lo haces en el entrenamiento:

    def json_serving_input_fn():
        """Build the serving inputs."""
        inputs = {}
        for feat in featurizer.INPUT_COLUMNS:
            inputs[feat.name] = tf.placeholder(shape=[None], dtype=feat.dtype)
    
        return tf.estimator.export.ServingInputReceiver(inputs, inputs)
    
    
  2. Cuando crees el Estimator, asegúrate de configurar el parámetro model_dir para que sea el mismo que usaste durante el entrenamiento. Esto permite que el Estimator pueda acceder a los puntos de control de los modelos guardados anteriormente.

  3. Por último, usa tu Estimator para llamar a export_savedmodel, pasando la ruta a tu modelo como el parámetro export_dir_base, y el nombre de tu función de entrada de entrega como el parámetro serving_input_fn.

Etiquetas y firmas de TensorFlow

Cuando compilas un grafo de predicción de TensorFlow, debes especificar los valores correctos para las etiquetas y las firmas del grafo. TensorFlow ofrece constantes para estos valores de etiquetas y firmas, que se usan con estos objetivos:

  • Seleccionar un grafo en tu modelo guardado para entregar predicciones.
  • Indicar que estás compilando una firma de predicción para tu grafo de predicción.

Las firmas definen las entradas y salidas de tu grafo. Cuando compilas una firma para tu grafo de predicción, debes especificar una constante de firma válida como el parámetro method_name en build_signature_def. Para la predicción, la mejor opción suele ser PREDICT_METHOD_NAME.

Debes usar una etiqueta a fin de especificar qué grafo de tu modelo guardado se usa para entregar predicciones. En add_meta_graph_and_variables, agrega tag_constants.SERVING en tu lista de tags.

Ve un ejemplo de cómo compilar un grafo de predicción con las constantes correctas para las etiquetas y las firmas.

Crea una versión del modelo

Cloud ML Engine organiza tus modelos entrenados usando recursos de modelo y de versión. Un modelo de Cloud ML Engine es un contenedor de las versiones de tu modelo de aprendizaje automático.

Encontrarás información detallada de los parámetros que necesitas para implementar tu modelo en Cloud ML Engine en la página sobre conceptos de predicción.

Para implementar tu modelo entrenado en Cloud ML Engine, debes llevar a cabo estos pasos:

  • Sube tu directorio de modelo guardado a un depósito de Cloud Storage antes de comenzar.
  • Crea un recurso de modelo de Cloud ML Engine.
  • Crea un recurso de versión de Cloud ML Engine y especifica la ruta de Cloud Storage a tu modelo guardado.
  • Asegúrate de que tu cuenta de servicio de Cloud ML Engine tenga acceso de “lista” al depósito de Cloud Storage que contiene tu modelo guardado, y acceso de “lectura” al modelo guardado dentro del depósito de Cloud Storage. Si no tienes los permisos correctos, tu solicitud para crear una versión fallará. Obtén más información sobre la concesión de permisos para el almacenamiento.

Console

  1. Abre la página Cloud ML Engine en Google Cloud Platform Console.

    Abrir los modelos en GCP Console

  2. Si es necesario, crea el modelo en el que agregarás tu versión nueva:

    1. Haz clic en Crear modelo.

    2. Ingresa un nombre para tu modelo en el cuadro Nombre del modelo.

    3. Haz clic en Crear.

    4. Verifica que hayas regresado a la página Modelos, y que tu modelo nuevo aparezca en la lista.

  3. Selecciona tu modelo de la lista.

  4. Haz clic en Crear una versión en el menú Versiones de la página Detalles del modelo.

  5. Completa el formulario de la página Crear versión:

    1. Ingresa el nombre del modelo en el cuadro Nombre.

    2. Ingresa la ruta de Cloud Storage a tu modelo guardado en el campo Origen.

    3. Haz clic en Crear.

    4. Verifica que hayas regresado a la página Modelos, y que tu versión nueva aparezca en la lista Versiones.

gcloud

  1. Si es necesario, crea el modelo del que estás implementando una versión nueva:

    gcloud ml-engine models create "model_name"
    
  2. De forma opcional, puedes configurar una variable de entorno para almacenar tu ruta de Cloud Storage, cuya escritura podría resultar complicada en el siguiente comando:

    DEPLOYMENT_SOURCE="bucket_path"
    
  3. Crea la versión:

    gcloud ml-engine versions create "version_name"\
        --model "model_name" --origin $DEPLOYMENT_SOURCE
    
  4. Obtén información sobre tu versión nueva:

    gcloud ml-engine versions describe "your_version_name" \
        --model "your_model_name"
    

    Deberías ver un resultado similar a este:

    createTime: '2016-09-29T16:30:45Z'
    deploymentUri: gs://your_bucket_path
    isDefault: true
    name: projects/project_name/models/model_name/versions/version_name
    

Python

Puedes usar la biblioteca cliente de las API de Google para Python con el fin de llamar a la API de Cloud Machine Learning Engine sin crear solicitudes HTTP de forma manual. Antes de ejecutar el siguiente ejemplo de código, debes configurar la autenticación.

  1. Importa los paquetes necesarios para usar las API de Cloud ML Engine del cliente de la API de Google:

    from googleapiclient import discovery
    from googleapiclient import errors
    # Time is for waiting until the request finishes.
    import time
    
  2. Configura las variables del proyecto y del modelo con el formato requerido para las API (projects/project/models/model/versions/version). Además, haz una variable para la ubicación de almacenamiento donde colocas tu modelo guardado:

    projectID = 'projects/{}'.format('project_name')
    modelName = 'model_name'
    modelID = '{}/models/{}'.format(projectID, modelName)
    versionName = 'version_name'
    versionDescription = 'version_description'
    trainedModelLocation = 'gs://bucket_path'
    runtimeVersion = '1.12'
    
  3. Compila la representación de Python de la API de Cloud ML Engine:

    ml = discovery.build('ml', 'v1')
    
  4. Si es necesario, crea el modelo al que pertenece esta versión:

    # Create a dictionary with the fields from the request body.
    requestDict = {'name': modelName,
        'description': 'Another model for testing.'}
    
    # Create a request to call projects.models.create.
    request = ml.projects().models().create(parent=projectID,
                                body=requestDict)
    
    # Make the call.
    try:
        response = request.execute()
    
        # Any additional code on success goes here (logging, etc.)
    
    except errors.HttpError as err:
        # Something went wrong, print out some information.
        print('There was an error creating the model.' +
            ' Check the details:')
        print(err._get_reason())
    
        # Clear the response for next time.
        response = None
    
  5. Crea un diccionario con las entradas para la solicitud de creación de la versión:

    requestDict = {'name': versionName,
        'description': versionDescription,
        'deploymentUri': trainedModelLocation}
    
  6. Crea la solicitud y realiza la llamada de servicio para crear la versión:

    # Create a request to call projects.models.versions.create
    request = ml.projects().models().versions().create(parent=modelID,
                  body=requestDict)
    
    # Make the call.
    try:
        response = request.execute()
    
        # Get the operation name.
        operationID = response['name']
    
        # Any additional code on success goes here (logging, etc.)
    
    except errors.HttpError as err:
        # Something went wrong, print out some information.
        print('There was an error creating the version.' +
              ' Check the details:')
        print(err._get_reason())
    
        # Handle the exception as makes sense for your application.
    
  7. Supervisa el estado de la operación de creación:

    done = False
    request = ml.projects().operations().get(name=operationID)
    
    while not done:
        response = None
    
        # Wait for 300 milliseconds.
        time.sleep(0.3)
    
        # Make the next call.
        try:
            response = request.execute()
    
            # Check for finish.
            done = response.get('done', False)
    
        except errors.HttpError as err:
            # Something went wrong, print out some information.
            print('There was an error getting the operation.' +
                  'Check the details:')
            print(err._get_reason())
            done = True
    

    En este ejemplo, se espera que finalice la creación de la versión, pero es posible que no desees bloquear el procesamiento en tu aplicación.

¿Qué sigue?

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Cloud ML Engine para TensorFlow