Exporta modelos para la predicción

Para entregar predicciones de AI Platform Prediction, debes exportar el 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 el modelo se aplican si realizas el entrenamiento en AI Platform Prediction o si lo haces en otro lugar y solo deseas realizar la implementación en AI Platform Prediction para entregar predicciones.

Una vez que hayas exportado el modelo, consulta la guía sobre cómo implementar modelos para aprender a crear recursos de modelo y versión en AI Platform Prediction a fin de entregar predicciones.

Código personalizado para la 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 de 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 un modelo, exporta el modelo como un directorio de modelos guardados de TensorFlow. Si deseas obtener información sobre cómo exportar un modelo guardado de TensorFlow que puedes implementar en AI Platform Prediction, consulta la guía sobre cómo exportar un modelo guardado para la predicción.

Si deseas implementar el 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 del modelo debe coincidir con una de estas opciones.

En los siguientes ejemplos con pestañas, se muestra 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 del modelo debe coincidir con una de estas opciones.

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 del modelo debe coincidir con una de estas opciones.

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 compilar la canalización, es suficiente para exportar un solo artefacto model.joblib o model.pkl. La implementación de AI Platform Prediction puede usar estos transformadores durante la predicción porque scikit-learn se incluye en la imagen del entorno de ejecución de AI Platform Prediction.

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

En el siguiente ejemplo, se muestra cómo usar código personalizado en una canalización y exportarlo para AI Platform Prediction. En el ejemplo, se usan FunctionTransformer y 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 de 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 la shell para crear dist/my_custom_code-0.1.tar.gz.

Consulta la guía sobre cómo implementar modelos para aprender a implementar este archivo comprimido junto con el 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 Prediction, no es necesario incluirlas en el archivo comprimido.

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

Exporta una rutina de predicción personalizada

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

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

Próximos pasos