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 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 hasta 10 GB si usas un tipo de máquina 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
dexgboost.Booster
para exportar un archivo llamadomodel.bst
. - Usa
sklearn.externals.joblib
para exportar un archivo llamadomodel.joblib
. - Usa el módulo
pickle
de Python para exportar un archivo llamadomodel.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 llamadomodel.joblib
. - Usa el módulo
pickle
de Python para exportar un archivo llamadomodel.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 varios 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 llamadomodel.joblib
. - Usa el módulo
pickle
de Python para exportar un archivo llamadomodel.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 lo haces, deberás exportar
tu código personalizado como una distribución de fuente
paquete
para que puedas proporcionarlos
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 básicas, pero TransformerMixin
te permite definir un modelo más complejo
transformación que ahorra el estado serializado en el entrenamiento y 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 descubrir cómo
para 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 Prediction, 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 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.
Lee la guía de rutinas de predicción personalizadas para aprender a usarlas.
¿Qué sigue?
- Aprende a implementar el modelo exportado en AI Platform Prediction para entregar predicciones.
- Trabaja con un instructivo sobre el uso de código personalizado para las canalizaciones de scikit-learn.
- Obtén información sobre cómo crear una rutina de predicción personalizada.