Kursus
Konsep Large Language Models (LLM)
2 jam
113.3K
Meskipun kebanyakan orang mengaitkan Google dengan mesin pencari, perusahaan ini juga memiliki akar yang kuat di industri data science. Google secara konsisten menghadirkan produk dan solusi mutakhir yang ditujukan untuk memaksimalkan manfaat dari data. Salah satu produknya, Vertex AI, dirilis pada tahun 2021 untuk menyederhanakan proses machine learning pada skala perusahaan.
Dalam tutorial ini, kita akan mempelajari cara memulai dengan platform Vertex AI dari Google dan bagaimana menggunakannya untuk mencakup berbagai tugas dalam siklus hidup ML. Kita akan mengakhiri dengan sebuah model yang ter-deploy yang dapat kita gunakan untuk mengirim permintaan guna menghasilkan prediksi untuk tugas klasifikasi.
Apa itu Vertex AI?
Siklus hidup machine learning yang umum terdiri dari banyak tahap:
- Persiapan data, ingestion, eksplorasi
- Rekayasa fitur, pemilihan
- Pelatihan dan penyetelan model
- Deployment dan pemantauan model
Semua tahap dan sub-tahap ini memerlukan seperangkat alat yang berbeda dan tim ahli yang beragam untuk mengoordinasikannya.
Vertex AI dari Google Cloud merampingkan dan menyatukan seluruh proses ini ke dalam satu platform.
Walaupun aplikasi ML skala besar memerlukan spesialis berpengalaman, Vertex AI memberdayakan pengguna di semua tingkat keterampilan:
- AutoML untuk pemula: Tidak memerlukan pengalaman pemrograman. Cukup masukkan data Anda, dan dengan beberapa klik, AutoML menghasilkan model berkualitas tinggi untuk Anda. Seluruh pekerjaan berat seperti persiapan data, pembangunan model termasuk pemilihan algoritme dan penyetelan hyperparameter dilakukan di balik layar.
- Pelatihan model kustom untuk ahli: Pengalaman Anda adalah batasnya. Bagi data scientist berpengalaman dan insinyur ML, Vertex AI memberikan fleksibilitas untuk melatih model menggunakan framework pilihan mereka, seperti PyTorch, TensorFlow, atau XGBoost.
- Deployment untuk semua orang: Setelah Anda memiliki model yang dilatih, baik oleh AutoML maupun kustom, Vertex AI memudahkan proses deployment. Anda dapat memublikasikan model sebagai API real-time untuk diintegrasikan ke produk Anda atau menggunakan prediksi batch untuk tugas berskala besar.
Ada banyak hal yang tidak kami sebutkan di bagian ini, karena Anda akan berkesempatan mengerjakan sebagian besar di antaranya sendiri dalam tutorial ini.
Apa itu Layanan Google Cloud?
Sebelum kita mulai mengeksplorasi platform, kita perlu menyebutkan induknya — layanan Google Cloud. Google Cloud Services mencakup beragam solusi komputasi awan yang menyediakan penyimpanan, jaringan, basis data, analitik, dan kapabilitas machine learning.
Layanan-layanan ini bekerja selaras dengan Vertex AI untuk menyatukan alur kerja machine learning Anda. Berikut ringkasan layanan yang sering digunakan bersama Vertex AI:
Penyimpanan dan pengelolaan data
- Cloud Storage: Bertindak sebagai repositori pusat untuk data mentah Anda, dapat diakses oleh Vertex AI untuk pelatihan dan analisis.
- BigQuery: Gudang data yang kuat untuk menyimpan dan melakukan query dataset besar, memungkinkan Vertex AI menggunakan BigQuery ML untuk pelatihan di dalam suite.
Sumber daya komputasi
- Compute Engine: Menyediakan mesin virtual dengan berbagai konfigurasi untuk kebutuhan pelatihan model kustom Anda. Vertex AI dapat terhubung ke mesin-mesin ini untuk tugas pelatihan yang intensif sumber daya.
- Vertex AI Pipelines: Mengoordinasikan alur kerja ML yang kompleks di berbagai sumber daya komputasi agar efisien.
Layanan Google Cloud selalu tersedia dari akun Google Anda jika Anda mengunjungi cloud.google.com. Jika belum pernah menggunakannya, klik “Get started for free” untuk mendapatkan uji coba gratis.
Jika sudah, Anda bisa langsung menuju ke console.cloud.google.com sehingga kita dapat mulai.
Menyiapkan Google Cloud Console untuk Vertex AI
Disclaimer: Jika Anda ingin mengikuti tutorial ini, siapkan biaya sekitar $25–30 untuk Vertex AI. Kita akan menggunakan konfigurasi termurah.
Saat Anda mengunjungi Google Cloud Console, kemungkinan Anda akan tiba di halaman sambutan berikut:
Halaman ini menampilkan nama workspace Anda; milik saya adalah ibexprogramming.com.
Hal pertama yang akan kita lakukan adalah membuat proyek. Proyek Google Cloud adalah unit organisasi tingkat tinggi untuk mengelola sumber daya bagi suatu tugas spesifik. Berikut GIF cara membuatnya:
Setelah proyek dibuat, pilih proyek tersebut sehingga bilah atas halaman menampilkan ini:
Sekarang, Anda perlu membuat akun penagihan karena Vertex AI memerlukan informasi penagihan untuk mengaktifkan layanannya. Jangan khawatir — Anda tidak akan dikenai biaya hingga menggunakan sumber daya berbayar. Jadi, buka https://console.cloud.google.com/billing:
Jika Anda belum memiliki akun seperti saya, klik “Create account” dan ikuti instruksinya. Kita akan menautkan akun penagihan ini ke proyek kita di bagian berikutnya.
Setelah itu, kembali ke https://console.cloud.google.com/ dan klik tombol “View all products” di bagian bawah halaman:
Halaman berikutnya akan menampilkan semua layanan yang ditawarkan Google Cloud untuk proyek Anda. Cari “Vertex AI” (Ctrl + F) dan sematkan ke menu untuk akses mudah. Lalu, klik layanannya:
Ini akan mengarahkan Anda ke dasbor Vertex AI Anda. Jendela mungkin muncul meminta Anda mengaktifkan Vertex AI API — pilih “Enable.” Jika jendela tidak muncul, Anda dapat mengeklik tombol “Enable all API permissions” untuk melakukan hal yang sama.
Sekarang, kita siap mengunggah dataset ke Vertex AI.
Mengunggah Dataset di Vertex AI
Ada berbagai cara untuk menambahkan dataset ke Vertex AI. Di bagian ini, kita akan menggunakan file CSV lokal demi kesederhanaan.
Unduh dataset contoh
Untuk artikel ini, kita akan menggunakan dataset Dry Bean dari repositori UCI Machine Learning. Dataset ini berisi 13 ribu contoh kacang dan 15 pengukuran numeriknya.
Tugasnya adalah mengklasifikasikan ke dalam tujuh jenis kacang: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz, dan Sira.
Setelah mengunduh, simpan file Excel di dalam ZIP yang diunduh ke direktori lokal Anda:
from pathlib import Path
cwd = Path.cwd()
data_path = cwd / "data" / "Dry_Bean_Dataset.xlsx"
Lalu, kita dapat membaca file ini dengan pandas dan menyimpannya kembali sebagai CSV:
import pandas as pd
beans = pd.read_excel(data_path)
beans.shape
(13611, 17)Perhatikan bahwa fungsi read_excel mengharuskan Anda memasang pustaka openpyxl dengan PIP.
Bagus, kita sudah memiliki dataset sebagai DataFrame. Mari simpan kembali sebagai CSV:
beans.to_csv(cwd / "data" / "dry_bean.csv", index=False)Buat bucket Cloud Storage
Seperti yang disebutkan sebelumnya, kita memerlukan Google Storage Bucket untuk menyimpan data mentah. Ikuti GIF di bawah untuk menavigasi ke dasbor produk:
GIF tersebut menunjukkan bahwa untuk mulai menggunakan layanan penyimpanan, kita perlu menautkan akun penagihan, yang kita lakukan menggunakan akun yang dibuat sebelumnya. Setelah itu, Anda dapat membuat bucket dengan nama yang unik secara global:
Setelah menemukan nama unik, klik “Continue” hingga bucket dibuat — Anda dapat memilih opsi default untuk semua kolom.
Sekarang, kita siap melakukan ingestion file CSV yang telah kita simpan pada bagian sebelumnya.
Mengimpor CSV lokal ke Vertex AI
Sekarang, mari kembali ke dasbor Vertex AI dan buka tab Datasets:
Anda akan menemukannya kosong, jadi klik tombol “+Create”:
Beri dataset nama unik dan pilih opsi tabular:
Kemudian, platform menampilkan opsi sumber. Pilih untuk mengunggah file CSV lokal, dan untuk Cloud Storage path, pilih bucket yang baru saja Anda buat:
Setelah dataset berhasil diunggah, Anda akan dialihkan ke tab “Analyze” yang menampilkan metadata dasar tentang file CSV. Anda juga akan melihat tombol “TRAIN NEW MODEL”, yang akan memulai pekerjaan pelatihan AutoML.
Namun, kita tidak akan menggunakan tombol itu karena ditujukan untuk pemula ML. Sebagai gantinya, kita akan menggunakan Vertex AI Workbench untuk mengonfigurasi lingkungan coding JupyterLab dan sumber daya komputasi guna menjalankan baik AutoML maupun pustaka kustom.
Mengonfigurasi JupyterLab dan Sumber Daya Komputasi di Vertex AI Workbench
Karena Vertex AI adalah platform terpadu, ia juga menawarkan lingkungan pengembangan yang disebut workbench. Untuk membuat workbench, buka tabnya sendiri dan ikuti instruksi pada GIF di bawah ini:
Setiap workbench dilengkapi JupyterLab 3 yang sudah terpasang. Jadi, Anda hanya perlu mengonfigurasi opsi perangkat keras sesuai anggaran dan kebutuhan Anda. Karena kita memiliki dataset yang cukup kecil, saya memilih instance terlemah untuk ilustrasi, yang biayanya hanya sekitar ~$0,12 per jam (saya sarankan memilih mesin dengan lebih banyak inti CPU agar komputasi lebih cepat).
Saya juga mengubah durasi idle shutdown menjadi 10 menit agar lingkungan berhenti otomatis jika saya lupa mematikannya.
Workbench akan memerlukan waktu untuk inisialisasi. Setelah siap, tombol “OPEN JUPYTERLAB” akan muncul, dan kita bisa mengekliknya:
Kita akan diarahkan ke antarmuka JupyterLab yang familiar. Dari sana, buat notebook Python 3 baru dan ubah namanya sesuai keinginan. Di sel pertama, pasang/tingkatkan SDK layanan Google Cloud google-cloud-aiplatform:
!pip3 install --upgrade --quiet google-cloud-aiplatform
Kemudian, Anda dapat membuat daftar proyek yang tersedia di bawah akun Anda dengan gcloud config list:
!gcloud config list
[compute]
region = us-central1
[core]
account = # HIDDEN #
disable_usage_reporting = True
project = vertexai-tutorial-423010
[dataproc]
region = us-central1
Your active configuration is: [default]
gcloud dan gsutil adalah utilitas terminal yang tersedia di semua workbench. Keduanya memungkinkan Anda mengelola layanan Google Cloud secara efisien.
Dari output yang tercetak, simpan informasi berikut sebagai variabel Python:
PROJECT_ID = 'vertexai-tutorial-423010'
BUCKET_URI = 'gs://vetex-tutorial-bucket-bex'
REGION = 'us-central1'
Jangan lupa ubah BUCKET_URI ke nama bucket Anda sendiri. Lalu, impor submodul aiplatform dan inisialisasi:
from google.cloud import aiplatform as ai
ai.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)
aiplatform akan berfungsi sebagai SDK untuk berinteraksi dengan fitur Vertex AI.
Ketika Anda selesai mengikuti tutorial atau ingin beristirahat, jangan lupa untuk STOP instance guna mencegah biaya yang tidak diinginkan.
Melatih dan Mendeploy Model AutoML di Vertex AI
Sekarang, mari melatih model dengan AutoML yang, seperti disebutkan sebelumnya, menangani seluruh pekerjaan berat untuk kita dan mengembalikan model terbaik yang dapat dilatih untuk dataset yang diberikan. Ini berarti agar dapat memanfaatkan AutoML sepenuhnya, Anda harus memastikan dataset yang Anda berikan berkualitas setinggi mungkin. Jadi, ada baiknya meluangkan waktu untuk merekayasa fitur baru dan melakukan langkah praproses sebelumnya.
AutoML melakukan praproses dataset secara internal, tetapi tidak dapat memperbaiki semua masalah pada dataset Anda.
Namun, di bagian ini, kita hanya akan melatih model AutoML baseline tanpa praproses atau rekayasa fitur demi kesederhanaan.
Memuat data dari bucket Google Storage
Hal pertama yang ingin kita lakukan adalah memuat dataset CSV dari bucket kita dan meluangkan waktu untuk mengeksplorasinya. Ingat, EDA adalah langkah penting, dan Anda dapat mempelajarinya lebih lanjut dalam kursus Exploratory Data Analysis in Python kami!
import pandas as pd
# Path to your CSV file in GCS bucket
gcs_path = "gs://vertex-tutorial-bucket-bex/dry_bean.csv"
beans = pd.read_csv(gcs_path)
beans.head()
Kabar baiknya adalah pandas dapat mengunduh file dari path GCS. Satu catatan, kode di atas hanya berfungsi di workbench Vertex AI karena sudah diautentikasi dengan kredensial Google Cloud Anda.
Mengeksplorasi data dengan pandas di Vertex AI
Kita tidak akan melakukan analisis mendalam terhadap dataset karena akan mengalihkan fokus dari tujuan utama artikel. Jadi, kita cukup mencetak beberapa statistik ringkas dan bagan:
beans.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 13611 entries, 0 to 13610
Data columns (total 17 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Area 13611 non-null int64
1 Perimeter 13611 non-null float64
2 MajorAxisLength 13611 non-null float64
3 MinorAxisLength 13611 non-null float64
4 AspectRation 13611 non-null float64
5 Eccentricity 13611 non-null float64
6 ConvexArea 13611 non-null int64
7 EquivDiameter 13611 non-null float64
8 Extent 13611 non-null float64
9 Solidity 13611 non-null float64
10 roundness 13611 non-null float64
11 Compactness 13611 non-null float64
12 ShapeFactor1 13611 non-null float64
13 ShapeFactor2 13611 non-null float64
14 ShapeFactor3 13611 non-null float64
15 ShapeFactor4 13611 non-null float64
16 Class 13611 non-null object
dtypes: float64(14), int64(2), object(1)
memory usage: 1.8+ MB
Jadi, ada 15 fitur numerik dan satu kolom target — Class. Hanya ada ~13 ribu catatan dan tidak ada nilai hilang. Ini akan sangat menyederhanakan pelatihan.
Mari simpan nama fitur ke dalam daftar terpisah karena mungkin kita memerlukannya nanti:
feature_names = beans.columns.tolist()
Sekarang, mari buat pair-plot dari beberapa fitur yang tampak penting:
import seaborn as sns
sns.pairplot(
beans,
vars=["Area", "MajorAxisLength", "MinorAxisLength", "Eccentricity", "roundness"],
hue="Class",
);
Kita melihat beberapa tren menarik — terutama, tampaknya kacang Bombay (hijau) jelas terpisah dari yang lain dalam hal pengukuran fisiknya.
Mari juga plot matriks korelasi:
import matplotlib.pyplot as plt
correlation = beans.corr(numeric_only=True)
# Create a square heatmap with center at 0
sns.heatmap(correlation, center=0, square=True, cmap="coolwarm", vmin=-1, vmax=1)
plt.show()
Ada beberapa fitur yang hampir berkorelasi sempurna dan itu masuk akal karena terkait dengan pengukuran fisik. Namun, kita juga memiliki beberapa pasangan fitur yang tidak menunjukkan korelasi atau sangat kecil korelasinya.
Pada titik ini, saya serahkan kepada Anda untuk melanjutkan eksplorasi dan mencoba menemukan beberapa pertanyaan untuk dijawab mengenai dataset.
Menjalankan pekerjaan pelatihan AutoML
Untuk memulai pekerjaan pelatihan AutoML, pertama-tama kita memerlukan objek dataset yang kompatibel dengannya:
ds = ai.TabularDataset.create(
display_name="dry_bean_dataset", gcs_source=gcs_path
)
TabularDataset created.
type(ds)google.cloud.aiplatform.datasets.tabular_dataset.TabularDataset
ds.resource_name
'projects/10783853768/locations/us-central1/datasets/4978116960081412096'
Kita menggunakan metode TabularDataset.create untuk menginisialisasi sebagai ds. Vertex AI memberinya nama sendiri, yang dapat diakses melalui atribut resource_name.
Sekarang, kita inisialisasi pekerjaan dengan kelas ai.AutoMLTabularTrainingJob. Kelas ini memerlukan dua argumen:
- Nama tampilan untuk pekerjaan
- Tujuan tugas — klasifikasi, dalam kasus ini.
job = ai.AutoMLTabularTrainingJob(
display_name="dry-bean-classification",
optimization_prediction_type="classification",
)
Berikutnya, kita jalankan metode run dari pekerjaan tersebut:
model = job.run(
dataset=ds,
target_column="Class",
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
model_display_name="baseline-classification-model",
disable_early_stopping=False,
)
Parameter metodenya cukup jelas. Kode ini akan memerlukan waktu untuk selesai dieksekusi (bergantung pada daya komputasi Anda).
Jika Anda pergi ke tab “MODEL DEVELOPMENT > TRAINING” di dasbor dan klik nama pekerjaan, Anda akan melihat progres pelatihan secara langsung. Gambar di bawah menunjukkan bahwa pelatihan berada pada tahap praproses:
Melihat hasil
Setelah pelatihan selesai, kembali ke tab training dan klik pada nama model. Kali ini, akan ditampilkan metrik kinerja di samping model:
Seperti yang Anda lihat, bahkan untuk model baseline, kita memiliki metrik yang sangat baik, semuanya di atas 0,90.
Mendeploy model AutoML dan menghasilkan prediksi
Kita sekarang dapat mendeploy model ini dengan satu baris kode:
endpoint = model.deploy(machine_type="n1-standard-4")
Metode deploy hanya memerlukan satu argumen — jenis mesin untuk menjalankan inference. Saya tidak benar-benar menjalankan baris di atas karena deployment menimbulkan biaya tambahan selama model online.
Namun, jika Anda menjalankannya, metode deploy akan mengembalikan objek Endpoint yang dapat kita kirimi permintaan:
prediction = endpoint.predict(
[
{
"Area": "30099",
"Perimeter": "638.8209999999999",
"MajorAxisLength": "237.14191130827916",
"MinorAxisLength": "162.3034300714102",
"AspectRation": "1.4611022774068396",
"Eccentricity": "0.7290928631259719",
"ConvexArea": "30477",
"EquivDiameter": "195.76321681302556",
"Extent": "0.8036043251902283",
"Solidity": "0.9875972044492568",
"roundness": "0.9268374259664279",
"Compactness": "0.8255108332939839",
"ShapeFactor1": "0.007878730566074592",
"ShapeFactor2": "0.002256976927384019",
"ShapeFactor3": "0.6814681358857279",
"ShapeFactor4": "0.9956946453228307",
}
]
)
print(prediction)
Objek ini memiliki metode predict yang menerima daftar sampel untuk diprediksi. Sampel harus diberikan dalam format JSON.
Anda juga dapat menggunakan dasbor untuk mendeploy model. Jika Anda pergi ke tab “MODEL REGISTRY”, Anda akan melihat model tercantum di sana. Klik namanya dan pilih tab “DEPLOY & TEST”:
Mengklik tombol ‘DEPLOY TO ENDPOINT’ akan membawa Anda ke halaman terpisah tempat Anda dapat mengonfigurasi mesin untuk mendeploy model. Namun sebelum itu, Anda dapat mengujinya di area di bawah tombol deployment:
Melatih dan Mendeploy Model Kustom di Vertex AI
Mendeploy model kustom di Vertex AI lebih menantang dibanding model AutoML dan juga lebih mahal karena akan ada beberapa kontainer Docker yang terlibat di atas biaya Workbench dan deployment Anda. Jika Anda siap, mari lanjut!
Gambaran tingkat tinggi pelatihan kustom di Vertex AI
Pelatihan kustom dimulai dengan skrip pelatihan model kustom. Dalam skrip ini, kita dapat melakukan apa pun selama skrip tersebut:
- Memuat data dari bucket GCS
- Melatih model dengan framework ML (TF, PyTorch, Scikit-learn, XGBoost)
- Opsional, menyetel hyperparameter model
- Menyimpannya ke bucket GCS untuk menyimpan model yang telah dilatih atau disetel.
Kemudian, skrip pelatihan ini harus diubah menjadi kontainer Docker dan didorong ke Google Container Registry. Dari sana, kita dapat menggunakan Vertex AI Python SDK atau dasbor untuk melatih model kustom.
Membuat struktur direktori untuk kode pelatihan
Pertama, mari buat struktur direktori seperti yang direkomendasikan oleh codelab ini oleh Google. Di workbench Anda, beralihlah ke terminal dengan memulai launcher baru:
Lalu, buat direktori baru bernama “dry-beans” dan masuk ke dalamnya:
$ mkdir dry-beans
$ cd dry-beans/
Di dalam dry-beans, buat direktori lain bernama trainer dan di dalamnya, file Python train.py:
$ mkdir trainer
$ touch trainer/train.py
Membuat Dockerfile
Selanjutnya, buat Dockerfile baru:
$ touch Dockerfile
Buka file tersebut dan tempel konten berikut:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Install XGBoost
RUN pip install xgboost==1.6.2
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
Dockerfile ini menggunakan image deep learning resmi yang disediakan oleh Google Container Registry dengan TensorFlow terpasang. File ini menyalin direktori trainer kita lalu memasang XGBoost. Di akhir, image akan menjalankan skrip Python kita.
Menulis skrip pelatihan
Skripnya harus memuat dataset Dry Beans dari bucket GCP kita, melatih classifier XGBoost di atasnya, dan menyimpan model kembali ke bucket. Saya telah menulis skrip sederhana yang melakukan tugas-tugas tersebut di GitHub gist ini (saya tidak membagikannya di sini untuk menghemat ruang).
Salin/tempel kode pada gist ke train.py. Lalu, kembali di terminal, pasang XGBoost karena belum terpasang sebelumnya di Workbench pilihan Anda, dan jalankan skripnya:
$ pip install xgboost==1.6.2
$ python trainer/train.py
Membangun image Docker
Jika skrip berjalan tanpa error, lanjutkan dengan memasukkan dua variabel ini ke terminal:
$ PROJECT_ID='vertexai-tutorial-423010' # Replace with your PROJECT_ID from earlier
$ IMAGE_URI="gcr.io/$PROJECT_ID/dry-beans:v1" # This stays the same
Variabel-variabel ini akan digunakan saat kita membangun kontainer, jadi lakukan:
$ docker build ./ -t $IMAGE_URI
Proses build akan memakan waktu. Setelah selesai, jalankan kontainernya untuk memastikan semuanya berjalan lancar:
$ docker run $IMAGE_URI
Model trained successfully!
Model uploaded successfully!
Jika Anda mendapatkan pesan sukses di atas, maka kontainer siap untuk didorong (push):
$ docker push $IMAGE_URIMembuat pekerjaan pelatihan kustom
Pada titik ini, sebagian besar pekerjaan sudah selesai. Kita sekarang bisa beralih ke dasbor dan membuat pekerjaan pelatihan kustom menggunakan kontainer yang baru saja kita dorong. Jadi, buka tab “MODEL REGISTRY” dan klik “CREATE”:
Untuk metode pelatihan, pilih opsi “No managed dataset” dan “Custom training”. Pada panel berikutnya (Model details), beri model nama — dry-beans-classifier.
Pada panel training container:
Pilih kontainer yang telah kita dorong untuk custom image dan bucket cloud-ai-platform untuk output model. Kemudian, klik continue hingga Anda mencapai panel "Compute and pricing":
Pilih mesin standar n1 dengan 4 CPU dan akhirnya, klik "START TRAINING". Lalu, beralih ke tab "TRAINING" di dasbor Anda.
Pada titik ini, Anda akan melihat salah satu dari dua hal:
- Status pelatihan gagal
- Status pelatihan sedang berlangsung
Saya mendapatkan yang pertama, jadi mari kita selidiki alasannya dengan mengklik nama model:
Error tersebut memberi tahu saya bahwa saya melebihi jumlah CPU pelatihan kustom yang diizinkan. Saya menelusuri masalah ini lebih jauh dan hasilnya cukup mengecewakan.
Biasanya, GCP memberikan setidaknya 20 kuota CPU untuk setiap wilayah komputasi, tetapi setelah memeriksa profil saya, saya menemukan bahwa kuota saya hanya 1. Ini berarti saya tidak dapat menjalankan pekerjaan pelatihan kustom, karena semua mesin yang ditawarkan Google memiliki setidaknya dua CPU.
Saya mencoba meningkatkan kuota menggunakan jawaban dari utas StackOverflow ini, tetapi tidak berhasil. Pesan yang saya terima adalah bahwa pengguna Vertex AI baru hanya diizinkan satu unit CPU. Jika saya ingin meningkatkan kuota, saya perlu mengajukan tiket dukungan, yang ternyata tidak gratis (Anda memerlukan kontrak dukungan berbayar).
Jadi, jika Anda kurang beruntung seperti saya, coba jawaban di utas SO tersebut. Jawaban itu berhasil bagi sebagian orang, tetapi jika tidak berhasil bagi Anda, maka satu-satunya opsi adalah menghubungi dukungan.
Namun jika Anda beruntung dan pelatihan Anda selesai, maka Anda akan dapat mendeploy model menggunakan langkah-langkah yang sama seperti yang saya jelaskan untuk model AutoML.
Kesimpulan
Vertex AI adalah platform besar dengan banyak fitur. Dalam tutorial ini, kita baru menyentuh permukaannya, tetapi kita telah membahas blok bangunan terpenting dari platform ini. Dengan menguasai pembuatan bucket penyimpanan, workbench, dan pekerjaan pelatihan, Anda akan siap mengeksplorasi bagian platform lainnya.
Jika Anda ingin mempelajari lebih lanjut tentang layanan Google Cloud, lihat sumber terkait yang direkomendasikan berikut:
Topik
