Exporta modelos para realizar predicciones

Para entregar predicciones de AI Platform, debes exportar tu modelo de aprendizaje automático entrenado como uno o más artefactos. En esta guía, se describen las diferentes formas de exportar modelos entrenados para su implementación en AI Platform Prediction.

Los siguientes métodos para exportar tu modelo se aplican tanto si realizas el entrenamiento en AI Platform como si lo haces en otro lugar y solo deseas realizar la implementación en AI Platform para entregar predicciones.

Una vez que exportes tu modelo, lee la guía Implementa modelos a fin de aprender a crear recursos de modelo y versión en AI Platform destinados a entregar predicciones.

Código personalizado para predicción

Si exportas una canalización de scikit-learn o una rutina de predicción personalizada, puedes incluir código personalizado para ejecutar en el momento de la predicción, más allá de la rutina de predicción que proporciona tu marco de trabajo de aprendizaje automático. Puedes usar esto para procesar previamente la entrada de predicción, hacer un procesamiento posterior de los resultados de la predicción o agregar registros personalizados.

Tamaño máximo del modelo

El tamaño total del archivo de los artefactos del modelo que implementas en AI Platform Prediction debe ser 500 MB o menos si usas un tipo de máquina heredada (MLS1). Debe ser 2 GB o menos si usas un tipo de máquina (Beta) de Compute Engine (N1). Obtén más información sobre los tipos de máquina para la predicción en línea.

Exporta un modelo guardado de TensorFlow

Si usas TensorFlow para entrenar tu modelo, puedes exportarlo como un directorio de modelos guardados de TensorFlow. Para obtener información sobre cómo exportar un modelo guardado de TensorFlow que puedes implementar en AI Platform Prediction, lee la guía sobre cómo exportar un modelo guardado para predicción.

Si deseas implementar tu modelo de TensorFlow como parte de una rutina de predicción personalizada, puedes exportarlo como un modelo guardado o como un conjunto diferente de artefactos. Lee la guía de rutinas de predicción personalizadas para obtener más información.

Exporta un acelerador de XGBoost

Si usas XGBoost para entrenar un modelo, puedes exportar el modelo entrenado de una de las tres maneras siguientes:

  • Usa el método save_model de xgboost.Booster para exportar un archivo llamado model.bst.
  • Usa sklearn.externals.joblib para exportar un archivo llamado model.joblib.
  • Usa el módulo pickle de Python para exportar un archivo llamado model.pkl.

El nombre de archivo del artefacto de tu modelo debe coincidir exactamente con una de las opciones a continuación.

Los siguientes ejemplos con pestañas muestran cómo entrenar y exportar un modelo en cada una de las tres formas:

xgboost.Booster

from sklearn import datasets
import xgboost as xgb

iris = datasets.load_iris()
dtrain = xgb.DMatrix(iris.data, label=iris.target)
bst = xgb.train({}, dtrain, 20)

bst.save_model('model.bst')

joblib

from sklearn import datasets
from sklearn.externals import joblib
import xgboost as xgb

iris = datasets.load_iris()
dtrain = xgb.DMatrix(iris.data, label=iris.target)
bst = xgb.train({}, dtrain, 20)

joblib.dump(bst, 'model.joblib')

pickle

import pickle

from sklearn import datasets
import xgboost as xgb

iris = datasets.load_iris()
dtrain = xgb.DMatrix(iris.data, label=iris.target)
bst = xgb.train({}, dtrain, 20)

with open('model.pkl', 'wb') as model_file:
  pickle.dump(bst, model_file)

Exporta un Estimador de scikit-learn

Si usas scikit-learn para entrenar un modelo, hay dos maneras de exportarlo:

  • Usa sklearn.externals.joblib para exportar un archivo llamado model.joblib.
  • Usa el módulo pickle de Python para exportar un archivo llamado model.pkl.

El nombre de archivo del artefacto de tu modelo debe coincidir exactamente con una de las opciones a continuación.

Los siguientes ejemplos con pestañas muestran cómo entrenar y exportar un modelo en cada una de las dos formas:

joblib

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib

iris = datasets.load_iris()
classifier = RandomForestClassifier()
classifier.fit(iris.data, iris.target)

joblib.dump(classifier, 'model.joblib')

pickle

import pickle

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier

iris = datasets.load_iris()
classifier = RandomForestClassifier()
classifier.fit(iris.data, iris.target)

with open('model.pkl', 'wb') as model_file:
  pickle.dump(classifier, model_file)

Exporta una canalización de scikit-learn

La clase de canalización de scikit-learn puede ayudarte a componer múltiples estimadores. Por ejemplo, puedes usar transformadores para procesar previamente los datos y pasar los datos transformados a un clasificador. Por otra parte, puedes exportar una canalización de las mismas dos maneras que puedes exportar otros estimadores de scikit-learn:

  • Usa sklearn.externals.joblib para exportar un archivo llamado model.joblib.
  • Usa el módulo pickle de Python para exportar un archivo llamado model.pkl.

El nombre de archivo del artefacto de tu modelo debe coincidir exactamente con una de las opciones a continuación.

Los siguientes ejemplos con pestañas muestran cómo entrenar y exportar un modelo en cada una de las dos formas:

joblib

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib
from sklearn.feature_selection import chi2
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import Pipeline

iris = datasets.load_iris()
pipeline = Pipeline([
      ('feature_selection', SelectKBest(chi2, k=2)),
      ('classification', RandomForestClassifier())
    ])
pipeline.fit(iris.data, iris.target)

joblib.dump(pipeline, 'model.joblib')

pickle

import pickle

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import chi2
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import Pipeline

iris = datasets.load_iris()
pipeline = Pipeline([
      ('feature_selection', SelectKBest(chi2, k=2)),
      ('classification', RandomForestClassifier())
    ])
pipeline.fit(iris.data, iris.target)

with open('model.pkl', 'wb') as model_file:
  pickle.dump(pipeline, model_file)

Exporta código de canalización personalizado

Si solo usas transformadores del paquete sklearn a fin de construir tu canalización, es suficiente para exportar un solo artefacto model.joblib o model.pkl. Tu implementación de AI Platform puede usar estos transformadores en el momento de la predicción porque scikit-learn se incluye en la imagen del entorno de ejecución de AI Platform.

Sin embargo, también puedes usar la clase FunctionTransformer o TransformerMixin de scikit-learn para incorporar transformaciones personalizadas. Si lo haces, debes exportar tu código personalizado como un paquete de distribución de fuente para que puedas proporcionarlo a AI Platform.

En el ejemplo siguiente, se muestra cómo usar el código personalizado en una canalización y exportarlo para AI Platform. En el ejemplo, se usa tanto FunctionTransformer como TransformerMixin. En general, FunctionTransformer puede ser más conveniente para transformaciones simples, pero TransformerMixin te permite definir una transformación más compleja que ahorra el estado serializado en el tiempo de entrenamiento que puede usarse durante la predicción.

Primero, escribe el siguiente código en un archivo llamado my_module.py:

import numpy as np
from sklearn.base import BaseEstimator
from sklearn.base import TransformerMixin
from sklearn.utils.validation import check_is_fitted

def add_sum(X):
  sums = X.sum(1).reshape((-1,1))
  transformed_X = np.append(X, sums, 1)
  return transformed_X

class MySimpleScaler(BaseEstimator, TransformerMixin):
  def fit(self, X, y=None):
    self.means = np.mean(X, axis=0)
    self.stds = np.std(X, axis=0)
    if not self.stds.all():
      raise ValueError('At least one column has standard deviation of 0.')
    return self

  def transform(self, X):
    check_is_fitted(self, ('means', 'stds'))
    transformed_X = (X - self.means) / self.stds
    return transformed_X

Luego, entrena y exporta una canalización mediante las transformaciones siguientes. Alterna entre las siguientes pestañas para ver las siguientes dos formas de exportar la canalización:

joblib

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer

import my_module

iris = datasets.load_iris()
pipeline = Pipeline([
      ('scale_data', my_module.MySimpleScaler()),
      ('add_sum_column', FunctionTransformer(my_module.add_sum)),
      ('classification', RandomForestClassifier())
    ])
pipeline.fit(iris.data, iris.target)

joblib.dump(pipeline, 'model.joblib')

pickle

import pickle

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer

import my_module

iris = datasets.load_iris()
pipeline = Pipeline([
      ('scale_data', my_module.MySimpleScaler()),
      ('add_sum_column', FunctionTransformer(my_module.add_sum)),
      ('classification', RandomForestClassifier())
    ])
pipeline.fit(iris.data, iris.target)

with open('model.pkl', 'wb') as model_file:
  pickle.dump(pipeline, model_file)

Por último, crea un paquete de distribución fuente .tar.gz que contenga my_module. Para hacerlo, primero crea el siguiente archivo setup.py:

from setuptools import setup

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

Luego, ejecuta python setup.py sdist --formats=gztar en tu shell para crear dist/my_custom_code-0.1.tar.gz.

Lee la guía sobre cómo implementar modelos para aprender a implementar este archivo tar junto con tu archivo model.joblib o model.pkl.

Ten en cuenta que my_module.py usa NumPy y scikit-learn como dependencias. Dado que ambas bibliotecas están incluidas en la imagen del entorno de ejecución de AI Platform, no es necesario incluirlas en el archivo tar.

Para obtener un instructivo más detallado sobre el uso de código de canalización personalizado, consulta el instructivo sobre el uso de código personalizado para las canalizaciones de scikit-learn.

Exporta una rutina de predicción personalizada

Para obtener la máxima flexibilidad, crea y exporta una rutina de predicción personalizada. Las rutinas de predicción personalizadas te permiten proporcionar a AI Platform el código de Python que deseas ejecutar en el momento de la predicción, así como cualquier artefacto de entrenamiento que desees usar durante la predicción.

Lee la guía de rutinas de predicción personalizadas para aprender a usarlas.

Próximos pasos