Halaman ini diterjemahkan oleh Cloud Translation API.

Menyajikan model Spark ML menggunakan Vertex AI

Last reviewed 2023-07-11 UTC

Ilmuwan data dan engineer machine learning (ML) sering kali memerlukan arsitektur penyaluran yang cukup cepat untuk memenuhi kebutuhan pembuatan prediksi online (atau real time) dari model ML mereka Vertex AI mampu memenuhi kebutuhan ini.

Dengan Vertex AI, Anda dapat melayani model dari berbagai framework ML. Untuk framework seperti TensorFlow, PyTorch, XGBoost, dan scikit-learn, Vertex AI menyediakan container bawaan yang akan digunakan untuk menjalankan model ML tersebut. Jika belum menggunakan salah satu framework ML tersebut, Anda harus membuat container kustom sendiri untuk digunakan oleh Vertex AI.

Dokumen ini ditujukan bagi pengguna yang perlu membuat container kustom untuk menyalurkan model ML Spark mereka. Dokumen ini mencakup deskripsi arsitektur penayangan yang diperlukan untuk container kustom dan implementasi referensi yang menunjukkan arsitektur ini untuk model Spark MLib.

Untuk mendapatkan hasil maksimal dari bagian implementasi referensi pada dokumen ini, Anda harus memahami cara mengekspor model Spark MLlib ke format MLeap dan memahami cara menggunakan Vertex AI untuk menyalurkan prediksi, dan memiliki pengalaman menggunakan image container.

Arsitektur

Meskipun container bawaan tersedia untuk beberapa framework ML, pengguna framework ML lain, seperti Spark, perlu membuat container kustom tempat Vertex AI dapat menjalankan prediksi. Diagram berikut menggambarkan arsitektur penyaluran yang Anda perlukan untuk menyalurkan model Spark MLib dan model lain yang memerlukan container kustom:

Arsitektur penyaluran untuk model yang digunakan dalam dokumen.

Arsitektur ini mencakup komponen berikut:

Cloud Storage: menyediakan penyimpanan untuk artefak model yang diperlukan untuk menjalankan model Anda. Untuk model Spark ML yang digunakan dalam referensi terlampir implementasinya, artefak model terdiri dari Paket MLeap dan skema model.
Cloud Build: menggunakan pembuat gambar untuk membuat gambar container khusus yang disebut penyaluran image container. Proses pembangunan mengompilasi dan mengemas kode penayangan model, membuat gambar container penayangan, lalu mengirim image container penayangan ke Artifact Registry.
Artifact Registry: berisi objek berikut:
- Image container builder scala-sbt yang digunakan Cloud Build untuk membangun image container penayangan.
- Image container penyaluran yang di-build oleh Cloud Build.
Vertex AI: berisi model ML yang telah diupload dari Cloud Storage. Model yang diupload dikonfigurasi dengan lokasi artefak model dalam Cloud Storage dan lokasi gambar container penayangan dalam Artifact Registry. Vertex AI juga mencakup endpoint tempat model telah di-deploy. Setelah model telah di-deploy ke endpoint, Vertex AI akan mengaitkan resource fisik dengan model tersebut sehingga model tersebut dapat menyajikan prediksi online.

Sebagai bagian dari penerapan arsitektur penyaluran ini, Anda perlu mengekspor model ML untuk digunakan oleh aplikasi lain dan menentukan image container penyaluran Anda sendiri. Implementasi referensi yang disediakan dalam dokumen ini menyediakan kode yang digunakan untuk menentukan dan membangun image container penayangan. Kode ini juga mencakup artefak model untuk model Spark ML yang telah diekspor sebelumnya. Dengan beberapa perubahan konfigurasi, Anda dapat menggunakan implementasi referensi ini untuk menyalurkan model ML Spark Anda sendiri.

Namun, Anda dapat mengimplementasikan arsitektur penayangan ini sendiri dan tidak menggunakan implementasi referensi. Jika memutuskan untuk mengimplementasikan arsitektur sendiri, Anda perlu melakukan hal berikut:

Ekspor model Anda agar dapat digunakan oleh aplikasi lain. Proses ini bergantung pada frameworks dan alat ML yang Anda gunakan. Misalnya, Anda dapat memilih untuk mengekspor model Spark MLlib dengan membuat paket MLeap seperti yang dijelaskan dalam penerapan referensi. Anda dapat melihat contoh lain terkait cara mengekspor model diMengekspor artefak model untuk prediksi.
Desain image container penyaluran Anda agar memenuhi persyaratan container kustom yang membuat image tersebut kompatibel dengan Vertex AI. Kode dapat menggunakan bahasa pemrograman pilihan Anda.
Kemas kode dalam format file paket yang kompatibel dengan bahasa pemrograman yang Anda gunakan. Misalnya, Anda dapat menggunakan file JAR untuk kode Java atau roda Python untuk kode Python.
Buat image container kustom yang mampu menayangkan kode mode kustom Anda.

Penerapan referensi

Penerapan referensi berikut menyajikan model Spark MLib yang memprediksi spesies iris berdasarkan panjang dan lebar kelopak dan kelopak bunga.

Anda dapat menemukan model yang digunakan dalam implementasi ini pada direktori example_model di repositori vertex-ai-spark-ml-serving.git. Direktori tersebut berisi artefak model yang digunakan oleh penayangan container untuk menjalankan prediksi, dan menyertakan file berikut:

File tersebutexample_model/model.zip adalah model regresi logistik yang dibangun menggunakan Spark MLlib, telah dilatih menggunakan Iris dataset, dan telah dikonversi menjadi Paket MLeap. Model ini memprediksi spesies bunga iris dengan menggunakan panjang dan lebar sepal dan kelopak bunga.
File tersebut example_model/schema.jsonadalah file JSON yang mendeskripsikan skema model. Skema model menjelaskan kolom input yang diharapkan untuk instance prediksi dan kolom output untuk hasil prediksi yang diperlukan untuk skema MLeap.

Gunakan model Mlib Anda sendiri

Untuk menggunakan model Anda sendiri dengan implementasi referensi ini, pertama-tama pastikan bahwa model Spark MLlib Anda telah diekspor ke Paket MLeap. Kemudian untuk menayangkan model Spark MLib, Anda harus memberikan artefak model yang sesuai: Paket MLeap dan skema model.

Paket MLeap

Container penyajian menentukan lokasi Paket MLeap menggunakan variabel lingkungan AIP_STORAGE_URI yang diteruskan dari Vertex AI ke container saat startup. Nilai variabel AIP_STORAGE_URI ditentukan saat Anda mengupload model ke Vertex AI.

Skema model

Skema model menjelaskan fitur input dan output prediksi model. Skema model direpresentasikan menggunakan data JSON. Berikut ini adalah skema yang digunakan dalam implementasi referensi ini untuk memprediksi spesies iris berdasarkan panjang dan lebar bunga sepal dan kelopaknya:

{
  "input": [
    {
      "name": "sepal_length",
      "type": "FLOAT"
    },
    {
      "name": "sepal_width",
      "type": "FLOAT"
    },
    {
      "name": "petal_length",
      "type": "FLOAT"
    },
    {
      "name": "petal_width",
      "type": "FLOAT"
    }
  ],
  "output": [
    {
      "name": "probability",
      "type": "DOUBLE",
      "struct": "VECTOR"
    }
  ]
}

Dalam skema contoh input array berisi kolom input (kolom) ke model, sedangkan output array berisi kolom output (kolom) yang akan ditampilkan dari model. Di kedua array, setiap objek array berisi properti berikut:

name: Nama bidang (kolom).
type: Jenis bidang (kolom). Jenis yang valid mencakup BOOLEAN, BYTE, DOUBLE, FLOAT, INTEGER, LONG, SHORT, dan STRING.
(opsional) struct: Struktur kolom, seperti skalar atau array. Struktur yang valid mencakup BASIC (jenis skalar), ARRAY (Spark Array), dan VECTOR (Spark DenseVector). BASIC digunakan jika kolom struct tidak ada.

Untuk meneruskan skema model Anda ke container penyajian, Anda dapat menggunakan salah satu dari metode berikut:

Tentukan data JSON yang menentukan skema dalam MLEAP_SCHEMA variabel lingkungan. Variabel MLEAP_SCHEMA lingkungan harus berisi data JSON itu sendiri, dan bukan jalur ke file yang berisi skema JSON.
Simpan data JSON dalam file bernama schema.json, dan buat file ini tersedia pada container di ${AIP_STORAGE_URI}/schema.json. Ini adalah metode yang digunakan untuk contoh model MLib yang disertakan dalam dokumen ini.

Jika Anda menggunakan kedua metode untuk meneruskan skema model ke container penayangan, data JSON yang disimpan dalam MLEAP_SCHEMA variabel lingkungan akan diutamakan.

Biaya

Implementasi referensi ini menggunakan komponen Google Cloud yang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga.

Setelah menyelesaikan penerapan referensi ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

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
Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.
Enable the Vertex AI, Cloud Build, Cloud Storage, and Artifact Registry APIs.
Enable the APIs
Di konsol Google Cloud, aktifkan Cloud Shell.

Aktifkan Cloud Shell
Temukan project ID Anda dan tetapkan di Cloud Shell.
```
export PROJECT_ID=YOUR_PROJECT_ID
gcloud config set project ${PROJECT_ID}
```
Ganti YOUR_PROJECT_ID dengan project ID Anda.

Membuat image builder scala-sbt

Anda menggunakan Cloud Build dengan scala-sbt community builder untuk membangun image container penayangan. Proses pembangunan ini bergantung pada adanya sbt-scala image builder di Container registry project Anda.

Pada Cloud Shell, clone repositori cloud-builders-community:

git clone https://github.com/GoogleCloudPlatform/cloud-builders-community.git

Buka direktori project:
```
cd cloud-builders-community/scala-sbt
```
Bangun image builder scala-sbt dan kirimkan ke Container Registry:
```
gcloud builds submit .
```

Membangun image container penayangan

Vertex AI menggunakan container penyaluran untuk menjalankan permintaan prediksi untuk contoh model. Langkah pertama Anda dalam membangun image container penyaluran adalah membuat repositori Docker di Artifact Registry yang akan menjadi tempat penyimpanan image. Selanjutnya, Anda perlu memberikan izin kepada Vertex AI untuk mengambil image container penyaluran dari repositori. Setelah membuat repositori dan memberikan izin, Anda dapat membangun image container penayangan dan mengirim ke image Artifact Registry.

Di Cloud Shell, buatlah repositori Docker di Artifact Registry:

REPOSITORY="vertex-ai-prediction"
LOCATION="us-central1"

gcloud artifacts repositories create $REPOSITORY \
    --repository-format=docker \
    --location=$LOCATION

Berikan peran Artifact Registry Reader ke Agen Layanan Vertex AI:

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \
    --format="value(projectNumber)")
SERVICE_ACCOUNT="service-$PROJECT_NUMBER@gcp-sa-aiplatform.iam.gserviceaccount.com"

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:$SERVICE_ACCOUNT" \
    --role="roles/artifactregistry.reader"

Membuat cloning spark-ml-serving repositori:

git clone https://github.com/GoogleCloudPlatform/vertex-ai-spark-ml-serving.git

Buka direktori project:
```
cd vertex-ai-spark-ml-serving
```
Bangun image container penayangan di project Anda:
```
IMAGE=spark-ml-serving

gcloud builds submit --config=cloudbuild.yaml \
    --substitutions="_LOCATION=$LOCATION,_REPOSITORY=$REPOSITORY,_IMAGE=$IMAGE" .
```
File cloudbuild.yaml menentukan dua builder: builder scala-sbt dan image builderdocker. Cloud Build menggunakan scala-sbt builder untuk mengompilasi kode penyaluran model dari Cloud Storage, lalu memaketkan kode yang sudah dikompilasi ke dalam file JAR yang dapat dieksekusi. Cloud Build menggunakan docker builder untuk membangun image container penayangan yang berisi file JAR. Setelah image container penayangan dibangun, image akan dikirim ke Artifact Registry.

Mengimpor model ke Vertex AI

Container penayangan membaca artefak model dari Cloud Storage. Anda perlu membuat lokasi penyimpanan untuk artefak ini sebelum mengimpor model ke Vertex AI. Saat mengimpor model, Anda perlu lokasi penyimpanan artefak model dan image container penayangan di Artifact Registry.

Di Cloud Shell, buatlah bucket untuk artefak model:
```
REGION="us-central1"
BUCKET="YOUR_BUCKET_NAME"
gsutil mb -l $REGION gs://$BUCKET
```
Ganti YOUR_BUCKET_NAME dengan nama bucket Anda.

Salin artefak model ke bucket:

gsutil cp example_model/* gs://$BUCKET/example_model/

Impor model ke Vertex AI:

DISPLAY_NAME="iris-$(date +'%Y%m%d%H%M%S')"
IMAGE_URI="${LOCATION}-docker.pkg.dev/$PROJECT_ID/${REPOSITORY}/${IMAGE}"
ARTIFACT_URI="gs://$BUCKET/example_model/"

gcloud ai models upload \
    --region=$REGION \
    --display-name=$DISPLAY_NAME \
    --container-image-uri=$IMAGE_URI \
    --artifact-uri=$ARTIFACT_URI \
    --container-health-route="/health" \
    --container-predict-route="/predict"

Dalam perintah gcloud ai models upload, nilai parameter --artifact-uri menentukan nilai variabel AIP_STORAGE_URI. Variabel ini menyediakan lokasi Paket MLeap yang sedang diimpor ke Vertex AI.

Men-deploy model ke endpoint baru

Agar Vertex AI dapat menjalankan prediksi, model yang diimpor harus di-deploy ke endpoint. Anda memerlukan ID endpoint dan ID model saat mendeploy model

Pada Cloud Shell, buatlah endpoint model:
```
gcloud ai endpoints create \
    --region=$REGION \
    --display-name=$DISPLAY_NAME
```
Alat command line gcloud mungkin memerlukan waktu beberapa detik untuk membuat endpoint.

Dapatkan ID endpoint dari endpoint yang baru dibuat:

ENDPOINT_ID=$(gcloud ai endpoints list \
    --region=$REGION \
    --filter=display_name=$DISPLAY_NAME \
    --format='value(name)')

# Print ENDPOINT_ID to the console
echo "Your endpoint ID is: $ENDPOINT_ID"

Dapatkan ID model dari model yang Anda impor di bagian Impor model ke Vertex AI:

MODEL_ID=$(gcloud ai models list \
    --region=$REGION \
    --filter=display_name=$DISPLAY_NAME \
    --format='value(name)')

# Print MODEL_ID to the console
echo "Your model ID is: $MODEL_ID"

Deploy model ke endpoint:
```
gcloud ai endpoints deploy-model $ENDPOINT_ID \
    --region=$REGION \
    --model=$MODEL_ID \
    --display-name=$DISPLAY_NAME \
    --traffic-split="0=100"
```
Perintah gcloud men-deploy model ke endpoint. Nilai default digunakan untuk jenis resource mesin, jumlah minimum dan maksimum node, serta opsi konfigurasi lainnya. Untuk mengetahui informasi selengkapnya tentang opsi deployment untuk model, lihat dokumentasi Vertex AI.

Menguji endpoint

Saat men-deploy model ke endpoint, Anda dapat menguji implementasinya. Untuk menguji endpoint, Anda dapat menggunakan klien contoh yang disertakan dengan kode implementasi referensi. Klien contoh menghasilkan instance prediksi dan mengirim permintaan prediksi ke endpoint. Setiap instance prediksi bernilai acak untuk,sepal_length, sepal_width, petal_length, dan petal_width. Secara default, contoh klien menggabungkan beberapa instance prediksi menjadi satu permintaan. Tanggapan dari respons titik akhir mencakup prediksi untuk setiap instance yang dikirim di permintaan. Prediksi berisi probalitas untuk setiap class dalam Iris dataset (setosa, versicolor, and virginica).

Pada Cloud Shell, jalankan klien prediksi contoh:

cd example_client
./run_client.sh --project $PROJECT_ID \
    --location $LOCATION \
    --endpoint $ENDPOINT_ID

Saat Anda menjalankan skrip untuk pertama kalinya, skrip akan membuat lingkungan virtual Python dan menginstal depensi. Setelah menginstal depensi, skrip akan menjalankan klien, contoh: Untuk setiap permintaan, klien akan mencetak instance prediksi dan probabilitas class yang sesuai ke terminal. Berikut adalah kutipan output-nya:

Sending 10 asynchronous prediction requests with 3 instances per request ...

==> Response from request #10:

Instance 1:     sepal_length:   5.925825137450266
                sepal_width:    4.5047557888651
                petal_length:   1.0432434310300223
                petal_width:    0.5050397721287457

Prediction 1:   setosa:         0.2036041134824573
                versicolor:     0.6062980065549213
                virginica:      0.1900978799626214

Instance 2:     sepal_length:   6.121228622484405
                sepal_width:    3.406317728235072
                petal_length:   3.178583759980504
                petal_width:    2.815141143581328

Prediction 2:   setosa:         0.471811302254083
                versicolor:     0.2063720436033448
                virginica:      0.3218166541425723

Instance 3:     sepal_length:   7.005781590327274
                sepal_width:    2.532116893508745
                petal_length:   2.6351337947193474
                petal_width:    2.270855223519198

Prediction 3:   setosa:         0.453579051699638
                versicolor:     0.2132869980698818
                virginica:      0.3331339502304803

Pembersihan

Untuk menghindari dikenakannya biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus project

Di konsol Google Cloud, buka halaman Manage resource.
Buka Manage resource
Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Menghapus resource satu per satu

Di Cloud Shell, batalkan deployment model dari endpoint:

DEPLOYED_MODEL_ID=$(gcloud ai endpoints describe $ENDPOINT_ID \
    --region=$REGION \
    --format='value(deployedModels.id)')

gcloud ai endpoints undeploy-model $ENDPOINT_ID \
    --region=$REGION \
    --deployed-model-id=$DEPLOYED_MODEL_ID

Hapus endpoint:

gcloud ai endpoints delete $ENDPOINT_ID \
    --region=$REGION \
    --quiet

Hapus model:

gcloud ai models delete $MODEL_ID \
    --region=$REGION

Hapus image container penayangan:

gcloud artifacts docker images delete \
    $LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE \
    --delete-tags \
    --quiet

Hapus scala-sbt container builder:

gcloud container images delete gcr.io/$PROJECT_ID/scala-sbt \
    --force-delete-tags \
    --quiet

Hapus bucket Cloud Storage yang tidak lagi diperlukan:
```
gsutil rm -r YOUR_BUCKET_NAME
```
Menghapus bucket juga akan menghapus semua objek yang disimpan di bucket tersebut. Bucket dan objek yang dihapus tidak dapat dipulihkan setelah dihapus.

Langkah selanjutnya

Pelajari lebih lanjut cara menjalankan prediksi menggunakan Vertex AI.
Pelajari lebih lanjut Spark pada Google Cloud.
Untuk arsitektur referensi, diagram, dan praktik terbaik lainnya, jelajahi Pusat Arsitektur Cloud.