Vertex AI Workbench: ฝึกโมเดล TensorFlow ด้วยข้อมูลจาก BigQuery

1. ภาพรวม

ในแล็บนี้ คุณจะได้เรียนรู้วิธีใช้ Vertex AI Workbench เพื่อสำรวจข้อมูลและฝึกโมเดล ML

สิ่งที่คุณจะได้เรียนรู้

โดยคุณจะได้เรียนรู้วิธีต่อไปนี้

สร้างและกำหนดค่าอินสแตนซ์ Vertex AI Workbench
ใช้เครื่องมือเชื่อมต่อ BigQuery ของ Vertex AI Workbench
ฝึกโมเดลในเคอร์เนล Vertex AI Workbench

ค่าใช้จ่ายทั้งหมดในการเรียกใช้ Lab นี้ใน Google Cloud อยู่ที่ประมาณ $1

2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI

แล็บนี้ใช้ผลิตภัณฑ์ AI ใหม่ล่าสุดที่พร้อมให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้ โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้จะรวมทั้ง 2 อย่างไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย

Vertex AI มีผลิตภัณฑ์มากมายที่แตกต่างกันเพื่อรองรับเวิร์กโฟลว์ ML แบบครบวงจร ห้องทดลองนี้จะมุ่งเน้นที่ Vertex AI Workbench

Vertex AI Workbench ช่วยให้ผู้ใช้สร้างเวิร์กโฟลว์ที่อิงตาม Notebook แบบครบวงจรได้อย่างรวดเร็วผ่านการผสานรวมอย่างลึกซึ้งกับบริการข้อมูล (เช่น Dataproc, Dataflow, BigQuery และ Dataplex) และ Vertex AI ซึ่งช่วยให้นักวิทยาศาสตร์ข้อมูลเชื่อมต่อกับบริการข้อมูลของ GCP, วิเคราะห์ชุดข้อมูล, ทดลองใช้เทคนิคการสร้างโมเดลต่างๆ, ทำให้ใช้งานได้โมเดลที่ฝึกแล้วในเวอร์ชันที่ใช้งานจริง และจัดการ MLOps ตลอดวงจรของโมเดลได้

3. ภาพรวมกรณีการใช้งาน

ใน Lab นี้ คุณจะได้สำรวจชุดข้อมูลการเช่าจักรยานในลอนดอน ข้อมูลนี้ประกอบด้วยข้อมูลเกี่ยวกับการปั่นจักรยานจากโปรแกรมจักรยานสาธารณะของลอนดอนตั้งแต่ปี 2011 คุณจะเริ่มต้นด้วยการสํารวจชุดข้อมูลนี้ใน BigQuery ผ่านเครื่องมือเชื่อมต่อ BigQuery ของ Vertex AI Workbench จากนั้นคุณจะโหลดข้อมูลลงใน Jupyter Notebook โดยใช้ pandas และฝึกโมเดล TensorFlow เพื่อคาดการณ์ระยะเวลาของการปั่นจักรยานตามเวลาที่ปั่นและระยะทางที่ปั่น

แล็บนี้ใช้เลเยอร์การประมวลผลล่วงหน้าของ Keras เพื่อแปลงและเตรียมข้อมูลอินพุตสำหรับการฝึกโมเดล API นี้ช่วยให้คุณสร้างการประมวลผลล่วงหน้าลงในกราฟโมเดล TensorFlow ได้โดยตรง ซึ่งจะช่วยลดความเสี่ยงของความคลาดเคลื่อนระหว่างการฝึกและการให้บริการด้วยการตรวจสอบว่าข้อมูลฝึกฝนและข้อมูลการแสดงผลได้รับการแปลงที่เหมือนกัน โปรดทราบว่า API นี้เสถียรแล้วตั้งแต่ TensorFlow 2.6 หากคุณใช้ TensorFlow เวอร์ชันเก่า คุณจะต้องนำเข้าสัญลักษณ์ทดลอง

4. ตั้งค่าสภาพแวดล้อม

คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่

ขั้นตอนที่ 1: เปิดใช้ Compute Engine API

ไปที่ Compute Engine แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้

ขั้นตอนที่ 2: เปิดใช้ Vertex AI API

ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API

แดชบอร์ด Vertex AI

ขั้นตอนที่ 3: สร้างอินสแตนซ์ Vertex AI Workbench

จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench

เปิดใช้ Notebooks API หากยังไม่ได้เปิด

Notebook_api

เมื่อเปิดใช้แล้ว ให้คลิก MANAGED NOTEBOOKS

Notebooks_UI

จากนั้นเลือก NOTEBOOK ใหม่

new_notebook

ตั้งชื่อ Notebook แล้วเลือกบัญชีบริการในส่วนสิทธิ์

service_account

เลือกการตั้งค่าขั้นสูง

ในส่วนความปลอดภัย ให้เลือก "เปิดใช้เทอร์มินัล" หากยังไม่ได้เปิดใช้

enable_terminal

คุณปล่อยให้การตั้งค่าขั้นสูงอื่นๆ ทั้งหมดเป็นไปตามเดิมได้

จากนั้นคลิกสร้าง

เมื่อสร้างอินสแตนซ์แล้ว ให้เลือกเปิด JUPYTERLAB

enable_terminal

5. สำรวจชุดข้อมูลใน BigQuery

ในอินสแตนซ์ Vertex AI Workbench ให้ไปที่ด้านซ้ายแล้วคลิกเครื่องมือเชื่อมต่อ BigQuery ใน Notebook

เครื่องมือเชื่อมต่อ BQ

เครื่องมือเชื่อมต่อ BigQuery ช่วยให้คุณสำรวจและค้นหาชุดข้อมูล BigQuery ได้อย่างง่ายดาย นอกเหนือจากชุดข้อมูลในโปรเจ็กต์แล้ว คุณยังสำรวจชุดข้อมูลในโปรเจ็กต์อื่นๆ ได้โดยคลิกปุ่มเพิ่มโปรเจ็กต์

ปักหมุด

สำหรับแล็บนี้ คุณจะใช้ข้อมูลจากชุดข้อมูลสาธารณะของ BigQuery เลื่อนลงจนกว่าจะพบชุดข้อมูล london_bicycles คุณจะเห็นว่าชุดข้อมูลนี้มี 2 ตาราง ได้แก่ cycle_hire และ cycle_stations มาดูรายละเอียดของแต่ละประเภทกัน

london_bike_ds

ก่อนอื่น ให้ดับเบิลคลิกที่ตาราง cycle_hire คุณจะเห็นว่าตารางจะเปิดเป็นแท็บใหม่พร้อมกับสคีมาของตาราง รวมถึงข้อมูลเมตา เช่น จำนวนแถวและขนาด

cycle_hire_ds

หากคลิกแท็บแสดงตัวอย่าง คุณจะเห็นตัวอย่างข้อมูล มาเรียกใช้คําค้นหาแบบง่ายๆ เพื่อดูเส้นทางยอดนิยมกัน ก่อนอื่น ให้คลิกปุ่มตารางการสืบค้น

cycle_hire_preview_ds

จากนั้นวางข้อมูลต่อไปนี้ลงในตัวแก้ไข SQL แล้วคลิกส่งคำค้นหา

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

จากผลการค้นหาของคำค้นหา คุณจะเห็นว่าการปั่นจักรยานไปและกลับจากสถานี Hyde Park Corner เป็นที่นิยมมากที่สุด

journey_query_results

จากนั้นดับเบิลคลิกตาราง cycle_stations ซึ่งมีข้อมูลเกี่ยวกับแต่ละสถานี

เราต้องการผนวกตาราง cycle_hire และ cycle_stations ตาราง cycle_stations มีละติจูด/ลองจิจูดของแต่ละสถานี คุณจะใช้ข้อมูลนี้เพื่อประมาณระยะทางที่ปั่นจักรยานในแต่ละครั้งโดยการคำนวณระยะทางระหว่างสถานีต้นทางและสถานีปลายทาง

หากต้องการทำการคำนวณนี้ คุณจะต้องใช้ฟังก์ชันภูมิศาสตร์ของ BigQuery โดยคุณจะแปลงสตริงละติจูด/ลองจิจูดแต่ละรายการเป็น ST_GEOGPOINT และใช้ฟังก์ชัน ST_DISTANCE เพื่อคำนวณระยะทางในแนวเส้นตรงเป็นเมตรระหว่างจุด 2 จุด คุณจะใช้ค่านี้เป็นตัวแทนของระยะทางที่เดินทางในแต่ละรอบ

คัดลอกคำค้นหาต่อไปนี้ลงในตัวแก้ไข SQL แล้วคลิกส่งคำค้นหา โปรดทราบว่ามีตาราง 3 ตารางในเงื่อนไข JOIN เนื่องจากเราต้องรวมตารางสถานี 2 ครั้งเพื่อรับละติจูด/ลองจิจูดของทั้งสถานีเริ่มต้นและสถานีสิ้นสุดของจักรยาน

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. ฝึกโมเดล ML ในเคอร์เนล TensorFlow

Vertex AI Workbench มีเลเยอร์ความเข้ากันได้ในการคำนวณที่ช่วยให้คุณเปิดตัวเคอร์เนลสำหรับ TensorFlow, PySpark, R ฯลฯ ได้จากอินสแตนซ์ Notebook เดียว ใน Lab นี้ คุณจะได้สร้าง Notebook โดยใช้เคอร์เนล TensorFlow

สร้าง DataFrame

หลังจากเรียกใช้การค้นหาแล้ว ให้คลิก "คัดลอกโค้ดสำหรับ DataFrame" ซึ่งจะช่วยให้คุณวางโค้ด Python ลงใน Notebook ที่เชื่อมต่อกับไคลเอ็นต์ BigQuery และดึงข้อมูลนี้เป็น pandas DataFrame ได้

copy_for_df

จากนั้นกลับไปที่ Launcher แล้วสร้าง Notebook ของ TensorFlow 2

tf_kernel

ในเซลล์แรกของ Notebook ให้วางโค้ดที่คัดลอกจากตัวแก้ไขคำค้นหา โดยควรมีลักษณะดังนี้

# 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()

สําหรับวัตถุประสงค์ของแล็บนี้ เราจะจํากัดชุดข้อมูลไว้ที่ 700, 000 เพื่อให้ใช้เวลาในการฝึกน้อยลง แต่คุณสามารถแก้ไขคําค้นหาและทดลองกับชุดข้อมูลทั้งหมดได้

จากนั้นให้นำเข้าไลบรารีที่จำเป็น

from datetime import datetime
import pandas as pd
import tensorflow as tf

เรียกใช้โค้ดต่อไปนี้เพื่อสร้าง DataFrame ที่ลดขนาดซึ่งมีเฉพาะคอลัมน์ที่จำเป็นสำหรับส่วน ML ของแบบฝึกหัดนี้

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()

คอลัมน์ start_date คือ datetime ของ Python แทนที่จะใช้ datetime นี้ในโมเดลโดยตรง คุณจะสร้างฟีเจอร์ใหม่ 2 รายการที่ระบุวันในสัปดาห์และชั่วโมงของวันที่เกิดการปั่นจักรยาน

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'])

สุดท้าย ให้แปลงคอลัมน์ระยะเวลาจากวินาทีเป็นนาทีเพื่อให้เข้าใจง่ายขึ้น

data['duration'] = data['duration'].apply(lambda x:float(x / 60))

ตรวจสอบ 2-3 แถวแรกของ DataFrame ที่จัดรูปแบบ สำหรับการปั่นจักรยานแต่ละครั้ง ตอนนี้คุณมีข้อมูลเกี่ยวกับวันในสัปดาห์และชั่วโมงของวันที่เกิดการเดินทาง รวมถึงระยะทางที่เดินทางด้วย จากข้อมูลนี้ คุณจะพยายามคาดการณ์ระยะเวลาที่ใช้ในการเดินทาง

data.head()

data_head

ก่อนที่จะสร้างและฝึกโมเดลได้ คุณต้องแยกข้อมูลออกเป็นชุดการฝึกและชุดการตรวจสอบ

# 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:]

สร้างโมเดล TensorFlow

คุณจะสร้างโมเดล TensorFlow โดยใช้ Keras Functional API หากต้องการประมวลผลข้อมูลนำเข้าล่วงหน้า คุณจะต้องใช้ API เลเยอร์การประมวลผลล่วงหน้าของ Keras

ฟังก์ชันยูทิลิตีต่อไปนี้จะสร้าง tf.data.Dataset จาก Pandas Dataframe

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

ใช้ฟังก์ชันด้านบนเพื่อสร้าง tf.data.Dataset 2 รายการ โดยรายการหนึ่งใช้สำหรับการฝึก และอีกรายการใช้สำหรับการตรวจสอบ คุณอาจเห็นคำเตือนบางอย่าง แต่ไม่ต้องสนใจคำเตือนเหล่านั้น

train_dataset = df_to_dataset(train_data, 'duration')
validation_dataset = df_to_dataset(val_data, 'duration')

คุณจะใช้เลเยอร์การประมวลผลล่วงหน้าต่อไปนี้ในโมเดล

เลเยอร์การทำให้เป็นมาตรฐาน: ทำการทำให้เป็นมาตรฐานระดับฟีเจอร์ของฟีเจอร์อินพุต
เลเยอร์ IntegerLookup: เปลี่ยนค่าหมวดหมู่จำนวนเต็มเป็นดัชนีจำนวนเต็ม
ชั้น CategoryEncoding: เปลี่ยนฟีเจอร์เชิงหมวดหมู่ที่เป็นจำนวนเต็มให้เป็นการแสดงแบบหนาแน่นแบบ One-hot, Multi-hot หรือ TF-IDF

โปรดทราบว่าเลเยอร์เหล่านี้ฝึกไม่ได้ แต่คุณจะตั้งค่าสถานะของเลเยอร์การประมวลผลล่วงหน้าโดยการเปิดเผยต่อข้อมูลฝึกฝนผ่านเมธอด adapt()

ฟังก์ชันต่อไปนี้จะสร้างเลเยอร์การทําให้เป็นมาตรฐานที่คุณใช้กับฟีเจอร์ระยะทางได้ คุณจะตั้งค่าสถานะก่อนที่จะปรับโมเดลโดยใช้วิธี adapt() กับข้อมูลฝึกฝน ซึ่งจะคำนวณค่าเฉลี่ยและความแปรปรวนเพื่อใช้ในการปรับให้เป็นมาตรฐาน ต่อมาเมื่อส่งชุดข้อมูลการตรวจสอบไปยังโมเดล ระบบจะใช้ค่าเฉลี่ยและความแปรปรวนเดียวกันนี้ที่คำนวณจากข้อมูลฝึกฝนเพื่อปรับขนาดข้อมูลการตรวจสอบ

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

ในทำนองเดียวกัน ฟังก์ชันต่อไปนี้จะสร้างการเข้ารหัสหมวดหมู่ที่คุณจะใช้กับฟีเจอร์ชั่วโมงและวันธรรมดา

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))

จากนั้นสร้างส่วนการประมวลผลล่วงหน้าของโมเดล ก่อนอื่น ให้สร้างtf.keras.Inputเลเยอร์สำหรับฟีเจอร์แต่ละรายการ

# 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')

จากนั้นสร้างเลเยอร์การเข้ารหัสการปรับให้เป็นมาตรฐานและหมวดหมู่ โดยจัดเก็บไว้ในรายการ

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)

หลังจากกําหนดเลเยอร์การประมวลผลล่วงหน้าแล้ว คุณจะกําหนดส่วนที่เหลือของโมเดลได้ คุณจะต่อฟีเจอร์อินพุตทั้งหมดเข้าด้วยกันและส่งไปยังเลเยอร์ Dense เลเยอร์เอาต์พุตเป็นหน่วยเดียวเนื่องจากนี่คือปัญหาการถดถอย

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)

สุดท้ายคือคอมไพล์โมเดล

model.compile(optimizer = tf.keras.optimizers.Adam(0.001),
              loss='mean_squared_logarithmic_error')

เมื่อกำหนดโมเดลแล้ว คุณจะเห็นภาพสถาปัตยกรรมได้

tf.keras.utils.plot_model(model, show_shapes=True, rankdir="LR")

keras_model

โปรดทราบว่าโมเดลนี้ค่อนข้างซับซ้อนสำหรับชุดข้อมูลที่เรียบง่ายนี้ มีวัตถุประสงค์เพื่อการสาธิต

มาฝึกโมเดล 1 รอบเพื่อยืนยันว่าโค้ดทำงานได้

model.fit(train_dataset, validation_data = validation_dataset, epochs = 1)

ฝึกโมเดลด้วย GPU

จากนั้น คุณจะฝึกโมเดลให้นานขึ้นและใช้ตัวสลับฮาร์ดแวร์เพื่อเร่งการฝึก Vertex AI Workbench ช่วยให้คุณเปลี่ยนฮาร์ดแวร์ได้โดยไม่ต้องปิดอินสแตนซ์ การเพิ่ม GPU เฉพาะเมื่อจำเป็นจะช่วยให้คุณควบคุมค่าใช้จ่ายได้

หากต้องการเปลี่ยนโปรไฟล์ฮาร์ดแวร์ ให้คลิกประเภทเครื่องที่มุมขวาบน แล้วเลือกแก้ไขฮาร์ดแวร์

modify_hardware

เลือก "แนบ GPU" แล้วเลือก NVIDIA T4 Tensor Core GPU

add_gpu

การกำหนดค่าฮาร์ดแวร์จะใช้เวลาประมาณ 5 นาที เมื่อกระบวนการเสร็จสมบูรณ์แล้ว เรามาฝึกโมเดลต่ออีกสักหน่อยกัน คุณจะเห็นว่าแต่ละ Epoch ใช้เวลาน้อยลง

model.fit(train_dataset, validation_data = validation_dataset, epochs = 5)

🎉 ยินดีด้วย 🎉

คุณได้เรียนรู้วิธีใช้ Vertex AI Workbench เพื่อทำสิ่งต่อไปนี้

สํารวจข้อมูลใน BigQuery
ใช้ไคลเอ็นต์ BigQuery เพื่อโหลดข้อมูลลงใน Python
ฝึกโมเดล TensorFlow ด้วยเลเยอร์การประมวลผลล่วงหน้าของ Keras และ GPU

ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex AI ได้ที่เอกสารประกอบ

7. ล้างข้อมูล

เนื่องจากเรากำหนดค่า Notebook ให้หมดเวลาหลังจากไม่มีการใช้งาน 60 นาที จึงไม่ต้องกังวลเรื่องการปิดอินสแตนซ์ หากต้องการปิดอินสแตนซ์ด้วยตนเอง ให้คลิกปุ่มหยุดในส่วน Vertex AI Workbench ของคอนโซล หากต้องการลบ Notebook ทั้งหมด ให้คลิกปุ่มลบ