Rutinitas prediksi kustom

Rutinitas prediksi kustom memungkinkan Anda menentukan kode yang berjalan saat Anda mengirim permintaan prediksi online ke AI Platform Prediction.

Saat Anda men-deploy resource versi ke AI Platform Prediction tanpa menggunakan rutinitas prediksi kustom, resource tersebut akan menangani permintaan prediksi dengan melakukan operasi prediksi framework machine learning yang Anda gunakan untuk pelatihan.

Namun, saat men-deploy rutinitas prediksi kustom sebagai resource versi, Anda dapat memberi tahu AI Platform Prediction untuk menjalankan kode Python kustom sebagai respons terhadap setiap permintaan prediksi yang diterimanya. Anda dapat memproses input prediksi sebelum model terlatih melakukan prediksi, atau Anda dapat memproses prediksi model sebelum mengirim hasil prediksi.

Untuk membuat rutinitas prediksi kustom, Anda harus memberikan dua bagian ke AI Platform Prediction saat membuat versi model:

  • Direktori model di Cloud Storage, yang berisi artefak apa pun yang perlu digunakan untuk prediksi.

  • Paket distribusi sumber Python .tar.gz di Cloud Storage yang berisi implementasi antarmuka Predictor dan kode kustom lainnya yang ingin Anda gunakan oleh AI Platform Prediction pada waktu prediksi.

Anda hanya dapat men-deploy rutinitas prediksi kustom saat menggunakan jenis mesin lama (MLS1) untuk versi model Anda.

Mengupload artefak model ke direktori model Anda

Ikuti panduan untuk men-deploy model guna mengupload model terlatih ke Cloud Storage, beserta file lain yang menyediakan data atau status untuk digunakan AI Platform Prediction selama prediksi.

Ukuran file total artefak model yang Anda deploy ke AI Platform Prediction harus 500 MB atau kurang.

Anda dapat mengupload model machine learning terlatih ke direktori model sebagai SavedModel TensorFlow, file model.joblib, file model.pkl, atau file model.bst, tetapi Anda juga dapat menyediakan model sebagai file HDF5 yang berisi model tf.keras terlatih atau dalam format serialisasi yang berbeda.

Anda juga dapat menyertakan file pickle dengan instance class preprosesor kustom yang menyimpan status serialisasi dari pelatihan.

Misalnya, pertimbangkan preprocessor berikut, yang ditentukan dalam file bernama preprocess.py:

import numpy as np


class ZeroCenterer(object):
    """Stores means of each column of a matrix and uses them for preprocessing."""

    def __init__(self):
        """On initialization, is not tied to any distribution."""
        self._means = None

    def preprocess(self, data):
        """Transforms a matrix.

        The first time this is called, it stores the means of each column of
        the input. Then it transforms the input so each column has mean 0. For
        subsequent calls, it subtracts the stored means from each column. This
        lets you 'center' data at prediction time based on the distribution of
        the original training data.

        Args:
            data: A NumPy matrix of numerical data.

        Returns:
            A transformed matrix with the same dimensions as the input.
        """
        if self._means is None:  # during training only
            self._means = np.mean(data, axis=0)
        return data - self._means

Selama pelatihan pada set data numerik, preprocessor memusatkan data di sekitar 0 dengan mengurangi rata-rata setiap kolom dari setiap nilai dalam kolom. Kemudian, Anda dapat mengekspor instance preprocessor sebagai file pickle, preprocessor.pkl, yang mempertahankan rata-rata setiap kolom yang dihitung dari data pelatihan.

Selama prediksi, rutinitas prediksi kustom dapat memuat praprosesor dari file ini untuk melakukan transformasi yang identik pada input prediksi.

Untuk mempelajari cara menggunakan preprocessor stateful seperti ini dalam rutinitas prediksi kustom, baca bagian berikutnya, yang menjelaskan cara mengimplementasikan antarmuka Predictor.

Untuk mempelajari contoh lengkap penggunaan preprocessor stateful selama pelatihan dan prediksi, baca Membuat rutinitas prediksi kustom dengan Keras atau Membuat rutinitas prediksi kustom dengan scikit-learn.

Membuat Prediktor

Beri tahu AI Platform Prediction cara menangani permintaan prediksi dengan menyediakan class Predictor. Ini adalah class yang mengimplementasikan antarmuka berikut:

class Predictor(object):
    """Interface for constructing custom predictors."""

    def predict(self, instances, **kwargs):
        """Performs custom prediction.

        Instances are the decoded values from the request. They have already
        been deserialized from JSON.

        Args:
            instances: A list of prediction input instances.
            **kwargs: A dictionary of keyword args provided as additional
                fields on the predict request body.

        Returns:
            A list of outputs containing the prediction results. This list must
            be JSON serializable.
        """
        raise NotImplementedError()

    @classmethod
    def from_path(cls, model_dir):
        """Creates an instance of Predictor using the given path.

        Loading of the predictor should be done in this method.

        Args:
            model_dir: The local directory that contains the exported model
                file along with any additional files uploaded when creating the
                version resource.

        Returns:
            An instance implementing this Predictor class.
        """
        raise NotImplementedError()

Node prediksi AI Platform Prediction menggunakan metode class from_path untuk memuat instance Predictor Anda. Metode ini akan memuat artefak yang Anda simpan di direktori model, yang kontennya dikopy dari Cloud Storage ke lokasi yang ditampilkan oleh argumen model_dir.

Setiap kali deployment Anda menerima permintaan prediksi online, instance class Predictor yang ditampilkan oleh from_path akan menggunakan metode predict-nya untuk menghasilkan prediksi. AI Platform Prediction melakukan serialisasi nilai yang ditampilkan dari metode ini ke JSON dan mengirimkannya sebagai respons terhadap permintaan prediksi.

Perhatikan bahwa metode predict tidak perlu mengonversi input dari JSON menjadi objek Python atau mengonversi output menjadi JSON; AI Platform Prediction menangani hal ini di luar metode predict.

AI Platform Prediction menyediakan argumen instances dengan mengurai kolom instances dari isi permintaan predict ke AI Platform Training and Prediction API. Class ini mengurai kolom lain dari isi permintaan dan memberikannya ke metode predict sebagai entri dalam kamus **kwargs. Untuk mempelajari lebih lanjut, baca cara menyusun permintaan predict ke Training API dan Prediction API AI Platform.

Melanjutkan contoh dari bagian sebelumnya, misalkan direktori model Anda berisi preprocessor.pkl (instance pickled dari class ZeroCenterer) dan model tf.keras terlatih yang diekspor sebagai model.h5atau model scikit-learn terlatih yang diekspor sebagai model.joblib.

Bergantung pada framework machine learning yang Anda gunakan, terapkan salah satu class Predictor berikut dalam file yang disebut predictor.py:

TensorFlow

import os
import pickle

import numpy as np
from tensorflow import keras


class MyPredictor(object):
    """An example Predictor for an AI Platform custom prediction routine."""

    def __init__(self, model, preprocessor):
        """Stores artifacts for prediction. Only initialized via `from_path`."""
        self._model = model
        self._preprocessor = preprocessor

    def predict(self, instances, **kwargs):
        """Performs custom prediction.

        Preprocesses inputs, then performs prediction using the trained Keras
        model.

        Args:
            instances: A list of prediction input instances.
            **kwargs: A dictionary of keyword args provided as additional
                fields on the predict request body.

        Returns:
            A list of outputs containing the prediction results.
        """
        inputs = np.asarray(instances)
        preprocessed_inputs = self._preprocessor.preprocess(inputs)
        outputs = self._model.predict(preprocessed_inputs)
        return outputs.tolist()

    @classmethod
    def from_path(cls, model_dir):
        """Creates an instance of MyPredictor using the given path.

        This loads artifacts that have been copied from your model directory in
        Cloud Storage. MyPredictor uses them during prediction.

        Args:
            model_dir: The local directory that contains the trained Keras
                model and the pickled preprocessor instance. These are copied
                from the Cloud Storage model directory you provide when you
                deploy a version resource.

        Returns:
            An instance of `MyPredictor`.
        """
        model_path = os.path.join(model_dir, "model.h5")
        model = keras.models.load_model(model_path)

        preprocessor_path = os.path.join(model_dir, "preprocessor.pkl")
        with open(preprocessor_path, "rb") as f:
            preprocessor = pickle.load(f)

        return cls(model, preprocessor)

scikit-learn

import os
import pickle

import numpy as np
from sklearn.externals import joblib


class MyPredictor(object):
    """An example Predictor for an AI Platform custom prediction routine."""

    def __init__(self, model, preprocessor):
        """Stores artifacts for prediction. Only initialized via `from_path`."""
        self._model = model
        self._preprocessor = preprocessor

    def predict(self, instances, **kwargs):
        """Performs custom prediction.

        Preprocesses inputs, then performs prediction using the trained
        scikit-learn model.

        Args:
            instances: A list of prediction input instances.
            **kwargs: A dictionary of keyword args provided as additional
                fields on the predict request body.

        Returns:
            A list of outputs containing the prediction results.
        """
        inputs = np.asarray(instances)
        preprocessed_inputs = self._preprocessor.preprocess(inputs)
        outputs = self._model.predict(preprocessed_inputs)
        return outputs.tolist()

    @classmethod
    def from_path(cls, model_dir):
        """Creates an instance of MyPredictor using the given path.

        This loads artifacts that have been copied from your model directory in
        Cloud Storage. MyPredictor uses them during prediction.

        Args:
            model_dir: The local directory that contains the trained
                scikit-learn model and the pickled preprocessor instance. These
                are copied from the Cloud Storage model directory you provide
                when you deploy a version resource.

        Returns:
            An instance of `MyPredictor`.
        """
        model_path = os.path.join(model_dir, "model.joblib")
        model = joblib.load(model_path)

        preprocessor_path = os.path.join(model_dir, "preprocessor.pkl")
        with open(preprocessor_path, "rb") as f:
            preprocessor = pickle.load(f)

        return cls(model, preprocessor)

Perhatikan bahwa metode predict mengonversi hasil prediksi menjadi daftar dengan metode tolist sebelum menampilkannya. Array NumPy tidak dapat diserialisasi JSON, jadi Anda harus mengonversinya menjadi daftar angka (yang dapat diserialisasi JSON). Jika tidak, AI Platform Prediction akan gagal mengirim respons prediksi.

Memaketkan Predictor dan dependensinya

Anda harus memaketkan Prediktor sebagai paket distribusi sumber .tar.gz. Karena NumPy, TensorFlow, dan scikit-learn disertakan dalam image runtime Prediksi AI Platform, Anda tidak perlu menyertakan dependensi ini dalam tarball. Namun, pastikan untuk menyertakan dependensi Predictor yang tidak diinstal sebelumnya di AI Platform Prediction.

Untuk contoh di atas, Anda harus menyertakan preprocess.py dalam paket distribusi sumber, meskipun Predictor tidak mengimpornya secara eksplisit. Jika tidak, preprocessor = pickle.load(f) akan gagal karena Python tidak akan mengenali class instance ZeroCenterer dalam file pickle.

setup.py berikut menunjukkan salah satu cara untuk memaketkan skrip ini:

from setuptools import setup

setup(name="my_custom_code", version="0.1", scripts=["predictor.py", "preprocess.py"])

Untuk memaketkan dan mengupload contoh kode kustom yang dijelaskan di halaman ini, lakukan hal berikut:

  1. Buat file preprocess.py, predictor.py, dan setup.py yang dijelaskan di bagian sebelumnya, semuanya dalam direktori yang sama. Buka direktori tersebut di shell Anda.

  2. Jalankan python setup.py sdist --formats=gztar untuk membuat dist/my_custom_code-0.1.tar.gz.

  3. Upload tarball ini ke lokasi staging di Cloud Storage.

    Nama ini tidak harus sama dengan direktori model Anda. Jika berencana untuk melakukan iterasi dan men-deploy beberapa versi rutinitas prediksi kustom, sebaiknya upload paket kode kustom di direktori staging yang ditetapkan. Anda dapat menambahkan argumen version di setup.py saat memperbarui kode untuk melacak berbagai versi.

    Perintah berikut menunjukkan salah satu cara untuk mengupload paket distribusi sumber ke Cloud Storage:

    gcloud storage cp dist/my_custom_code-0.1.tar.gz gs://YOUR_BUCKET/PATH_TO_STAGING_DIR/

Anda dapat memberikan kode untuk rutinitas prediksi kustom dalam satu atau beberapa paket.

Men-deploy rutinitas prediksi kustom

Pertama, pilih region tempat prediksi online tersedia dan gunakan gcloud untuk membuat resource model:

gcloud ai-platform models create MODEL_NAME{"</var>"}} \
  --regions CHOSEN_REGION

Pastikan komponen gcloud beta Anda telah diupdate, lalu buat resource versi dengan perhatian khusus pada flag gcloud berikut:

  • --origin: Jalur ke direktori model Anda di Cloud Storage.
  • --package-uris: Daftar tarball kode pengguna yang dipisahkan koma di Cloud Storage, termasuk yang berisi class Predictor Anda.
  • --prediction-class: Nama class Predictor yang sepenuhnya memenuhi syarat (MODULE_NAME.CLASS_NAME).
  • --framework: Jangan menentukan framework saat men-deploy rutinitas prediksi kustom.
  • --runtime-version: Rutinitas prediksi kustom tersedia dalam versi runtime 1.4 hingga 2.11.

Perintah berikut menunjukkan cara membuat resource versi berdasarkan file contoh yang dijelaskan di bagian sebelumnya:

gcloud components install beta

gcloud beta ai-platform versions create VERSION_NAME \
  --model MODEL_NAME{"</var>"}} \
  --runtime-version 2.11 \
  --python-version 3.7 \
  --origin gs://YOUR_BUCKET/PATH_TO_MODEL_DIR \
  --package-uris gs://YOUR_BUCKET/PATH_TO_STAGING_DIR/my_custom_code-0.1.tar.gz \
  --prediction-class predictor.MyPredictor

Untuk mempelajari lebih lanjut cara membuat model dan versi secara mendetail, atau untuk mempelajari cara membuatnya menggunakan konsol Google Cloud, bukan gcloud CLI, lihat panduan untuk men-deploy model.

Menentukan akun layanan

Saat membuat resource versi, Anda dapat menentukan akun layanan secara opsional untuk digunakan rutinitas prediksi kustom selama prediksi. Dengan demikian, Anda dapat menyesuaikan izinnya untuk mengakses resource Google Cloud lainnya. Pelajari lebih lanjut cara menentukan akun layanan untuk rutinitas prediksi kustom Anda.

Langkah selanjutnya

  • Ikuti tutorial tentang cara menggunakan rutinitas prediksi kustom dengan Keras atau dengan scikit-learn untuk melihat contoh yang lebih lengkap tentang cara melatih dan men-deploy model menggunakan rutinitas prediksi kustom.
  • Baca panduan mengekspor model untuk mempelajari cara mengekspor artefak untuk prediksi tanpa menggunakan rutinitas prediksi kustom.
  • Baca panduan men-deploy model untuk mempelajari detail selengkapnya tentang men-deploy resource model dan version ke AI Platform Prediction untuk menayangkan prediksi.