หน้านี้ได้รับการแปลโดย Cloud Translation API

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

1. ภาพรวม

ในชั้นเรียนนี้ คุณจะได้เรียนรู้วิธีใช้ Vertex AI Workbench สําหรับการสํารวจข้อมูลและการฝึกโมเดล ML

สิ่งที่คุณเรียนรู้

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

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

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

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

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

ห้องทดลองนี้ใช้เลเยอร์การประมวลผลข้อมูลก่อนการประมวลผลของ Keras เพื่อเปลี่ยนรูปแบบและเตรียมข้อมูลอินพุตสําหรับการฝึกโมเดล API นี้ช่วยให้คุณสร้างการประมวลผลข้อมูลล่วงหน้าในกราฟโมเดล TensorFlow ได้โดยตรง ซึ่งจะช่วยลดความเสี่ยงที่ข้อมูลการฝึก/การแสดงผลจะเบี่ยงเบน โดยการตรวจสอบว่าข้อมูลการฝึกและข้อมูลการแสดงผลได้รับการเปลี่ยนรูปแบบเหมือนกัน โปรดทราบว่าสำหรับ TensorFlow 2.6 API นี้มีความเสถียร หากใช้ 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

เมื่อเปิดใช้แล้ว ให้คลิกโน้ตบุ๊กที่มีการจัดการ

Notebooks_UI

จากนั้นเลือกสมุดบันทึกใหม่

new_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

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

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 โดยใช้เคอร์เนล TensorFlow

สร้าง DataFrame

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

copy_for_df

ถัดไป ให้กลับไปที่ Launcher และสร้างโน้ตบุ๊ก TensorFlow 2

tf_kernel

ในเซลล์แรกของโน้ตบุ๊ก ให้วางโค้ดที่คัดลอกมาจากเครื่องมือแก้ไขข้อความค้นหา ซึ่งควรมีลักษณะดังต่อไปนี้

# 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 จาก 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

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

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

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

เลเยอร์การปรับมาตรฐาน: ทำการทำให้เป็นมาตรฐานตามฟีเจอร์ของฟีเจอร์อินพุต
เลเยอร์ IntegerLookup: เปลี่ยนค่าเชิงหมวดหมู่ที่เป็นจำนวนเต็มให้เป็นดัชนีจำนวนเต็ม
เลเยอร์ CategoryEncoding: เปลี่ยนฟีเจอร์เชิงหมวดหมู่จำนวนเต็มเป็นการแทนแบบร้อนเดียว แบบมัลติฮอต หรือ 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)

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

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" แล้วเลือก GPU เทอร์เซอร์คอร์ของ NVIDIA T4

add_gpu

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

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

🎉 ยินดีด้วย 🎉

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

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

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

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

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