มาลองทำ Deep Learning ง่าย ๆ บน Google Colab กัน!!

เนื่องจากการใช้ Google Colab เราจะไม่ต้องติดตั้งโปรแกรมเลย ซึ่งเราสามารถใช้งานได้เพียงมีบัญชี Google เท่านั้น โดยในบทความนี้จะศึกษามาจากคลาส Deep Learning ของ MIT ซึ่งใครอยากลองดูคลิปก็แนะนำเลยเพราะสอนเข้าใจง่ายมาก

เริ่มต้นการใช้งาน Google Colab

เราสามารถเข้าไปใช้ Colab ได้ที่ https://colab.research.google.com/ จากนั้นก็เลือก NEW NOTEBOOK เพื่อเริ่มต้นไฟล์ใหม่

ลองสั่งคำสั่งง่าย ๆ ก่อน เช่น print(“hi”) //Google Colab จะใช้ภาษา python

ช่องสี่เหลี่ยมที่เราจะใช้วางโค้ดเพื่อรันเนี่ย เรียกว่า cell ซึ่งเราสามารถเพิ่มได้โดยกด [+ Code] หรือ [+ Text] ตามในรูป

หรือกดจากที่แท็บด้านบนก็ได้ และสามารถกดรัน Cell นั้น ๆ ได้ที่ปุ่มรูปสามเหลี่ยมที่อยู่ส่วนหัวของ Cell ตามรูปด้านล่าง

ที่แต่ละ cell ก็จะมีเครื่องมือให้เลือกใช้ เรียงจากซ้ายไปขวาคือ สลับ Cell ขึ้นไปด้านบน, สลับ Cell ลงด้านล่าง, link to cell, comment, Setting, Mirror cell in Tab, Delete Cell

ทางด้านซ้ายก็จะมีเครื่องมือที่น่าสนใจอีกอย่างคือ Table of contents เวลาที่เรามีโค้ดเยอะ ๆ เราก็สามารถรวม code ส่วนย่อยเป็น 1 section ได้เพื่อความสะดวกในการหา

ส่วนที่เป็นรูปแฟ้มก็คือเราสามารถสร้าง Floder เก็บพวก Code หรือว่า Data ไว้ที่ส่วนนี้ เพื่อความสะดวกในการเรียกใช้

อีกอย่างที่ส่วนตัวมองว่าใช้บ่อยคือแท็บเครื่องมือ Runtime

ซึ่งสะดวกต่อการใช้งานมาก บางทีเราต้องการรันทีเดียวทุก cell เราก็ไม่ต้องเสียเวลากดทีละอัน

**เราสามารถใช้ทางลัด Shift + Enter เพื่อรันแต่ละ Cell ได้นะ

นอกจากนี้ ด้วยความที่ Google Colab เป็นของ Google เราก็สามารถเรียกของจาก Google Drive ของเราออกมาได้ด้วย โดยใช้คำสั่ง

from google.colab import drive
drive.mount('/content/drive')

โดยกดตามลิงค์ที่เขาให้มาเราก็จะได้รหัสผ่าน แล้วก็นำมาใส่ในช่องว่างนั้น ดูเพิ่มเติม

แล้วเราสามารถเลือกได้ว่าจะใช้ CPU GPU หรือ TPU โดยกดไปที่ Runtime -> Change runtime type แล้วก็จะได้ pop-up ดังรูปด้านล่าง

ในเรื่องของความแตกต่างนั้น CPU จะถูกสร้างมาให้สามารถทำงานได้หลากหลายกว่า GPU กล่าวคือ GPU จะทำงานในส่วนของการ render graphics หรืองานที่เป็น parallel และในตัวของ CPU จะมี Core น้อยกว่า (4–8 cores) แต่ GPU จะมี Core เยอะกว่ามาก

นอกจากนั้นยังมีการคำนวณที่ต่างกันคือ CPU จะประมวลผลแบบ 1*1 data แต่ GPU จะประมวลผลแบบ 1*n data ทำให้สามารถทำงานได้เร็ว ดังรูปด้านล่าง

https://iq.opengenus.org/cpu-vs-gpu-vs-tpu/

ส่วน TPU คือตัวที่สร้างมาเพื่อการคำนวณขนาดใหญ่ ประมวลผลแบบ n*n data เพื่อทำให้การทำงานด้วย Tensor Flow เร็วขึ้น

โปรแกรม

ในส่วนของโปรแกรมนั้นจะเป็นโจทย์ Boston Housing ของ Kaggle ซึ่งในจะยกตัวอย่างจากการสอนของอาจารย์ MIT ชื่อ Lex Fridman

โจทย์คือให้เราทำนายราคาบ้านซึ่งจากชุดข้อมูลจะเป็นตัวที่มีชื่อว่า medv โดยการนำ 13 ปัจจัยที่เหลือมาเป็น Input

จากตัวอย่างจะใช้เป็น Feed Forward Neural Networks ในการทำนาย และแต่ละ Neural จะมีการเชื่อมกันแบบ dense (fully connected) เพราะว่าเราต้องการใช้ทั้ง 13 ปัจจัยในการทำนาย ถ้าอีกแบบนึงจะเรียกว่า Sparse Neural Network ตือแต่ละ node จะไม่ได้เชื่อมถึงกันหมดตามภาพด้านล่าง

https://towardsdatascience.com/the-sparse-future-of-deep-learning-bce05e8e094a

เริ่มแรกสุดให้เลือก Import เครื่องมือตามนี้

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense
import numpy as np
import os
import sys
import pandas as pd

เราก็จะทำการโหลดข้อมูลด้วยคำสั่ง load_data() แล้วแบ่งออกเป็น train data และ test data

ในส่วนของ train_features จะเป็นข้อมูลของ 13 ปัจจัยที่จะเอาไปเป็น input ของ model ส่วน train_labels คือค่าของ medv ที่เอามาเป็นตัวอย่างในการสอน ฝั่งของ test ก็เหมือนกันแต่เป็นข้อมูลที่เอาไว้ทดสอบโมเดล

(train_features, train_labels), (test_features, test_labels) = keras.datasets.boston_housing.load_data()
train_mean = np.mean(train_features, axis=0)
train_std = np.std(train_features, axis=0)
train_features = (train_features - train_mean) / train_std

• คำสั่งสร้างโมเดล

จากโค้ดด้านล่างคือเราจะกำหนดว่ามี 1 hidden layer จาก 20 neuron ตรงนี้เราก็สามารถปรับได้

ส่วน Dense คือการบอกว่าเป็น Fully Connected หรือ การเชื่อมที่ทุก Node ในชั้นหนึ่งเชื่อมไปยังอีกชั้นหนึ่ง

และเราก็จะคำนวณค่า error ของโมเดลด้วย Loss Function โดยจะคิดจาก MSE (Mean Squared Error) โดยการเทรนแต่ละครั้งจะมีเป้าหมายเพื่อลดค่า Loss Function นี้ให้น้อยที่สุดเพื่อให้ได้โมเดลทำนายที่ดี

ตรงส่วน Matrics คือเราจะใช้เพื่อประเมินคุณภาพของโมเดล โดยในที่นี้ใช้ MAE (Mean Absolute Error) กับ MSE (Mean Square Error) ซึ่งแต่ละตัวมีผลที่ต่างกันขึ้นกับลักษณะของข้อมูล ดูเพิ่มเติม

def build_model():
model = keras.Sequential([Dense(20, activation=tf.nn.relu, input_shape=[len(train_features[0])]), Dense(1)])
model.compile(optimizer=tf.optimizers.Adam(), loss='mse',metrics=['mae', 'mse'])
return model

• คำสั่ง Train Model

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

class PrintDot(keras.callbacks.Callback):
      def on_epoch_end(self, epoch, logs):
          if epoch % 100 == 0: print('')
          print('.', end='')
import time
start = time.time()

model = build_model()
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=50)
history = model.fit(train_features, train_labels, epochs=1000, verbose=0, validation_split = 0.1,
callbacks=[early_stop, PrintDot()])
hist = pd.DataFrame(history.history)
hist['epoch'] = history.epoch
stop = time.time()
rmse_final = np.sqrt(float(hist['val_mse'].tail(1)))
print()
print('RMSE: {}'.format(round(rmse_final, 3)))
print('time:', stop-start)

จากโค้ดด้านบนจะเห็นได้ว่าเราใส่ฟังก์ชั่น time เอาไว้เพื่อวัดเวลา สำหรับคนที่ต้องการลองรันในหน่วยประมวลผลต่าง ๆ ก็ใช้วิธีการเปลี่ยน Hardware แบบที่ได้กล่าวไปในตอนต้น ส่วนที่เราลองรันก็จะได้ผลดังนี้
CPU ได้ 58.375
GPU ได้ 37.160
TPU ได้ 27.527
จะเห็นได้ว่าลำดับความเร็วจะเรียงดังนี้ TPU GPU และ CPU

สำหรับใครที่ลองรันด้วย GPU แล้วสงสัยว่าตอนนี้โปรแกรมเรารันด้วย GPU จริงมั้ย สามารถทดสอบได้ด้วยการใช้คำสั่ง

tf.test.gpu_device_name()

ซึ่งจะได้ผลดังนี้ถ้าเราใช้ GPU

แต่ถ้ายังไม่ใช้ GPU จะขึ้นเป็น String ว่าง (‘ ’)

• คำสั่งดูค่า RMSE

ถ้าค่า RMSE เยอะแสดงว่าโมเดลทำนายไม่ค่อยดี เช่น ถ้าได้ RMSE 5.14 หมายความว่าโมเดลจะทำนาย +- 5.14 ที่ใช้ RMSE เพราะว่าจะทำให้เราตีความได้ง่ายกว่า MSE (RMSE คือนำ MSE ซึ่งอยู่ในรูปยกกำลังสองมาถอดรูท ทำให้ได้ค่าแบบไม่ยกกำลังสอง) สามารถอ่านเพิ่มเติมได้

test_features_norm = (test_features - train_mean) / train_std
mse, _, _ = model.evaluate(test_features_norm, test_labels)
rmse = np.sqrt(mse)
print('Root Mean Square Error on test set: {}'.format(round(rmse, 3)))

สำหรับใครที่ต้องการการรันที่เร็วขึ้นก็ยังมี Google Colab Pro อีกด้วย ซึ่งเป็นแบบที่เราต้องเสียเงินรายเดือน ราคา ณ ตอนที่เขียนบทความคือ 321.00/เดือน ( $10/month) ความพิเศษของ Pro คืออะไร

1. Faster GPUs : ได้ GPU ที่เร็วขึ้น T4 หรือP100 GPU ซึ่งแบบธรรมดาจะใช้ K80 GPU
2. More memory: สามารถใช้ High-RAM ได้
3. Longer runtimes: คือปกติ Colab จะมีการตั้ง Reset หลังจากช่วงเวลานึงแต่แบบ Pro จะได้ช่วงเวลา runtime ที่มากกว่าแบบปกติถึง 2 เท่า

โดยส่วนตัวแล้วคิดว่าถ้าไม่ใช่คนที่ทำงาน หรือ เรียนที่ต้องรันด้วยข้อมูลขนาดใหญ่มาก ๆ แบบต้องใช้เวลารันเป็นวัน การใช ้Pro อาจไม่ได้ช่วยอะไรมาก น่าจะช่วยแค่เรื่องความเร็วที่เพิ่มมากขึ้นเฉย ๆ แต่ถ้าต้องการความเร็วในการรัน หรือต้องใช้พื้นที่จัดเก็บข้อมูลเยอะ ต้องใช้เวลารันนาน การใช้ Pro ก็ค่อนข้างเป็นทางเลือกที่ดี

อย่างไรก็ตามการตัดสินใจใช้งาน Colab ว่าจะใช้แบบไหนก็ลองตัดสินใจกันนะคะ โดยอาจอ่านข้อมูลเพิ่มเติมได้จากลิงค์นี้ เขาค่อนข้างสรุปมาให้ชัดเจน แล้วยังมี Visualization ให้ดูง่ายขึ้นอีกด้วย

Colab Pro: Is it Worth the Money?

Future work
- เราสามารถใช้ GPU เข้าไปช่วยในทุกโปรแกรมเลยหรือเปล่า
- คำสั่งอื่น ๆ สำหรับการเขียนโปรแกรม
ซึ่งถ้าได้ทำการศึกษาเพิ่มแล้วก็จะมาอัพเดทเนื้อหาให้นะคะ

Acknowledgment

บทความนี้สำเร็จไปได้ด้วยดีด้วยความช่วยเหลือและสนับสนุนจาก ดร. อภิวดี ปิยธรรมรงค์ (พี่ซี) ในขณะที่เข้าฝึกงานที่ NSTDA Supercomputer center (ThaiSC) ทั้งช่วยให้คำแนะนำและข้อเสนอแนะ รวมถึงการตรวจสอบแก้ไขข้อผิดพลาดตลอดการจัดทำบทความ ขอขอบพระคุณค่ะ

Reference

MIT Deep Learning Basics: Introduction and Overview with TensorFlow

Google Colaboratory

CPU, GPU and TPU — Machine Learning

Metrics พื้นฐานสำหรับวัดประสิทธิภาพของโมเดล Machine Learning

บทสรุป Neural Network and Deep Learning

MAE, MSE, RMSE — เลือกใช้ยังไงดีมาลองดูที่ความหมาย