1. ภาพรวม
ในห้องทดลองนี้ คุณจะได้อธิบายเวิร์กโฟลว์การฝึก ML ที่สมบูรณ์บน Google Cloud โดยใช้ PyTorch สร้างโมเดลของคุณ จากสภาพแวดล้อม Cloud AI Platform Notebooks คุณจะได้เรียนรู้วิธีจัดแพ็กเกจงานการฝึกเพื่อเรียกใช้ในการฝึก AI Platform ด้วยการปรับแต่งไฮเปอร์พารามิเตอร์
สิ่งที่ได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- สร้างอินสแตนซ์ AI Platform Notebooks
- สร้างโมเดล PyTorch
- ฝึกโมเดลด้วยการปรับแต่งไฮเปอร์พารามิเตอร์ในการฝึก AI Platform
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน Google Cloud อยู่ที่ประมาณ $1
2. ตั้งค่าสภาพแวดล้อมของคุณ
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เปิดใช้ Cloud AI Platform Models API
ไปที่ส่วนโมเดล AI Platform ของ Cloud Console แล้วคลิกเปิดใช้ หากยังไม่ได้เปิดใช้
ขั้นตอนที่ 2: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้ หากยังไม่ได้เปิดใช้ ซึ่งคุณจะต้องใช้ในการสร้างอินสแตนซ์สมุดบันทึก
ขั้นตอนที่ 3: สร้างอินสแตนซ์ AI Platform Notebooks
ไปที่ส่วน AI Platform Notebooks ของ Cloud Console แล้วคลิกอินสแตนซ์ใหม่ จากนั้นเลือกประเภทอินสแตนซ์ PyTorch ล่าสุด (ไม่มี GPU) ดังนี้
ใช้ตัวเลือกเริ่มต้นหรือตั้งชื่อแบบกำหนดเองหากต้องการ แล้วคลิกสร้าง เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab:
จากนั้นเปิดอินสแตนซ์สมุดบันทึก Python 3 จาก Launcher ด้วยคำสั่งต่อไปนี้
คุณพร้อมที่จะเริ่มใช้งานแล้ว
ขั้นตอนที่ 5: นำเข้าแพ็กเกจ Python
ในเซลล์แรกของสมุดบันทึก ให้เพิ่มการนำเข้าต่อไปนี้และเรียกใช้เซลล์ โดยกดปุ่มลูกศรขวาในเมนูด้านบนหรือกด Command-Enter ดังนี้
import datetime
import numpy as np
import os
import pandas as pd
import time
คุณจะเห็นว่าเราไม่ได้นำเข้า PyTorch ที่นี่ เนื่องจากเรากำลังเรียกใช้งานการฝึกในการฝึกอบรม AI Platform ไม่ใช่จากอินสแตนซ์สมุดบันทึกของเรา
3. สร้างแพ็กเกจสำหรับงานการฝึก
ในการเรียกใช้งานการฝึกอบรมเกี่ยวกับการฝึกอบรม AI Platform เราจำเป็นต้องมีโค้ดการฝึกอบรมที่อยู่ในอินสแตนซ์สมุดบันทึกภายในเครื่อง และต้องมีที่เก็บข้อมูล Cloud Storage เพื่อเก็บเนื้อหาสำหรับงานของเรา ก่อนอื่น เราจะสร้างที่เก็บข้อมูลของพื้นที่เก็บข้อมูล คุณสามารถข้ามขั้นตอนนี้ได้ หากมีอยู่แล้ว
ขั้นตอนที่ 1: สร้างที่เก็บข้อมูล Cloud Storage สำหรับโมเดลของเรา
เรามากำหนดตัวแปรสภาพแวดล้อมบางส่วนที่เราจะใช้ใน Codelab ที่เหลือก่อนกัน กรอกค่าด้านล่างด้วยชื่อโปรเจ็กต์ Google Cloud และชื่อที่เก็บข้อมูล Cloud Storage ที่ต้องการสร้าง (ต้องไม่ซ้ำกันทั่วโลก)
# Update these to your own GCP project, model, and version names
GCP_PROJECT = 'your-gcp-project'
BOCKET_URL = 'gs://storage_bucket_name'
ตอนนี้เราพร้อมที่จะสร้างที่เก็บข้อมูลของพื้นที่เก็บข้อมูลแล้ว ซึ่งเราจะนำไปยังเมื่อเราเริ่มต้นงานการฝึกของเรา
เรียกใช้คำสั่ง gsutil นี้จากภายในสมุดบันทึกเพื่อสร้างที่เก็บข้อมูล
!gsutil mb $BUCKET_URL
ขั้นตอนที่ 2: สร้างไฟล์เริ่มต้นสำหรับแพ็กเกจ Python
ในการเรียกใช้งานการฝึกบน AI Platform เราจะต้องกำหนดค่าโค้ดเป็นแพ็กเกจ Python ซึ่งประกอบด้วยไฟล์ setup.py ในไดเรกทอรีรากของเราที่ระบุทรัพยากร Dependency ของแพ็กเกจภายนอก ไดเรกทอรีย่อยที่มีชื่อแพ็กเกจของเรา (ในที่นี้เราจะเรียกว่า trainer/) และไฟล์ __init__.py ที่ว่างเปล่าภายในไดเรกทอรีย่อยนี้
ขั้นแรก เราจะเขียนไฟล์ Setup.py เรากำลังใช้เวทมนตร์ของ iPython %%writefile เพื่อบันทึกไฟล์ไปยังอินสแตนซ์ของเรา ในที่นี้เราจะระบุไลบรารีภายนอก 3 รายการที่เราจะใช้ในโค้ดการฝึกอบรมของเรา ได้แก่ PyTorch, Scikit-learn และ Pandas
%%writefile setup.py
from setuptools import find_packages
from setuptools import setup
REQUIRED_PACKAGES = ['torch>=1.5', 'scikit-learn>=0.20', 'pandas>=1.0']
setup(
name='trainer',
version='0.1',
install_requires=REQUIRED_PACKAGES,
packages=find_packages(),
include_package_data=True,
description='My training application package.'
)
ถัดไป ให้สร้างไดเรกทอรี Trainer/ และไฟล์ init.py ที่ว่างเปล่าภายในไดเรกทอรี Python ใช้ไฟล์นี้เพื่อระบุว่าเป็นแพ็กเกจ
!mkdir trainer
!touch trainer/__init__.py
ตอนนี้เราพร้อมแล้วที่จะสร้างงานการฝึก
4. ดูตัวอย่างชุดข้อมูล
ส่วนสำคัญของ Lab นี้จะอยู่ที่เครื่องมือในการฝึกโมเดล แต่เรามาดูชุดข้อมูลที่จะใช้ฝึกโมเดลทำความเข้าใจคร่าวๆ กัน เราจะใช้ชุดข้อมูลธรรมชาติที่มีอยู่ใน BigQuery ข้อมูลนี้มีข้อมูลการเกิดจากสหรัฐอเมริกาในช่วงหลายทศวรรษที่ผ่านมา เราจะใช้ชุดข้อมูลนี้ 2-3 คอลัมน์เพื่อคาดการณ์น้ำหนักแรกเกิดของทารก ชุดข้อมูลต้นฉบับมีขนาดค่อนข้างใหญ่ และเราจะใช้ชุดข้อมูลบางส่วนที่เราจัดเตรียมไว้ให้คุณในที่เก็บข้อมูล Cloud Storage
ขั้นตอนที่ 1: การดาวน์โหลดชุดข้อมูลเหตุการณ์ ณ ธรรมชาติของ BigQuery
มาดาวน์โหลดเวอร์ชันของชุดข้อมูลที่เราจัดเตรียมให้คุณได้ใน Cloud Storage ไปยัง Pandas DataFrame และดูตัวอย่าง
natality = pd.read_csv('https://storage.googleapis.com/ml-design-patterns/natality.csv')
natality.head()
ชุดข้อมูลนี้มีแถวไม่ถึง 100,000 แถว เราจะใช้คุณลักษณะ 5 อย่างในการคาดคะเนน้ำหนักแรกเกิดของทารก คือ อายุของแม่และพ่อ, สัปดาห์การตั้งครรภ์, น้ำหนักตัวแม่ที่เพิ่มขึ้นในหน่วยปอนด์ และเพศของทารกที่แสดงเป็นค่าบูลีน
5. กำหนดงานการฝึกด้วยการปรับแต่งไฮเปอร์พารามิเตอร์
เราจะเขียนสคริปต์การฝึกลงในไฟล์ชื่อ model.py ภายในไดเรกทอรีย่อยของผู้ฝึกสอน/ ที่เราสร้างไว้ก่อนหน้านี้ งานการฝึกของเราจะทํางานในการฝึก AI Platform และจะใช้บริการปรับแต่งไฮเปอร์พารามิเตอร์ของ AI Platform เพื่อค้นหาไฮเปอร์พารามิเตอร์ที่เหมาะสมที่สุดสำหรับโมเดลของเราที่ใช้การเพิ่มประสิทธิภาพแบบ Bayesian
ขั้นตอนที่ 1: สร้างสคริปต์การฝึกอบรม
ก่อนอื่น ให้สร้างไฟล์ Python ด้วยสคริปต์การฝึกของเรา จากนั้นเราจะวิเคราะห์สิ่งที่เกิดขึ้น การเรียกใช้คำสั่ง %%writefile จะเขียนโค้ดโมเดลไปยังไฟล์ Python ในเครื่อง:
%%writefile trainer/model.py
import argparse
import hypertune
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.utils import shuffle
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import normalize
def get_args():
"""Argument parser.
Returns:
Dictionary of arguments.
"""
parser = argparse.ArgumentParser(description='PyTorch MNIST')
parser.add_argument('--job-dir', # handled automatically by AI Platform
help='GCS location to write checkpoints and export ' \
'models')
parser.add_argument('--lr', # Specified in the config file
type=float,
default=0.01,
help='learning rate (default: 0.01)')
parser.add_argument('--momentum', # Specified in the config file
type=float,
default=0.5,
help='SGD momentum (default: 0.5)')
parser.add_argument('--hidden-layer-size', # Specified in the config file
type=int,
default=8,
help='hidden layer size')
args = parser.parse_args()
return args
def train_model(args):
# Get the data
natality = pd.read_csv('https://storage.googleapis.com/ml-design-patterns/natality.csv')
natality = natality.dropna()
natality = shuffle(natality, random_state = 2)
natality.head()
natality_labels = natality['weight_pounds']
natality = natality.drop(columns=['weight_pounds'])
train_size = int(len(natality) * 0.8)
traindata_natality = natality[:train_size]
trainlabels_natality = natality_labels[:train_size]
testdata_natality = natality[train_size:]
testlabels_natality = natality_labels[train_size:]
# Normalize and convert to PT tensors
normalized_train = normalize(np.array(traindata_natality.values), axis=0)
normalized_test = normalize(np.array(testdata_natality.values), axis=0)
train_x = torch.Tensor(normalized_train)
train_y = torch.Tensor(np.array(trainlabels_natality))
test_x = torch.Tensor(normalized_test)
test_y = torch.Tensor(np.array(testlabels_natality))
# Define our data loaders
train_dataset = torch.utils.data.TensorDataset(train_x, train_y)
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=128, shuffle=True)
test_dataset = torch.utils.data.TensorDataset(test_x, test_y)
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=128, shuffle=False)
# Define the model, while tuning the size of our hidden layer
model = nn.Sequential(nn.Linear(len(train_x[0]), args.hidden_layer_size),
nn.ReLU(),
nn.Linear(args.hidden_layer_size, 1))
criterion = nn.MSELoss()
# Tune hyperparameters in our optimizer
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
epochs = 20
for e in range(epochs):
for batch_id, (data, label) in enumerate(train_dataloader):
optimizer.zero_grad()
y_pred = model(data)
label = label.view(-1,1)
loss = criterion(y_pred, label)
loss.backward()
optimizer.step()
val_mse = 0
num_batches = 0
# Evaluate accuracy on our test set
with torch.no_grad():
for i, (data, label) in enumerate(test_dataloader):
num_batches += 1
y_pred = model(data)
mse = criterion(y_pred, label.view(-1,1))
val_mse += mse.item()
avg_val_mse = (val_mse / num_batches)
# Report the metric we're optimizing for to AI Platform's HyperTune service
# In this example, we're mimizing error on our test set
hpt = hypertune.HyperTune()
hpt.report_hyperparameter_tuning_metric(
hyperparameter_metric_tag='val_mse',
metric_value=avg_val_mse,
global_step=epochs
)
def main():
args = get_args()
print('in main', args)
train_model(args)
if __name__ == '__main__':
main()
งานการฝึกอบรมประกอบด้วย 2 หน้าที่การทำงานเป็นกลุ่ม
get_args(): การดำเนินการนี้จะแยกวิเคราะห์อาร์กิวเมนต์บรรทัดคำสั่งที่เราจะส่งเมื่อสร้างงานการฝึก รวมทั้งไฮเปอร์พารามิเตอร์ที่เราต้องการให้ AI Platform เพิ่มประสิทธิภาพ ในตัวอย่างนี้ รายการอาร์กิวเมนต์ของเรามีเฉพาะไฮเปอร์พารามิเตอร์ที่เราจะเพิ่มประสิทธิภาพ เช่น อัตราการเรียนรู้ของโมเดล โมเมนตัม และจำนวนเซลล์ประสาทในเลเยอร์ที่ซ่อนอยู่train_model(): ตรงนี้เราจะดาวน์โหลดข้อมูลไปยัง Pandas DataFrame ทำให้เป็นมาตรฐาน แปลงเป็น PyTorch Tensors แล้วกำหนดโมเดลของเรา ในการสร้างโมเดลของเรา เราใช้ PyTorchnn.SequentialAPI ซึ่งช่วยให้เรากำหนดโมเดลของเราเป็นชุดเลเยอร์ได้ ดังนี้
model = nn.Sequential(nn.Linear(len(train_x[0]), args.hidden_layer_size),
nn.ReLU(),
nn.Linear(args.hidden_layer_size, 1))
โปรดสังเกตว่าแทนที่จะฮาร์ดโค้ดขนาดของเลเยอร์ที่ซ่อนอยู่ของโมเดลของเรา เรากำลังสร้างไฮเปอร์พารามิเตอร์ที่ AI Platform จะปรับแต่งมาให้เรา ดูข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้ได้ในส่วนถัดไป
ขั้นตอนที่ 2: การใช้บริการปรับแต่งไฮเปอร์พารามิเตอร์ของ AI Platform
เราจะใช้บริการเพิ่มประสิทธิภาพไฮเปอร์พารามิเตอร์ของ Cloud AI Platform แทนที่จะลองใช้ค่าไฮเปอร์พารามิเตอร์ต่างๆ และฝึกโมเดลอีกครั้งทุกครั้งด้วยตนเอง หากเราตั้งค่างานการฝึกด้วยอาร์กิวเมนต์ไฮเปอร์พารามิเตอร์ AI Platform จะใช้การเพิ่มประสิทธิภาพแบบเบเยสเซียนเพื่อหาค่าที่เหมาะกับไฮเปอร์พารามิเตอร์ที่เราระบุ
ในการปรับแต่งไฮเปอร์พารามิเตอร์ การทดลองใช้ครั้งเดียวจะประกอบด้วยการเรียกใช้การฝึก 1 ครั้งของโมเดลของเราที่มีชุดค่าผสมที่เฉพาะเจาะจงของไฮเปอร์พารามิเตอร์ AI Platform จะใช้ผลลัพธ์ของการทดลองใช้ที่เสร็จสมบูรณ์แล้วเพื่อเพิ่มประสิทธิภาพไฮเปอร์พารามิเตอร์ที่เลือกสำหรับอนาคต โดยขึ้นอยู่กับจำนวนการทดลองใช้ที่เราเรียกใช้ ในการกำหนดค่าการปรับแต่งไฮเปอร์พารามิเตอร์ เราจำเป็นต้องส่งไฟล์การกำหนดค่าเมื่อเริ่มงานการฝึกด้วยข้อมูลบางส่วนเกี่ยวกับไฮเปอร์พารามิเตอร์แต่ละรายการที่เรากำลังเพิ่มประสิทธิภาพ
จากนั้นให้สร้างไฟล์การกำหนดค่าในเครื่อง:
%%writefile config.yaml
trainingInput:
hyperparameters:
goal: MINIMIZE
maxTrials: 10
maxParallelTrials: 5
hyperparameterMetricTag: val_mse
enableTrialEarlyStopping: TRUE
params:
- parameterName: lr
type: DOUBLE
minValue: 0.0001
maxValue: 0.1
scaleType: UNIT_LINEAR_SCALE
- parameterName: momentum
type: DOUBLE
minValue: 0.0
maxValue: 1.0
scaleType: UNIT_LINEAR_SCALE
- parameterName: hidden-layer-size
type: INTEGER
minValue: 8
maxValue: 32
scaleType: UNIT_LINEAR_SCALE
สำหรับไฮเปอร์พารามิเตอร์แต่ละรายการ เราจะระบุประเภท ช่วงของค่าที่ต้องการค้นหา และระดับที่จะเพิ่มค่าในการทดสอบต่างๆ
ในตอนต้นของงาน เรายังระบุเมตริกที่กําลังเพิ่มประสิทธิภาพให้อีกด้วย โปรดทราบว่าเมื่อสิ้นสุดฟังก์ชัน train_model() ด้านบน เราจะรายงานเมตริกนี้ไปยัง AI Platform ทุกครั้งที่การทดลองเสร็จสมบูรณ์ ในที่นี้เราจะลดความคลาดเคลื่อนเฉลี่ยของโมเดลกำลังสองของโมเดล เราจึงต้องการใช้ไฮเปอร์พารามิเตอร์ที่ทำให้เกิดข้อผิดพลาดค่าเฉลี่ยกำลังสองที่ต่ำที่สุดสำหรับโมเดลของเรา ชื่อของเมตริกนี้ (val_mse) ตรงกับชื่อที่เราใช้ในการรายงานเมื่อเราเรียกใช้ report_hyperparameter_tuning_metric() เมื่อสิ้นสุดช่วงทดลองใช้
6. เรียกใช้งานการฝึกบน AI Platform
ในส่วนนี้เราจะเริ่มต้นงานการฝึกโมเดลด้วยการปรับแต่งไฮเปอร์พารามิเตอร์บน AI Platform
ขั้นตอนที่ 1: กำหนดตัวแปรสภาพแวดล้อมบางรายการ
ก่อนอื่น เรามากำหนดตัวแปรสภาพแวดล้อมบางส่วนที่เราจะใช้เพื่อเริ่มต้นงานการฝึกของเรากัน หากคุณต้องการเรียกใช้งานในภูมิภาคอื่น ให้อัปเดตตัวแปร REGION ที่ด้านล่าง
MAIN_TRAINER_MODULE = "trainer.model"
TRAIN_DIR = os.getcwd() + '/trainer'
JOB_DIR = BUCKET_URL + '/output'
REGION = "us-central1"
งานการฝึกแต่ละรายการบน AI Platform ควรมีชื่อไม่ซ้ำกัน เรียกใช้รายการต่อไปนี้เพื่อกำหนดตัวแปรสำหรับชื่องานโดยใช้การประทับเวลา
timestamp = str(datetime.datetime.now().time())
JOB_NAME = 'caip_training_' + str(int(time.time()))
ขั้นตอนที่ 2: เริ่มต้นงานการฝึก
เราจะสร้างงานการฝึกโดยใช้ gcloud ซึ่งเป็น Google Cloud CLI เราสามารถเรียกใช้คำสั่งนี้ได้โดยตรงในสมุดบันทึกของเรา โดยอ้างอิงตัวแปรที่เรากำหนดไว้ข้างต้น
!gcloud ai-platform jobs submit training $JOB_NAME \
--scale-tier basic \
--package-path $TRAIN_DIR \
--module-name $MAIN_TRAINER_MODULE \
--job-dir $JOB_DIR \
--region $REGION \
--runtime-version 2.1 \
--python-version 3.7 \
--config config.yaml
หากงานของคุณสร้างขึ้นอย่างถูกต้อง ให้ไปที่ส่วนงานของคอนโซล AI Platform เพื่อตรวจสอบบันทึก
ขั้นตอนที่ 3: ตรวจสอบงาน
เมื่อคุณอยู่ในส่วน "งาน" ของคอนโซล ให้คลิกงานที่คุณเพิ่งเริ่มดูรายละเอียด
เมื่อการทดลองใช้รอบแรกเริ่มต้นขึ้น คุณจะเห็นค่าไฮเปอร์พารามิเตอร์ที่เลือกสำหรับการทดลองใช้แต่ละครั้ง ดังนี้
เมื่อการทดสอบเสร็จสมบูรณ์ ระบบจะบันทึกค่าผลลัพธ์ของเมตริกการเพิ่มประสิทธิภาพ (ในกรณีนี้คือ val_mse) ที่นี่ งานอาจใช้เวลา 15-20 นาทีในการทำงาน และหน้าแดชบอร์ดจะมีลักษณะดังนี้เมื่องานเสร็จสิ้น (ค่าที่แน่นอนจะแตกต่างกันไป)
หากต้องการแก้ไขข้อบกพร่องของปัญหาที่อาจเกิดขึ้นและตรวจสอบงานอย่างละเอียดมากขึ้น ให้คลิกดูบันทึกจากหน้ารายละเอียดงาน
ทุกคำสั่ง print() ในโค้ดการฝึกโมเดลจะแสดงที่นี่ หากคุณพบปัญหา ให้ลองเพิ่มใบแจ้งยอดการพิมพ์และเริ่มงานการฝึกอบรมใหม่
เมื่องานการฝึกของคุณเสร็จสมบูรณ์ ให้ค้นหาไฮเปอร์พารามิเตอร์ที่ให้ val_mse ต่ำสุด คุณสามารถใช้ข้อมูลเหล่านี้เพื่อฝึกและส่งออกโมเดลเวอร์ชันสุดท้ายของโมเดล หรือใช้เป็นแนวทางเพื่อเริ่มงานการฝึกอื่นด้วยการทดลองใช้การปรับแต่งไฮเปอร์พารามิเตอร์เพิ่มเติม
7. ล้างข้อมูล
หากต้องการใช้สมุดบันทึกนี้ต่อไป ขอแนะนำให้ปิดสมุดบันทึกเมื่อไม่ได้ใช้งาน จาก UI ของสมุดบันทึกใน Cloud Console ให้เลือกสมุดบันทึก แล้วเลือกหยุด
หากต้องการลบทรัพยากรทั้งหมดที่คุณสร้างไว้ในห้องทดลองนี้ เพียงลบอินสแตนซ์สมุดบันทึกแทนที่จะหยุด
ใช้เมนูการนำทางใน Cloud Console เพื่อเรียกดูพื้นที่เก็บข้อมูล แล้วลบที่เก็บข้อมูลทั้ง 2 รายการที่คุณสร้างขึ้นเพื่อจัดเก็บเนื้อหาโมเดล