Como exportar modelos para previsão

Para fornecer previsões com o AI Platform Prediction, exporte seu 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 seguintes métodos de exportação do modelo se aplicam se você realiza treinamentos no AI Platform Prediction ou em outro local e quer implantá-los para o AI Platform Prediction exibir previsões.

Depois de exportar seu modelo, leia o guia para implantar modelos e saiba como criar modelos 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 10 GB ou menos se você usar um tipo de máquina N1 do Compute Engine. Saiba mais sobre tipos de máquinas para previsão on-line.

Exportar um SavedModel do TensorFlow

Se você usar o TensorFlow para treinar um modelo, exporte-o como um diretório TensorFlow SavedModel (em inglês). 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.

Estes exemplos com guias mostram 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 scikit-learn

A classe Pipeline scikit-learn 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.

Estes exemplos com guias mostram 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 Prediction pode usar esses transformadores no momento da previsão, já que o scikit-learn é incluído na imagem do ambiente de execução do AI Platform Prediction.

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

O exemplo a seguir mostra como usar o código personalizado em um pipeline e exportá-lo para a previsão do 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 são incluídas na imagem de ambiente de execução do AI Platform Prediction, não é necessário incluí-las no tarball.

Para ver um tutorial mais aprofundado sobre o uso de código de pipeline personalizado, consulte Como usar código personalizado para pipelines 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. As rotinas de previsão personalizada permitem fornecer ao AI Platform Prediction o código Python que você quer executar no momento da previsão, bem como quaisquer 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