Crea una rutina de predicción personalizada con Keras

Logotipo de Colab Ejecuta este instructivo como un notebook en Colab. Logotipo de GitHub Visualiza el notebook en GitHub.

En este instructivo, se muestra cómo implementar un modelo entrenado por Keras en AI Platform y entregar predicciones con una rutina de predicción personalizada. Esto te permite personalizar el modo en el que AI Platform responde a cada solicitud de predicción.

En este ejemplo, usarás una rutina de predicción personalizada para procesar previamente la entrada de predicción mediante su escalamiento y para procesar posteriormente el resultado de la predicción mediante la conversión de los resultados de probabilidad de softmax en strings de etiqueta.

En este instructivo, se presentan los siguientes pasos:

  • Entrena un modelo Keras simple localmente.
  • Crea y luego implementa una rutina de predicción personalizada en AI Platform.
  • Entrega solicitudes de predicción de esa implementación.

Conjunto de datos

En este instructivo, se usa el conjunto de datos Iris de R. A. Fisher, un pequeño conjunto de datos popular para probar el funcionamiento de las técnicas de aprendizaje automático. Cada instancia tiene cuatro atributos numéricos, que son diferentes medidas de una flor, y una etiqueta objetivo que la marca como uno de los tres tipos de iris: Iris setosa, Iris versicolor o Iris virginica.

En este instructivo, se usa la copia del conjunto de datos Iris incluida en la biblioteca de scikit-learn.

Objetivo

El objetivo es entrenar un modelo que use las medidas de una flor como entrada para predecir qué tipo de iris es.

Este instructivo se centra más en el uso de este modelo con AI Platform que en el diseño del modelo en sí.

Costos

En este instructivo, se usan componentes facturables de Google Cloud Platform (GCP):

  • AI Platform
  • Cloud Storage

Obtén información sobre los precios de AI Platform y los precios de Cloud Storage, y usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Antes de comenzar

Debes completar varios pasos antes de poder entrenar e implementar un modelo en AI Platform:

  • Configura tu entorno de desarrollo local.
  • Configura un proyecto de GCP con la facturación y las API necesarias habilitadas.
  • Crea un depósito de Cloud Storage para almacenar tu paquete de entrenamiento y tu modelo entrenado.

Configura tu entorno de desarrollo local

Para completar este instructivo, necesitarás lo siguiente:

  • Python 3
  • virtualenv
  • SDK de Cloud

La guía de Google Cloud Configura un entorno de desarrollo de Python brinda instrucciones detalladas para cumplir con estos requisitos. En los siguientes pasos, se brinda un conjunto abreviado de instrucciones:

  1. Instala Python 3.

  2. Instala virtualenv y crea un entorno virtual que utilice Python 3.

  3. Activa ese entorno.

  4. Completa los pasos en la siguiente sección para instalar el SDK de Cloud.

Configura tu proyecto de GCP

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. Selecciona o crea un proyecto de GCP.

    Ir a la página Administrar recursos

  3. Asegúrate de tener habilitada la facturación para tu proyecto.

    Aprende a habilitar la facturación

  4. Habilita las AI Platform ("Cloud Machine Learning Engine") y Compute Engine API necesarias.

    Habilita las API

  5. Realiza la instalación y la inicialización del SDK de Cloud.

Autentica tu cuenta de GCP

Para configurar la autenticación, debes crear una clave de cuenta de servicio y establecer una variable de entorno para la ruta de acceso del archivo a la clave de la cuenta de servicio.

  1. Crea una clave de cuenta de servicio para la autenticación:
    1. En GCP Console, ve a la página Crear clave de la cuenta de servicio.

      Ir a la página Crear clave de la cuenta de servicio
    2. En la lista desplegable de Cuenta de servicio, selecciona Nueva cuenta de servicio.
    3. En el campo Nombre de la cuenta de servicio, ingresa un nombre.
    4. En la lista desplegable Función, selecciona Machine Learning Engine > Administrador de ML Engine y Almacenamiento > Administrador de objeto de almacenamiento.

      Nota: El campo Función autoriza el acceso de tu cuenta de servicio a los recursos. Puedes ver y cambiar este campo luego con GCP Console. Si desarrollas una aplicación de producción, es posible que tengas que especificar permisos más detallados que Machine Learning Engine > Administrador de ML Engine y Almacenamiento > Administrador de objeto de almacenamiento. Puedes obtener más información si consultas el control de acceso de AI Platform.
    5. Haz clic en Crear. Se descargará en tu computadora un archivo JSON que contiene tu clave.
  2. Configura la variable de entorno GOOGLE_APPLICATION_CREDENTIALS en la ruta de acceso del archivo JSON que contiene la clave de tu cuenta de servicio. Esta variable solo se aplica a tu sesión actual de shell. Por lo tanto, si abres una sesión nueva, deberás volver a configurar la variable.

Crea un depósito de Cloud Storage

Para implementar una rutina de predicción personalizada, debes subir los artefactos de tu modelo entrenado y tu código personalizado a Cloud Storage.

Establece el nombre de tu depósito de Cloud Storage como una variable de entorno. Debe ser único en todos los depósitos de Cloud Storage:

BUCKET_NAME="your-bucket-name"

Selecciona una región en la cual AI Platform Training and Prediction esté disponible y crea otra variable de entorno.

REGION="us-central1"

Crea tu depósito de Cloud Storage en esta región y, a continuación, usa la misma región para el entrenamiento y la predicción. Ejecuta el siguiente comando para crear el depósito si todavía no existe:

gsutil mb -l $REGION gs://$BUCKET_NAME

Compila y entrena un modelo de Keras

A menudo sucede que no puedes usar tus datos sin procesar para entrenar un modelo de aprendizaje automático. Incluso si puedes hacerlo, se recomienda procesar previamente los datos antes de usarlos para el entrenamiento, ya que esto puede mejorar tu modelo.

Si suponemos que esperas que la entrada para la predicción tenga el mismo formato que tus datos de entrenamiento, debes aplicar un procesamiento previo idéntico durante el entrenamiento y la predicción a fin de garantizar que tu modelo realice predicciones coherentes.

En esta sección, crea un módulo de procesamiento previo y úsalo como parte del entrenamiento. Luego, exporta un procesador previo con las características aprendidas durante el entrenamiento de modo que puedas usarlo en tu rutina de predicción personalizada más tarde.

Instala dependencias para el entrenamiento local

El entrenamiento local requiere varias dependencias; utiliza lo siguiente:

pip install numpy scikit-learn 'tensorflow>=1.13,<2'

Escribe tu procesador previo

Escalar los datos de entrenamiento a fin de que cada columna de atributos numéricos tenga una media de 0 y una desviación estándar de 1 puede mejorar tu modelo.

Crea preprocess.py, que contiene una clase para realizar el escalamiento siguiente:

import numpy as np

class MySimpleScaler(object):
  def __init__(self):
    self._means = None
    self._stds = None

  def preprocess(self, data):
    if self._means is None: # during training only
      self._means = np.mean(data, axis=0)

    if self._stds is None: # during training only
      self._stds = np.std(data, axis=0)
      if not self._stds.all():
        raise ValueError('At least one column has standard deviation of 0.')

    return (data - self._means) / self._stds

Observa que una instancia de MySimpleScaler guarda las medias y las desviaciones estándar de cada columna de atributos en el primer uso. Luego, utiliza estas estadísticas de resumen para escalar los datos que encuentra posteriormente.

Esto te permite almacenar características de la distribución del entrenamiento y usarlas para realizar un procesamiento previo idéntico en el momento de la predicción.

Entrena tu modelo

A continuación, usa preprocess.MySimpleScaler para procesar previamente los datos de iris y, luego, entrenar una red neuronal simple con Keras.

Al final, exporta tu modelo entrenado con Keras como un archivo HDF5 (.h5) y, tu instancia de MySimpleScaler, como un archivo pickle (.pkl):

import pickle

from sklearn.datasets import load_iris
import tensorflow as tf

from preprocess import MySimpleScaler

iris = load_iris()
scaler = MySimpleScaler()
num_classes = len(iris.target_names)
X = scaler.preprocess(iris.data)
y = tf.keras.utils.to_categorical(iris.target, num_classes=num_classes)

model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(num_classes, activation=tf.nn.softmax))
model.compile(
  optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X, y, epochs=10, batch_size=1)

model.save('model.h5')
with open ('preprocessor.pkl', 'wb') as f:
  pickle.dump(scaler, f)

Implementa una rutina de predicción personalizada

Si deseas implementar una rutina de predicción personalizada para entregar predicciones desde tu modelo entrenado, haz lo siguiente:

  • Crea un predictor personalizado para que administre las solicitudes.
  • Empaqueta tu predictor y tu módulo de procesamiento previo.
  • Sube los artefactos de tu modelo y tu código personalizado a Cloud Storage.
  • Implementa tu rutina de predicción personalizada en AI Platform.

Crea un predictor personalizado

Para implementar una rutina de predicción personalizada, debes crear una clase que implemente la interfaz de Predictor. Esta le indica a AI Platform cómo cargar tu modelo y administrar las solicitudes de predicción.

Escribe el código siguiente en predictor.py:

import os
import pickle

import numpy as np
from sklearn.datasets import load_iris
import tensorflow as tf

class MyPredictor(object):
  def __init__(self, model, preprocessor):
    self._model = model
    self._preprocessor = preprocessor
    self._class_names = load_iris().target_names

  def predict(self, instances, **kwargs):
    inputs = np.asarray(instances)
    preprocessed_inputs = self._preprocessor.preprocess(inputs)
    outputs = self._model.predict(preprocessed_inputs)
    if kwargs.get('probabilities'):
      return outputs.tolist()
    else:
      return [self._class_names[index] for index in np.argmax(outputs, axis=1)]

  @classmethod
  def from_path(cls, model_dir):
    model_path = os.path.join(model_dir, 'model.h5')
    model = tf.keras.models.load_model(model_path)

    preprocessor_path = os.path.join(model_dir, 'preprocessor.pkl')
    with open(preprocessor_path, 'rb') as f:
      preprocessor = pickle.load(f)

    return cls(model, preprocessor)

Ten en cuenta que, además de usar el procesador previo que definiste durante el entrenamiento, este predictor realiza un paso de procesamiento posterior que convierte el resultado de softmax de la red neuronal (un arreglo que denota la probabilidad de cada etiqueta de ser la correcta) en la etiqueta con la mayor probabilidad.

En cambio, si el predictor recibe un argumento de palabra clave de probabilities con el valor True, muestra el arreglo de probabilidad. En la última parte de este instructivo, se muestra cómo proporcionar este argumento de palabra clave.

Empaqueta tu código personalizado

Debes empaquetar predictor.py y preprocess.py como un paquete de distribución de fuente .tar.gz y proporcionar el paquete a AI Platform de modo que pueda usar tu código personalizado para entregar predicciones.

Escribe el setup.py siguiente para definir tu paquete:

from setuptools import setup

setup(
    name='my_custom_code',
    version='0.1',
    scripts=['predictor.py', 'preprocess.py'])

Luego, ejecuta el comando siguiente para crear dist/my_custom_code-0.1.tar.gz:

python setup.py sdist --formats=gztar

Sube artefactos del modelo y código personalizado a Cloud Storage

Antes de que puedas implementar tu modelo para realizar entregas, AI Platform necesita acceso a los archivos siguientes en Cloud Storage:

  • model.h5 (artefacto de modelo)
  • preprocessor.pkl (artefacto de modelo)
  • my_custom_code-0.1.tar.gz (código personalizado)

Los artefactos de modelo deben almacenarse juntos en un directorio de modelos, al que tu Predictor puede acceder como el argumento model_dir en su método de clase from_path. No es necesario que el código personalizado esté en el mismo directorio. Ejecuta los comandos siguientes para subir tus archivos:

gsutil cp ./dist/my_custom_code-0.1.tar.gz gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz
gsutil cp model.h5 preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/

Implementa tu rutina de predicción personalizada

Crea un recurso de modelo y un recurso de versión para implementar tu rutina de predicción personalizada. En primer lugar, define las variables de entorno con los siguientes nombres de tus recursos:

MODEL_NAME='IrisPredictor'
VERSION_NAME='v1'

Luego, crea tu modelo de la siguiente manera:

gcloud ai-platform models create $MODEL_NAME \
  --regions $REGION

A continuación, crea una versión. En este paso, proporciona las rutas de acceso a los artefactos y al código personalizado que subiste a Cloud Storage:

gcloud components install beta

gcloud beta ai-platform versions create $VERSION_NAME \
  --model $MODEL_NAME \
  --runtime-version 1.13 \
  --python-version 3.5 \
  --origin gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/ \
  --package-uris gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz \
  --prediction-class predictor.MyPredictor

Obtén más información sobre las opciones que debes especificar cuando implementas una rutina de predicción personalizada.

Entrega predicciones en línea

Para probar tu implementación, envía una solicitud de predicción en línea. Primero, instala la biblioteca cliente de las API de Google para Python:

pip install --upgrade google-api-python-client

Luego, envía dos instancias de datos de iris a tu versión implementada. Para ello, ejecuta el código de Python siguiente:

import googleapiclient.discovery

instances = [
  [6.7, 3.1, 4.7, 1.5],
  [4.6, 3.1, 1.5, 0.2],
]

service = googleapiclient.discovery.build('ml', 'v1')
name = 'projects/{}/models/{}/versions/{}'.format(PROJECT_ID, MODEL_NAME, VERSION_NAME)

response = service.projects().predict(
    name=name,
    body={'instances': instances}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])
['versicolor', 'setosa']

Envía argumentos de palabras clave

Cuando envías una solicitud de predicción a una rutina de predicción personalizada, puedes proporcionar campos adicionales en el cuerpo de tu solicitud. El método predict del Predictor los recibe como campos del diccionario **kwargs.

El código siguiente envía la misma solicitud que antes, pero esta vez agrega un campo de probabilities al cuerpo de la solicitud:

response = service.projects().predict(
    name=name,
    body={'instances': instances, 'probabilities': True}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])
[[0.0019204545533284545, 0.8623144626617432, 0.13576509058475494], [0.999488353729248, 0.000511515187099576, 1.293626752385535e-07]]

Limpia

Para limpiar todos los recursos de GCP usados en este proyecto, puedes borrar el proyecto de GCP que utilizaste para el instructivo.

Alternativamente, puedes limpiar recursos individuales; para ello, ejecuta los siguientes comandos:

# Delete version resource
gcloud ai-platform versions delete $VERSION_NAME --quiet --model $MODEL_NAME

# Delete model resource
gcloud ai-platform models delete $MODEL_NAME --quiet

# Delete Cloud Storage objects that were created
gsutil -m rm -r gs://$BUCKET_NAME/custom_prediction_routine_tutorial

Pasos siguientes

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

Enviar comentarios sobre…

¿Necesitas ayuda? Visita nuestra página de asistencia.