Membuat rutinitas prediksi kustom dengan Keras

Jalankan tutorial ini sebagai notebook di Colab

Lihat notebook di GitHub

Beta

Fitur ini tunduk pada "Persyaratan Penawaran Pra-GA" di bagian Persyaratan Layanan Umum dalam Persyaratan Khusus Layanan. Fitur pra-GA tersedia "sebagaimana adanya" dan mungkin memiliki dukungan terbatas. Untuk mengetahui informasi selengkapnya, lihat deskripsi tahap peluncuran.

Tutorial ini menunjukkan cara men-deploy model Keras terlatih ke Prediksi AI Platform dan menyalurkan prediksi menggunakan rutinitas prediksi kustom. Dengan begitu, Anda dapat menyesuaikan cara AI Platform Prediction merespons setiap permintaan prediksi.

Dalam contoh ini, Anda akan menggunakan rutinitas prediksi kustom untuk melakukan prapemrosesan input prediksi dengan menskalakannya, dan untuk melakukan output prediksi pascapemrosesan dengan mengonversi output probabilitas softmax menjadi string label.

Tutorial ini memberikan beberapa langkah:

• Melatih model Keras sederhana secara lokal
• Membuat dan men-deploy rutinitas prediksi kustom ke AI Platform Prediction
• Menyalurkan permintaan prediksi dari deployment tersebut

Set data

Tutorial ini menggunakan set data Iris R.A. Fisher, sebuah set data kecil yang populer untuk mencoba teknik machine learning. Setiap instance memiliki empat fitur numerik, yang merupakan ukuran bunga yang berbeda, dan label target yang menandainya sebagai salah satu dari tiga jenis iris: Iris setosa, Iris versicolour, atau Iris virginica.

Tutorial ini menggunakan salinan set data Iris yang disertakan dalam library scikit-learn.

Tujuan

Tujuannya adalah untuk melatih model yang menggunakan pengukuran bunga sebagai input untuk memprediksi jenis iris itu.

Tutorial ini lebih berfokus pada penggunaan model ini dengan AI Platform Prediction daripada desain model itu sendiri.

Biaya

Tutorial ini menggunakan komponen Google Cloud yang dapat ditagih:

• AI Platform Prediction
• Cloud Storage

Pelajari harga AI Platform Prediction dan harga Cloud Storage, lalu gunakan Kalkulator Harga untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda.

Sebelum memulai

Anda harus melakukan beberapa hal sebelum dapat melatih dan men-deploy model di AI Platform Prediction:

• Menyiapkan lingkungan pengembangan lokal Anda.
• Siapkan project Google Cloud dengan penagihan dan API yang diperlukan telah diaktifkan.
• Buat bucket Cloud Storage untuk menyimpan paket pelatihan dan model yang Anda latih.

Menyiapkan lingkungan pengembangan lokal

Anda memerlukan hal berikut untuk menyelesaikan tutorial ini:

• Python 3
• Virtualenv
• Google Cloud SDK

Catatan: Tutorial ini dirancang untuk Python 3, tetapi mungkin juga berfungsi dengan Python 2.

Panduan Google Cloud untuk Menyiapkan lingkungan pengembangan Python menyediakan petunjuk mendetail untuk memenuhi persyaratan ini. Langkah-langkah berikut memberikan serangkaian petunjuk ringkas:

1. Instal Python 3.

2. Instal virtualenv dan buat lingkungan virtual yang menggunakan Python 3.

3. Aktifkan lingkungan tersebut.

4. Selesaikan langkah-langkah di bagian berikut untuk menginstal Google Cloud SDK.

Menyiapkan project Google Cloud Anda

1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

2. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

3. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

4. Aktifkan API AI Platform Training & Prediction and Compute Engine.

   Mengaktifkan API

5. Menginstal Google Cloud CLI.

6. Untuk initialize gcloud CLI, jalankan perintah berikut:

   gcloud init

7. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

8. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

9. Aktifkan API AI Platform Training & Prediction and Compute Engine.

   Mengaktifkan API

10. Menginstal Google Cloud CLI.

11. Untuk initialize gcloud CLI, jalankan perintah berikut:

    gcloud init

Mengautentikasi akun GCP Anda

Untuk menyiapkan autentikasi, Anda harus membuat kunci akun layanan dan menetapkan variabel lingkungan untuk jalur file ke kunci akun layanan.

1. Buat akun layanan:

   1. Di konsol Google Cloud, buka halaman Buat akun layanan.

      Buka Create service account

   2. Di kolom Nama akun layanan, masukkan nama.
   3. Opsional: Di kolom Deskripsi akun layanan, masukkan deskripsi.
   4. Klik Create.
   5. Klik kolom Pilih peran. Di bagian Semua peran, pilih AI Platform > AI Platform Admin.
   6. Klik Add another role.

   7. Klik kolom Pilih peran. Di bagian All roles, pilih Storage > Storage Object Admin.

      Catatan: Peran yang Anda pilih memungkinkan akun layanan mengakses resource. Anda dapat melihat dan mengubah peran ini nanti menggunakan konsol Google Cloud. Jika Anda mengembangkan aplikasi produksi, Anda mungkin perlu menentukan peran dengan izin yang lebih sedikit daripada AI Platform Admin dan Storage Object Admin. Untuk mengetahui informasi selengkapnya, lihat kontrol akses untuk Prediksi AI Platform.

   8. Klik Selesai untuk membuat akun layanan.

      Jangan tutup jendela browser Anda. Anda akan menggunakannya pada langkah berikutnya.

2. Membuat kunci akun layanan untuk autentikasi:

   1. Di konsol Google Cloud, klik alamat email untuk akun layanan yang telah dibuat.
   2. Klik Kunci.
   3. Klik Tambahkan kunci, lalu Buat kunci baru.
   4. Klik Create. File kunci JSON akan didownload ke komputer Anda.
   5. Klik Close.

3. Tetapkan variabel lingkungan GOOGLE_APPLICATION_CREDENTIALS ke jalur file JSON yang berisi kunci akun layanan Anda. Variabel ini hanya berlaku untuk sesi shell Anda saat ini. Jadi, jika Anda membuka sesi baru, tetapkan variabel kembali.

   Contoh: Linux atau macOS

   Ganti [PATH] dengan jalur file JSON yang berisi kunci akun layanan Anda.

   export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

   Contoh:

   export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

   Contoh: Windows

   Ganti [PATH] dengan jalur file JSON yang berisi kunci akun layanan Anda, dan [FILE_NAME] dengan nama file.

   Dengan PowerShell:

   $env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

   Contoh:

   $env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\[FILE_NAME].json"

   Dengan command prompt:

   set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

Membuat bucket Cloud Storage

Untuk men-deploy rutinitas prediksi kustom, Anda harus mengupload artefak model yang telah dilatih dan kode kustom Anda ke Cloud Storage.

Tetapkan nama bucket Cloud Storage sebagai variabel lingkungan. Nama ini harus unik di semua bucket Cloud Storage:

BUCKET_NAME="your-bucket-name"

Pilih region tempat AI Platform Prediction tersedia dan buat variabel lingkungan lainnya.

REGION="us-central1"

Buat bucket Cloud Storage di region ini, lalu gunakan region yang sama untuk pelatihan dan prediksi. Jalankan perintah berikut untuk membuat bucket jika belum ada:

gsutil mb -l $REGION gs://$BUCKET_NAME

Membangun dan melatih model Keras

Sering kali, Anda tidak dapat menggunakan data dalam bentuk mentah untuk melatih model machine learning. Meskipun bisa, pemrosesan data terlebih dahulu sebelum menggunakannya untuk pelatihan terkadang dapat meningkatkan kualitas model Anda.

Dengan asumsi bahwa Anda mengharapkan input untuk prediksi memiliki format yang sama dengan data pelatihan, Anda harus menerapkan pra-pemrosesan yang identik selama pelatihan dan prediksi untuk memastikan bahwa model Anda membuat prediksi yang konsisten.

Di bagian ini, buat modul pra-pemrosesan dan gunakan sebagai bagian dari pelatihan. Kemudian, ekspor praprosesor dengan karakteristik yang dipelajari selama pelatihan untuk digunakan nanti dalam rutinitas prediksi kustom Anda.

Menginstal dependensi untuk pelatihan lokal

Pelatihan secara lokal memerlukan beberapa dependensi:

pip install numpy scikit-learn 'tensorflow=2.3'

Menulis praprosesor Anda

Menskalakan data pelatihan sehingga setiap kolom fitur numerik memiliki rata-rata 0 dan deviasi standar 1 dapat meningkatkan kualitas model Anda.

Buat preprocess.py, yang berisi class untuk melakukan penskalaan ini:

import numpy as np

class MySimpleScaler(object):
  def __init__(self):
    self._means = None
    self._stds = None

  def preprocess(self, data):
    if self._means is None: # during training only
      self._means = np.mean(data, axis=0)

    if self._stds is None: # during training only
      self._stds = np.std(data, axis=0)
      if not self._stds.all():
        raise ValueError('At least one column has standard deviation of 0.')

    return (data - self._means) / self._stds

Perhatikan bahwa instance MySimpleScaler menyimpan sarana dan standar deviasi dari setiap kolom fitur pada penggunaan pertama. Kemudian model ini menggunakan statistik ringkasan ini untuk menskalakan data yang ditemukan setelahnya.

Dengan begitu, Anda dapat menyimpan karakteristik distribusi pelatihan dan menggunakannya untuk pra-pemrosesan yang identik pada waktu prediksi.

Melatih model Anda

Selanjutnya, gunakan preprocess.MySimpleScaler untuk melakukan prapemrosesan data iris, lalu latih jaringan neural sederhana menggunakan Keras.

Terakhir, ekspor model Keras terlatih Anda sebagai file HDF5 (.h5) dan ekspor instance MySimpleScaler sebagai file acar (.pkl):

import pickle

from sklearn.datasets import load_iris
import tensorflow as tf

from preprocess import MySimpleScaler

iris = load_iris()
scaler = MySimpleScaler()
num_classes = len(iris.target_names)
X = scaler.preprocess(iris.data)
y = tf.keras.utils.to_categorical(iris.target, num_classes=num_classes)

model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(num_classes, activation=tf.nn.softmax))
model.compile(
  optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X, y, epochs=10, batch_size=1)

model.save('model.h5')
with open ('preprocessor.pkl', 'wb') as f:
  pickle.dump(scaler, f)

Catatan: Saat men-deploy model TensorFlow ke AI Platform Prediction tanpa rutinitas prediksi kustom, Anda harus mengekspor model yang dilatih dalam format SavedModel. Saat menerapkan rutinitas prediksi kustom, Anda dapat mengekspor ke format HDF5—atau format lain yang sesuai dengan kebutuhan Anda.

Men-deploy rutinitas prediksi kustom

Untuk men-deploy rutinitas prediksi kustom guna menampilkan prediksi dari model yang telah dilatih, lakukan hal berikut:

• Membuat prediktor kustom untuk menangani permintaan
• Mengemas prediktor dan modul pra-pemrosesan Anda
• Upload artefak model dan kode kustom Anda ke Cloud Storage
• Men-deploy rutinitas prediksi kustom Anda ke AI Platform Prediction

Membuat prediktor kustom

Untuk men-deploy rutinitas prediksi kustom, Anda harus membuat class yang mengimplementasikan antarmuka Predictor. Atribut ini akan memberi tahu AI Platform Prediction cara memuat model Anda dan cara menangani permintaan prediksi.

Tulis kode berikut ke predictor.py:

import os
import pickle

import numpy as np
from sklearn.datasets import load_iris
import tensorflow as tf

class MyPredictor(object):
  def __init__(self, model, preprocessor):
    self._model = model
    self._preprocessor = preprocessor
    self._class_names = load_iris().target_names

  def predict(self, instances, **kwargs):
    inputs = np.asarray(instances)
    preprocessed_inputs = self._preprocessor.preprocess(inputs)
    outputs = self._model.predict(preprocessed_inputs)
    if kwargs.get('probabilities'):
      return outputs.tolist()
    else:
      return [self._class_names[index] for index in np.argmax(outputs, axis=1)]

  @classmethod
  def from_path(cls, model_dir):
    model_path = os.path.join(model_dir, 'model.h5')
    model = tf.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)

Perhatikan bahwa, selain menggunakan praprosesor yang Anda tentukan selama pelatihan, preprosesor ini melakukan langkah pascapemrosesan yang mengonversi output softmax jaringan neural (array yang menunjukkan probabilitas setiap label yang benar) ke dalam label dengan probabilitas tertinggi.

Namun, jika prediktor menerima argumen kata kunci probabilities dengan nilai True, prediktor akan menampilkan array probabilitas. Bagian terakhir tutorial ini menunjukkan cara memberikan argumen kata kunci ini.

Mengemas kode kustom

Anda harus mengemas predictor.py dan preprocess.py sebagai paket distribusi sumber .tar.gz dan memberikan paket tersebut ke AI Platform Prediction agar dapat menggunakan kode kustom Anda untuk menyajikan prediksi.

Tulis setup.py berikut untuk menentukan paket Anda:

from setuptools import setup

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

Lalu, jalankan perintah berikut untuk membuat dist/my_custom_code-0.1.tar.gz:

python setup.py sdist --formats=gztar

Mengupload artefak model dan kode kustom ke Cloud Storage

Sebelum Anda dapat men-deploy model untuk inferensi, AI Platform Prediction memerlukan akses ke file berikut di Cloud Storage:

• model.h5 (artefak model)
• preprocessor.pkl (artefak model)
• my_custom_code-0.1.tar.gz (kode kustom)

Artefak model harus disimpan bersama dalam direktori model, yang dapat diakses oleh Prediktor sebagai argumen model_dir dalam metode class from_path-nya. Kode kustom tidak perlu berada di direktori yang sama. Jalankan perintah berikut untuk mengupload file Anda:

gsutil cp ./dist/my_custom_code-0.1.tar.gz gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz
gsutil cp model.h5 preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/

Men-deploy rutinitas prediksi kustom Anda

Buat resource model dan resource versi untuk men-deploy rutinitas prediksi kustom Anda. Pertama-tama, tentukan variabel lingkungan dengan nama resource Anda:

MODEL_NAME='IrisPredictor'
VERSION_NAME='v1'

Kemudian buat model Anda:

gcloud ai-platform models create $MODEL_NAME \
  --regions $REGION

Selanjutnya, buat versi. Pada langkah ini, berikan jalur ke artefak dan kode kustom yang Anda upload ke Cloud Storage:

gcloud components install beta

gcloud beta ai-platform versions create $VERSION_NAME \
  --model $MODEL_NAME \
  --runtime-version 2.3 \
  --python-version 3.7 \
  --origin gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/ \
  --package-uris gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz \
  --prediction-class predictor.MyPredictor

Pelajari lebih lanjut opsi yang harus Anda tentukan saat men-deploy rutinitas prediksi kustom.

Menyajikan prediksi online

Coba deployment Anda dengan mengirim permintaan prediksi online. Pertama, instal Library Klien Google API untuk Python:

pip install --upgrade google-api-python-client

Kemudian kirim dua instance data iris ke versi yang di-deploy dengan menjalankan kode Python berikut:

import googleapiclient.discovery

instances = [
  [6.7, 3.1, 4.7, 1.5],
  [4.6, 3.1, 1.5, 0.2],
]

service = googleapiclient.discovery.build('ml', 'v1')
name = 'projects/{}/models/{}/versions/{}'.format(PROJECT_ID, MODEL_NAME, VERSION_NAME)

response = service.projects().predict(
    name=name,
    body={'instances': instances}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])

['versicolor', 'setosa']

Catatan: Kode ini menggunakan kredensial yang Anda siapkan selama langkah autentikasi untuk membuat permintaan prediksi online.

Mengirim argumen kata kunci

Saat mengirim permintaan prediksi ke rutinitas prediksi kustom, Anda dapat memberikan kolom tambahan pada isi permintaan. Metode predict Predictor menerima peristiwa ini sebagai kolom kamus **kwargs.

Kode berikut mengirim permintaan yang sama seperti sebelumnya, tetapi kali ini menambahkan kolom probabilities ke isi permintaan:

response = service.projects().predict(
    name=name,
    body={'instances': instances, 'probabilities': True}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])

[[0.0019204545533284545, 0.8623144626617432, 0.13576509058475494], [0.999488353729248, 0.000511515187099576, 1.293626752385535e-07]]

Pembersihan

Untuk membersihkan semua resource GCP yang digunakan dalam project ini, Anda dapat menghapus project GCP yang digunakan untuk tutorial.

Atau, Anda dapat membersihkan resource satu per satu dengan menjalankan perintah berikut:

# Delete version resource
gcloud ai-platform versions delete $VERSION_NAME --quiet --model $MODEL_NAME

# Delete model resource
gcloud ai-platform models delete $MODEL_NAME --quiet

# Delete Cloud Storage objects that were created
gsutil -m rm -r gs://$BUCKET_NAME/custom_prediction_routine_tutorial

Langkah selanjutnya

• Baca selengkapnya tentang rutinitas prediksi kustom.
• Pelajari cara mengekspor model untuk menampilkan prediksi tanpa rutinitas prediksi kustom.