Rutinitas prediksi kustom

Rutinitas prediksi kustom memungkinkan Anda menentukan kode yang dijalankan 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 menjalankan 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 diterima. Anda dapat melakukan prapemrosesan input prediksi sebelum model yang dilatih menjalankan prediksi, atau Anda dapat melakukan pascapemrosesan prediksi model sebelum mengirim hasil prediksi.

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

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

  • Paket distribusi sumber Python .tar.gz di Cloud Storage yang berisi implementasi antarmuka Predictor dan kode kustom lainnya yang Anda inginkan untuk digunakan 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

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

Total ukuran file 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 TensorFlow SavedModel, file model.joblib, file model.pkl, atau file model.bst, tetapi Anda juga dapat memberikan model Anda sebagai file HDF5 yang berisi tf.keras model terlatih atau dalam format serial yang berbeda.

Anda juga dapat menyertakan file acar dengan instance class praprosesor kustom yang menyimpan status serial dari pelatihan.

Misalnya, pertimbangkan praprosesor 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, praprosesor memusatkan data di sekitar 0 dengan mengurangi rata-rata setiap kolom dari setiap nilai dalam kolom. Kemudian, Anda dapat mengekspor instance preprosesor sebagai file acar, preprocessor.pkl, yang mempertahankan rata-rata setiap kolom yang dihitung dari data pelatihan.

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

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

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

Membuat Predictor Anda

Memberi tahu AI Platform Prediction cara menangani permintaan prediksi dengan menyediakannya dengan 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 isinya disalin 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 menggunakan metode predict untuk menghasilkan prediksi. AI Platform Prediction menserialisasi nilai hasil 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 ke JSON; AI Platform Prediction menangani hal ini di luar metode predict.

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

Melanjutkan contoh dari bagian sebelumnya, anggaplah direktori model Anda berisi preprocessor.pkl (instance acar class ZeroCenterer) dan model tf.keras terlatih yang diekspor sebagai model.h5 atau 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 bernama 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.

Mengemas Predictor Anda dan dependensinya

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

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

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

from setuptools import setup

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

Untuk mengemas 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 di direktori yang sama. Arahkan ke direktori itu di {i>shell<i} 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.

    Direktori ini tidak harus sama dengan direktori model Anda. Jika Anda berencana untuk melakukan iterasi dan men-deploy beberapa versi rutinitas prediksi kustom, Anda dapat mengupload paket kode kustom dalam direktori staging yang ditetapkan. Anda dapat menambahkan argumen version di setup.py saat mengupdate kode untuk melacak versi yang berbeda.

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

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

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

Men-deploy rutinitas prediksi kustom Anda

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 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 Anda yang sepenuhnya memenuhi syarat (MODULE_NAME.CLASS_NAME).
  • --framework: Jangan tentukan framework saat men-deploy rutinitas prediksi kustom.
  • --runtime-version: Rutinitas prediksi kustom tersedia di 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 mempelajari cara membuatnya dengan 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 untuk digunakan oleh 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.

Langkah selanjutnya

  • Selesaikan tutorial tentang penggunaan 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 guna mempelajari cara mengekspor artefak untuk prediksi tanpa menggunakan rutinitas prediksi kustom.
  • Baca panduan men-deploy model untuk mempelajari detail lebih lanjut tentang cara men-deploy resource model dan version ke Prediksi AI Platform untuk menyajikan prediksi.