1. Ringkasan
Di lab ini, Anda akan mempelajari cara menggunakan Vertex AI Workbench untuk eksplorasi data dan pelatihan model ML.
Yang Anda pelajari
Anda akan mempelajari cara:
- Membuat dan mengonfigurasi instance Vertex AI Workbench
- Menggunakan konektor BigQuery Vertex AI Workbench
- Melatih model di kernel Vertex AI Workbench
Total biaya untuk menjalankan lab ini di Google Cloud adalah sekitar $1.
2. Pengantar Vertex AI
Lab ini menggunakan penawaran produk AI terbaru yang tersedia di Google Cloud. Vertex AI mengintegrasikan penawaran ML di Google Cloud ke dalam pengalaman pengembangan yang lancar. Sebelumnya, model yang dilatih dengan AutoML dan model kustom dapat diakses melalui layanan terpisah. Penawaran baru ini menggabungkan kedua model ini menjadi satu API, beserta produk baru lainnya. Anda juga dapat memigrasikan project yang sudah ada ke Vertex AI.
Vertex AI mencakup banyak produk yang berbeda untuk mendukung alur kerja ML secara menyeluruh. Lab ini akan berfokus pada Vertex AI Workbench.
Vertex AI Workbench membantu pengguna membangun alur kerja berbasis notebook end-to-end dengan cepat melalui integrasi yang mendalam dengan layanan data (seperti Dataproc, Dataflow, BigQuery, dan Dataplex) dan Vertex AI. Vertex AI Workbench memungkinkan data scientist terhubung ke layanan data GCP, menganalisis set data, bereksperimen dengan berbagai teknik pemodelan, men-deploy model terlatih ke produksi, dan mengelola MLOps melalui siklus proses model.
3. Ringkasan Kasus Penggunaan
Di lab ini, Anda akan menjelajahi set data London Bicycles Hire. Data ini berisi informasi tentang perjalanan sepeda dari program berbagi sepeda publik London sejak tahun 2011. Anda akan mulai dengan menjelajahi set data ini di BigQuery melalui konektor BigQuery Vertex AI Workbench. Kemudian, Anda akan memuat data ke dalam Jupyter Notebook menggunakan pandas dan melatih model TensorFlow untuk memprediksi durasi perjalanan sepeda berdasarkan waktu perjalanan dan jarak yang ditempuh orang tersebut.
Lab ini menggunakan lapisan pra-pemrosesan Keras untuk mengubah dan menyiapkan data input untuk pelatihan model. API ini memungkinkan Anda membangun pra-pemrosesan langsung ke dalam grafik model TensorFlow, sehingga mengurangi risiko perbedaan performa pelatihan/penayangan dengan memastikan bahwa data pelatihan dan data penayangan mengalami transformasi yang identik. Perhatikan bahwa mulai TensorFlow 2.6, API ini stabil. Jika Anda menggunakan TensorFlow versi lama, Anda harus mengimpor simbol eksperimental.
4. Menyiapkan lingkungan Anda
Anda memerlukan project Google Cloud Platform dengan penagihan yang diaktifkan untuk menjalankan codelab ini. Untuk membuat project, ikuti petunjuk di sini.
Langkah 1: Aktifkan Compute Engine API
Buka Compute Engine dan pilih Aktifkan jika belum diaktifkan.
Langkah 2: Aktifkan Vertex AI API
Buka bagian Vertex AI di Cloud Console Anda, lalu klik Aktifkan Vertex AI API.
Langkah 3: Membuat instance Vertex AI Workbench
Dari bagian Vertex AI di Cloud Console Anda, klik Workbench:
Aktifkan Notebooks API jika belum diaktifkan.
Setelah diaktifkan, klik NOTEBOOK TERKELOLA:
Kemudian, pilih NOTEBOOK BARU.
Namai notebook Anda, lalu di bagian Izin, pilih Akun layanan
Pilih Setelan Lanjutan.
Di bagian Keamanan, pilih "Aktifkan terminal" jika belum diaktifkan.
Anda dapat membiarkan semua setelan lanjutan lainnya apa adanya.
Selanjutnya, klik Buat.
Setelah instance dibuat, pilih BUKA JUPYTERLAB.
5. Menjelajahi set data di BigQuery
Di instance Vertex AI Workbench, buka sisi kiri dan klik konektor BigQuery in Notebooks.
Konektor BigQuery memungkinkan Anda menjelajahi dan membuat kueri set data BigQuery dengan mudah. Selain set data apa pun di project Anda, Anda dapat menjelajahi set data di project lain dengan mengklik tombol Tambahkan Project.
Untuk lab ini, Anda akan menggunakan data dari set data publik BigQuery. Scroll ke bawah hingga Anda menemukan set data london_bicycles. Anda akan melihat bahwa set data ini memiliki dua tabel, cycle_hire dan cycle_stations. Mari kita pelajari satu per satu.
Pertama, klik dua kali tabel cycle_hire. Anda akan melihat bahwa tabel terbuka sebagai tab baru dengan skema tabel serta metadata seperti jumlah baris dan ukuran.
Jika mengklik tab Preview, Anda akan dapat melihat sampel data. Mari jalankan kueri sederhana untuk melihat perjalanan populer. Pertama, klik tombol Query table.
Kemudian, tempel kode berikut ke editor SQL, lalu klik Submit Query.
SELECT
start_station_name,
end_station_name,
IF(start_station_name = end_station_name,
TRUE,
FALSE) same_station,
AVG(duration) AS avg_duration,
COUNT(*) AS total_rides
FROM
`bigquery-public-data.london_bicycles.cycle_hire`
GROUP BY
start_station_name,
end_station_name,
same_station
ORDER BY
total_rides DESC
Dari hasil kueri, Anda akan melihat bahwa perjalanan bersepeda ke dan dari stasiun Hyde Park Corner adalah yang paling populer.
Selanjutnya, klik dua kali tabel cycle_stations, yang memberikan informasi tentang setiap stasiun.
Kita ingin menggabungkan tabel cycle_hire dan cycle_stations. Tabel cycle_stations berisi lat/lon untuk setiap stasiun. Anda akan menggunakan informasi ini untuk memperkirakan jarak yang ditempuh pada setiap perjalanan bersepeda dengan menghitung jarak antara stasiun awal dan akhir.
Untuk melakukan penghitungan ini, Anda akan menggunakan fungsi geografi BigQuery. Secara khusus, Anda akan mengonversi setiap string lintang/bujur menjadi ST_GEOGPOINT dan menggunakan fungsi ST_DISTANCE untuk menghitung jarak garis lurus dalam meter antara dua titik. Anda akan menggunakan nilai ini sebagai proxy untuk jarak yang ditempuh dalam setiap perjalanan bersepeda.
Salin kueri berikut ke editor SQL Anda, lalu klik Kirim Kueri. Perhatikan bahwa ada tiga tabel dalam kondisi JOIN karena kita perlu menggabungkan tabel stasiun dua kali untuk mendapatkan lat/lon untuk stasiun awal dan stasiun akhir perjalanan sepeda.
WITH staging AS (
SELECT
STRUCT(
start_stn.name,
ST_GEOGPOINT(start_stn.longitude, start_stn.latitude) AS POINT,
start_stn.docks_count,
start_stn.install_date
) AS starting,
STRUCT(
end_stn.name,
ST_GEOGPOINT(end_stn.longitude, end_stn.latitude) AS point,
end_stn.docks_count,
end_stn.install_date
) AS ending,
STRUCT(
rental_id,
bike_id,
duration, --seconds
ST_DISTANCE(
ST_GEOGPOINT(start_stn.longitude, start_stn.latitude),
ST_GEOGPOINT(end_stn.longitude, end_stn.latitude)
) AS distance, --meters
start_date,
end_date
) AS bike
FROM `bigquery-public-data.london_bicycles.cycle_stations` AS start_stn
LEFT JOIN `bigquery-public-data.london_bicycles.cycle_hire` as b
ON start_stn.id = b.start_station_id
LEFT JOIN `bigquery-public-data.london_bicycles.cycle_stations` AS end_stn
ON end_stn.id = b.end_station_id
LIMIT 700000)
SELECT * from STAGING
6. Melatih model ML di kernel TensorFlow
Vertex AI Workbench memiliki lapisan kompatibilitas komputasi yang memungkinkan Anda meluncurkan kernel untuk TensorFlow, PySpark, R, dll., semuanya dari satu instance notebook. Di lab ini, Anda akan membuat notebook menggunakan kernel TensorFlow.
Membuat DataFrame
Setelah kueri dijalankan, klik Copy code for DataFrame. Dengan begitu, Anda dapat menempelkan kode Python ke notebook yang terhubung ke klien BigQuery dan mengekstrak data ini sebagai pandas DataFrame.
Selanjutnya, kembali ke Peluncur dan buat notebook TensorFlow 2.
Di sel pertama notebook, tempelkan kode yang disalin dari Editor Kueri. Perintahnya seharusnya terlihat seperti berikut:
# The following two lines are only necessary to run once.
# Comment out otherwise for speed-up.
from google.cloud.bigquery import Client, QueryJobConfig
client = Client()
query = """WITH staging AS (
SELECT
STRUCT(
start_stn.name,
ST_GEOGPOINT(start_stn.longitude, start_stn.latitude) AS POINT,
start_stn.docks_count,
start_stn.install_date
) AS starting,
STRUCT(
end_stn.name,
ST_GEOGPOINT(end_stn.longitude, end_stn.latitude) AS point,
end_stn.docks_count,
end_stn.install_date
) AS ending,
STRUCT(
rental_id,
bike_id,
duration, --seconds
ST_DISTANCE(
ST_GEOGPOINT(start_stn.longitude, start_stn.latitude),
ST_GEOGPOINT(end_stn.longitude, end_stn.latitude)
) AS distance, --meters
start_date,
end_date
) AS bike
FROM `bigquery-public-data.london_bicycles.cycle_stations` AS start_stn
LEFT JOIN `bigquery-public-data.london_bicycles.cycle_hire` as b
ON start_stn.id = b.start_station_id
LEFT JOIN `bigquery-public-data.london_bicycles.cycle_stations` AS end_stn
ON end_stn.id = b.end_station_id
LIMIT 700000)
SELECT * from STAGING"""
job = client.query(query)
df = job.to_dataframe()
Untuk tujuan lab ini, kami membatasi set data hingga 700.000 untuk mempersingkat waktu pelatihan. Namun, jangan ragu untuk mengubah kueri dan bereksperimen dengan seluruh set data.
Selanjutnya, impor library yang diperlukan.
from datetime import datetime
import pandas as pd
import tensorflow as tf
Jalankan kode berikut untuk membuat frame data yang diperkecil yang hanya berisi kolom yang diperlukan untuk bagian ML dalam latihan ini.
values = df['bike'].values
duration = list(map(lambda a: a['duration'], values))
distance = list(map(lambda a: a['distance'], values))
dates = list(map(lambda a: a['start_date'], values))
data = pd.DataFrame(data={'duration': duration, 'distance': distance, 'start_date':dates})
data = data.dropna()
Kolom start_date adalah datetime Python. Daripada menggunakan datetime ini secara langsung dalam model, Anda akan membuat dua fitur baru yang menunjukkan hari dalam seminggu dan jam dalam sehari saat perjalanan sepeda terjadi.
data['weekday'] = data['start_date'].apply(lambda a: a.weekday())
data['hour'] = data['start_date'].apply(lambda a: a.time().hour)
data = data.drop(columns=['start_date'])
Terakhir, konversi kolom durasi dari detik ke menit agar lebih mudah dipahami
data['duration'] = data['duration'].apply(lambda x:float(x / 60))
Periksa beberapa baris pertama DataFrame yang diformat. Untuk setiap perjalanan bersepeda, Anda kini memiliki data tentang hari dalam seminggu dan jam dalam sehari saat perjalanan terjadi, serta jarak yang ditempuh. Dari informasi ini, Anda akan mencoba memprediksi durasi perjalanan.
data.head()
Sebelum dapat membuat dan melatih model, Anda harus memisahkan data menjadi set pelatihan dan validasi.
# Use 80/20 train/eval split
train_size = int(len(data) * .8)
print ("Train size: %d" % train_size)
print ("Evaluation size: %d" % (len(data) - train_size))
# Split data into train and test sets
train_data = data[:train_size]
val_data = data[train_size:]
Membuat model TensorFlow
Anda akan membuat model TensorFlow menggunakan Keras Functional API. Untuk memproses data input, Anda akan menggunakan Keras preprocessing layers API.
Fungsi utilitas berikut akan membuat tf.data.Dataset dari Dataframe pandas.
def df_to_dataset(dataframe, label, shuffle=True, batch_size=32):
dataframe = dataframe.copy()
labels = dataframe.pop(label)
ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels))
if shuffle:
ds = ds.shuffle(buffer_size=len(dataframe))
ds = ds.batch(batch_size)
ds = ds.prefetch(batch_size)
return ds
Gunakan fungsi di atas untuk membuat dua tf.data.Dataset, satu untuk pelatihan dan satu untuk validasi. Anda mungkin melihat beberapa peringatan, tetapi Anda dapat mengabaikannya dengan aman.
train_dataset = df_to_dataset(train_data, 'duration')
validation_dataset = df_to_dataset(val_data, 'duration')
Anda akan menggunakan lapisan pra-pemrosesan berikut dalam model:
- Lapisan normalisasi: melakukan normalisasi per fitur pada fitur input.
- Lapisan IntegerLookup: mengubah nilai kategoris bilangan bulat menjadi indeks bilangan bulat.
- Lapisan CategoryEncoding: mengubah fitur kategoris bilangan bulat menjadi representasi padat one-hot, multi-hot, atau TF-IDF.
Perhatikan bahwa lapisan ini tidak dapat dilatih. Sebagai gantinya, Anda menetapkan status lapisan prapemrosesan dengan mengeksposnya ke data pelatihan, melalui metode adapt().
Fungsi berikut akan membuat lapisan normalisasi yang dapat Anda gunakan pada fitur jarak. Anda akan menetapkan status sebelum menyesuaikan model dengan menggunakan metode adapt() pada data pelatihan. Tindakan ini akan menghitung rata-rata dan varians yang akan digunakan untuk normalisasi. Selanjutnya, saat Anda meneruskan set data validasi ke model, rata-rata dan varians yang sama yang dihitung pada data pelatihan ini akan digunakan untuk menskalakan data validasi.
def get_normalization_layer(name, dataset):
# Create a Normalization layer for our feature.
normalizer = tf.keras.layers.Normalization(axis=None)
# Prepare a Dataset that only yields our feature.
feature_ds = dataset.map(lambda x, y: x[name])
# Learn the statistics of the data.
normalizer.adapt(feature_ds)
return normalizer
Demikian pula, fungsi berikut membuat encoding kategori yang akan Anda gunakan pada fitur jam dan hari dalam seminggu.
def get_category_encoding_layer(name, dataset, dtype, max_tokens=None):
index = tf.keras.layers.IntegerLookup(max_tokens=max_tokens)
# Prepare a Dataset that only yields our feature
feature_ds = dataset.map(lambda x, y: x[name])
# Learn the set of possible values and assign them a fixed integer index.
index.adapt(feature_ds)
# Create a Discretization for our integer indices.
encoder = tf.keras.layers.CategoryEncoding(num_tokens=index.vocabulary_size())
# Apply one-hot encoding to our indices. The lambda function captures the
# layer so we can use them, or include them in the functional model later.
return lambda feature: encoder(index(feature))
Selanjutnya, buat bagian praproses model. Pertama, buat lapisan tf.keras.Input untuk setiap fitur.
# Create a Keras input layer for each feature
numeric_col = tf.keras.Input(shape=(1,), name='distance')
hour_col = tf.keras.Input(shape=(1,), name='hour', dtype='int64')
weekday_col = tf.keras.Input(shape=(1,), name='weekday', dtype='int64')
Kemudian, buat lapisan encoding kategori dan normalisasi, lalu simpan di daftar.
all_inputs = []
encoded_features = []
# Pass 'distance' input to normalization layer
normalization_layer = get_normalization_layer('distance', train_dataset)
encoded_numeric_col = normalization_layer(numeric_col)
all_inputs.append(numeric_col)
encoded_features.append(encoded_numeric_col)
# Pass 'hour' input to category encoding layer
encoding_layer = get_category_encoding_layer('hour', train_dataset, dtype='int64')
encoded_hour_col = encoding_layer(hour_col)
all_inputs.append(hour_col)
encoded_features.append(encoded_hour_col)
# Pass 'weekday' input to category encoding layer
encoding_layer = get_category_encoding_layer('weekday', train_dataset, dtype='int64')
encoded_weekday_col = encoding_layer(weekday_col)
all_inputs.append(weekday_col)
encoded_features.append(encoded_weekday_col)
Setelah menentukan lapisan praproses, Anda dapat menentukan bagian model lainnya. Anda akan menggabungkan semua fitur input, dan meneruskannya ke lapisan padat. Lapisan output adalah satu unit karena ini adalah masalah regresi.
all_features = tf.keras.layers.concatenate(encoded_features)
x = tf.keras.layers.Dense(64, activation="relu")(all_features)
output = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(all_inputs, output)
Terakhir, kompilasi model.
model.compile(optimizer = tf.keras.optimizers.Adam(0.001),
loss='mean_squared_logarithmic_error')
Setelah menentukan model, Anda dapat memvisualisasikan arsitektur
tf.keras.utils.plot_model(model, show_shapes=True, rankdir="LR")
Perhatikan bahwa model ini cukup rumit untuk set data sederhana ini. Fitur ini ditujukan untuk tujuan demonstrasi.
Latih selama 1 epoch hanya untuk mengonfirmasi bahwa kode berjalan.
model.fit(train_dataset, validation_data = validation_dataset, epochs = 1)
Melatih model dengan GPU
Selanjutnya, Anda akan melatih model lebih lama dan menggunakan pengalih hardware untuk mempercepat pelatihan. Vertex AI Workbench memungkinkan Anda mengubah hardware tanpa mematikan instance. Dengan menambahkan GPU hanya saat Anda membutuhkannya, Anda dapat menekan biaya.
Untuk mengubah profil hardware, klik jenis mesin di sudut kanan atas, lalu pilih Modify hardware
Pilih Pasang GPU, lalu pilih GPU NVIDIA T4 Tensor Core.
Konfigurasi hardware akan memakan waktu sekitar lima menit. Setelah proses selesai, mari kita latih model lebih lama. Anda akan melihat bahwa setiap epoch membutuhkan waktu yang lebih singkat sekarang.
model.fit(train_dataset, validation_data = validation_dataset, epochs = 5)
🎉 Selamat! 🎉
Anda telah mempelajari cara menggunakan Vertex AI Workbench untuk:
- Menjelajahi data di BigQuery
- Menggunakan klien BigQuery untuk memuat data ke Python
- Melatih model TensorFlow dengan Lapisan Praproses Keras dan GPU
Untuk mempelajari lebih lanjut berbagai bagian Vertex AI, lihat dokumentasinya.
7. Pembersihan
Karena sebelumnya kita telah mengonfigurasi notebook agar kehabisan waktu setelah 60 menit tidak ada aktivitas, jangan khawatir untuk menonaktifkan instance-nya. Jika Anda ingin menonaktifkan instance secara manual, klik tombol Hentikan di bagian Vertex AI Workbench pada konsol. Jika Anda ingin menghapus notebook secara keseluruhan, klik tombol Hapus.
