Exportar modelos para previsão

Para exibir predições do AI Platform, exporte o modelo de machine learning treinado como um ou mais artefatos. Neste guia, você verá as diferentes maneiras de exportar modelos treinados para implantação no AI Platform Prediction.

Os métodos de exportação de modelo a seguir serão válidos independentemente de você realizar o treinamento no AI Platform ou em outro lugar e só quiser implantar no AI Platform para exibir previsões.

Depois que você tiver exportado o modelo, leia o guia sobre como implantar modelos para saber como criar recursos de modelo e versão no AI Platform para exibir previsões.

Código personalizado para previsão

Se você exportar um pipeline do scikit-learn ou uma rotina de previsão personalizada, poderá incluir um código personalizado para ser executado no momento da previsão, além da rotina de previsão que seu framework de machine learning oferece. Você pode usar isso para pré-processar a entrada de predição, pós-processar os resultados da predição ou adicionar um registro customizado.

Tamanho máximo do modelo

O tamanho total do arquivo dos artefatos de modelo implantados no AI Platform Prediction precisa ser 500 MB ou inferior se você usar um tipo de máquina legado (MLS1). Ele precisa ter 2 GB ou menos se você usar um tipo de máquina do Compute Engine (N1) (Beta). Saiba mais sobre tipos de máquinas para previsão on-line.

Exportar um SavedModel do TensorFlow

Quando você usa o TensorFlow para treinar um modelo, é possível exportá-lo como um diretório SavedModel do TensorFlow. Para aprender como exportar um SavedModel do TensorFlow implantável no AI Platform Prediction, leia o guia de exportação de SavedModel para previsão.

Se você quiser implantar seu modelo do TensorFlow como parte de uma rotina de previsão personalizada, exporte-o como SavedModel ou como um conjunto diferente de artefatos. Leia o guia sobre rotinas de predição personalizadas para saber mais.

Exportar um booster XGBoost

Se você usar o XGBoost para treinar um modelo, convém exportar o modelo treinado de uma destas três maneiras:

  • Use save_model de xgboost.Booster para exportar um arquivo chamado model.bst.
  • Use sklearn.externals.joblib para exportar um arquivo chamado model.joblib.
  • Use o módulo pickle do Python para exportar um arquivo chamado model.pkl.

O nome de arquivo do artefato de modelo precisa corresponder exatamente a uma dessas opções.

Nestes exemplos com guias, mostramos como treinar e exportar um modelo de três maneiras:

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)

Exportar um estimador scikit-learn

Se você usar scikit-learn para treinar um modelo, convém exportá-lo de duas maneiras:

  • Use sklearn.externals.joblib para exportar um arquivo chamado model.joblib.
  • Use o módulo pickle do Python para exportar um arquivo chamado model.pkl.

O nome de arquivo do artefato de modelo precisa corresponder exatamente a uma dessas opções.

Nestes exemplos com guias, mostramos como treinar e exportar um modelo de duas maneiras:

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)

Exportar um pipeline do scikit-learn

A classe Pipeline do scikit-learn (em inglês) pode ajudar a escrever vários estimadores. Por exemplo, use transformadores a fim de pré-processar dados e passar os dados transformados para um classificador. Exporte um pipeline das mesmas duas maneiras que é possível exportar outros estimadores scikit-learn:

  • Use sklearn.externals.joblib para exportar um arquivo chamado model.joblib.
  • Use o módulo pickle do Python para exportar um arquivo chamado model.pkl.

O nome de arquivo do artefato de modelo precisa corresponder exatamente a uma dessas opções.

Nestes exemplos com guias, mostramos como treinar e exportar um modelo de duas maneiras:

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)

Exportar código de pipeline personalizado

Se você usar somente transformadores do pacote sklearn para criar seu canal, basta exportar um único artefato model.joblib ou model.pkl. Sua implantação do AI Platform pode usar esses transformadores no momento da previsão, uma vez que o scikit-learn está incluído na imagem do ambiente de execução do AI Platform.

No entanto, também é possível usar o scikit-learn FunctionTransformer ou TransformerMixin para incorporar transformações personalizadas. Se você fizer isso, será preciso exportar seu código personalizado como um pacote de distribuição de origem para que seja possível fornecê-lo ao AI Platform (links em inglês).

O exemplo a seguir mostra como usar o código personalizado em um pipeline e exportá-lo para o AI Platform. No exemplo, usamos FunctionTransformer e TransformerMixin. Em geral, FunctionTransformer pode ser mais conveniente para transformações simples, mas TransformerMixin permite definir uma transformação mais complexa que salva o estado serializado no momento do treinamento que pode ser usado durante a previsão.

Primeiro, escreva o código a seguir em um arquivo chamado 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

Em seguida, treine e exporte um pipeline usando as transformações a seguir. Alterne entre as guias a seguir para visualizar as duas maneiras de exportar o pipeline:

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 fim, crie um pacote de distribuição de origem .tar.gz contendo my_module. Para fazer isso, primeiro crie o arquivo setup.py a seguir:

from setuptools import setup

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

Em seguida, execute python setup.py sdist --formats=gztar no seu shell para criar dist/my_custom_code-0.1.tar.gz.

Leia o guia sobre implantação de modelos para saber como implantar esse tarball com o arquivo model.joblib ou model.pkl.

Observe que my_module.py usa o NumPy e o scikit-learn como dependências. Como essas duas bibliotecas estão incluídas na imagem do ambiente de execução do AI Platform, não é necessário incluí-las no tarball.

Para ver um tutorial mais detalhado sobre o uso de código de pipeline personalizado, consulte Como usar código personalizado para pipelines do scikit-learn.

Exportar uma rotina de previsão personalizada

Para ter o máximo de flexibilidade, crie e exporte uma rotina de previsão personalizada. Com as rotinas de previsão personalizadas, é possível fornecer ao AI Platform o código Python que você quer executar no momento da previsão, bem como os artefatos de treinamento que você quer usar durante a previsão.

Leia o guia para rotinas de previsão personalizadas para aprender como usá-las.

A seguir