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 Prediction y entregar predicciones mediante una rutina de predicción personalizada. Esto te permite personalizar el modo en que AI Platform Prediction responde a cada solicitud de predicción.

En este ejemplo, usarás una rutina de predicción personalizada para realizar un procesamiento previo de la entrada de predicción mediante su escalamiento y hacer un procesamiento posterior de los resultados 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:

  • Entrenar un modelo Keras simple de forma local
  • Crear y, luego, implementar una rutina de predicción personalizada en AI Platform Prediction
  • 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 incluido 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 Prediction que en el diseño del modelo en sí.

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

  • AI Platform Prediction
  • Cloud Storage

Obtén información sobre los precios de AI Platform Prediction y los precios de Cloud Storage. 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 y, luego, implementar un modelo en AI Platform Prediction:

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

Configura el entorno de desarrollo local

Para completar este instructivo, necesitarás lo siguiente:

  • Python 3
  • virtualenv
  • El SDK de Cloud

En la guía de Google Cloud Configura un entorno de desarrollo de Python, se brindan 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 use Python 3.

  3. Activa ese entorno.

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

Configura el proyecto de Google Cloud

  1. Accede a tu Cuenta de Google.

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

  2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

  4. Habilita las API de AI Platform Training & Prediction and Compute Engine.

    Habilita las API

  5. Instala e inicializa el SDK de Cloud.

Autentica la 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 realizar la autenticación:
    1. En Cloud Console, ve a la página Crear clave de la cuenta de servicio.

      Ir a la página Crea una clave de la cuenta de servicio
    2. En la lista desplegable de Cuenta de servicio, selecciona Nueva cuenta de servicio.
    3. Ingresa un nombre en el campo Nombre de cuenta de servicio.
    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 más adelante con Cloud Console. Si desarrollas una app 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. A fin de obtener más información, consulta el control de acceso para AI Platform Prediction.
    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 que AI Platform Prediction esté disponible y crea otra variable de entorno.

REGION="us-central1"

Crea un 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 el modelo.

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

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 los medios y las desviaciones estándar de cada columna de atributos en el primer uso. Luego, usa estas estadísticas de resumen para escalar los datos que encuentra más adelante.

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 un modelo

A continuación, usa preprocess.MySimpleScaler para realizar un procesamiento previo de los datos de iris y, luego, entrena una red neuronal simple con Keras.

Al final, exporta el modelo entrenado por Keras como un archivo HDF5 (.h5) y exporta la instancia 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 Prediction.

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 Prediction cómo cargar un modelo y cómo administrar las solicitudes de predicción.

Escribe el siguiente código 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.

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

Empaqueta un 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 Prediction para que pueda usar el código personalizado a fin de entregar predicciones.

Escribe el siguiente setup.py para definir el paquete:

from setuptools import setup

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

Luego, ejecuta el siguiente comando 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 implementar el modelo en la entrega, AI Platform Prediction necesita acceder a los siguientes archivos 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 modelo, al que el predictor pueda 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 una rutina de predicción personalizada

Crea un recurso de modelo y un recurso de versión para implementar una rutina de predicción personalizada. En primer lugar, define las variables de entorno con los siguientes nombres de los 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 siguiente código de Python:

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 la solicitud. El método predict del predictor los recibe como campos del diccionario **kwargs.

Con el siguiente código, se envía la misma solicitud que antes, sin embargo, esta vez se agrega un campo 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]]

Realiza una limpieza

Para limpiar todos los recursos de GCP usados en este proyecto, puedes borrar el proyecto de GCP que usaste para este 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

Próximos pasos