update: 7 กพ. 2564 เรื่อง Data Pipeline ใน TF 2.x ด้านล่างครับ
10 เรื่องใหม่ “ต้องรู้“ ใน Tensorflow 2.2 และ Keras ทีม ThaiKeras : 31 พค 2563
เมื่อเดือนพฤษภาที่ผ่านมา Tensorflow 2.2 หรือ TF2.2 ก็ได้ฤกษ์เปิดตัวอย่างเป็นทางการ โดยนับแต่ TF 2.0 ที่ทางทีมงาน TF ได้วางแผนจะให้การเขียน Keras เป็น standard สำคัญ และใน TF เวอร์ชั่น 2.2 นี้นับว่าวิสัยทัศน์นี้เกือบเสร็จสมบูรณ์มากๆ แล้วครับ โดยการเขียนโปรแกรมด้วย TF+Keras นั้นมีจุดเด่นมากๆ หลายจุดที่เราประทับใจสุดๆ
ทีมงานจึงนำ “10 เรื่องต้องรู้” มาสรุปสั้นๆ ให้เพื่อนๆ พร้อมทั้งลิงก์เพื่อศึกษาเพิ่มเติมครับ
1. หลอมรวมการเขียนโปรแกรมบน CPU, GPU, Multi-GPUs และ TPU เป็นหนึ่งเดียว 2. เพิ่มประสิทธิภาพสูงสุดให้ Input Pipeline ด้วย tf.data.dataset 3. HuggingFace Transformers สนับสนุน tf.keras อย่างเป็นทางการ 4. เพิ่มความยืดหยุ่นให้สามารถปรับ model.fit ให้เรียกใช้งานสอนข้อมูลได้ทุกประเภท 5. Tutorials และ codes examples ใหม่ๆ นับไม่ถ้วนบน tensorflow official, keras official, tfhub และบน Kaggle 6. Eager execution mode 7. Tensorflow Addons (tfa) - พบกับ loss ใหม่ๆ มากมายบน tfa.loss 8. พบกับ layers ใหม่ๆ มากมายบน tfa.layers 9. พบกับ optimizers ใหม่ๆ มากมายบน tfa.optimizers 10. สร้าง probabilistic model ด้วย tfp (Tensorflow Probability) .
. 0) เปลี่ยนจาก keras เป็น tf.keras เรื่องพื้นฐานที่ต้องทราบก่อนก็คือ การจะใช้งาน TF2.0+Keras เวอร์ชั่นใหม่นี้เราต้องเปลี่ยนวิธีการเขียนโปรแกรมจากการเรียก keras library โดยตรง เป็นเรียกจาก tf.keras แทน อาทิเช่น
เดิม : เขียนโค้ดด้วย keras.layers.xxx ใหม่: import tensorflow as tf จากนั้นใช้ tf.keras.layers.xxx แทน
. หรือจะใช้ from tensorflow import keras แทน import keras
หรือ from tensorflow.keras.layers import *
ก็ได้แล้วแต่ถนัดครับผม .
. 1) หลอมรวมการเขียนโปรแกรมบน CPU, GPU, Multi-GPUs และ TPU เป็นหนึ่งเดียว การฝึกสอนโมเดลบน Multi-GPUs หรือ TPU นั้นโดยปกติต้องใช้หลัก Distributed Training ซึ่งการเขียนโปรแกรมที่จะใช้ Core computing บน Tensorflow ใน version ก่อน หรือแม้แต่ใน Pytorch ณ ปัจจุบัน นั้นค่อนข้างยุ่งยากมาก
บน Tensorflow 2.2 นี้ ได้นิยามการทำงานบน Single GPU, Multi-GPUs หรือ TPU ว่ามี "strategy" แตกต่างกัน และที่น่ามหัศจรรย์คือ เราเขียนโปรแกรมแตกต่างกันเพียงตอนเริ่มต้น โดยกำหนดตัวแปรที่ชื่อว่า “strategy” เพียงไม่กี่บรรทัด
เช่น strategy = TPUStrategy() สำหรับ TPU หรือ strategy = MirroredStrategy() สำหรับ Multi-GPUs
หลังจากนั้นเราเพียงเพิ่มคำสั่งการสร้างโมเดลเพียงหนึ่งบรรทัดภายใต้คำสั่ง
with strategy.scope: model = create_model() # ฟังก์ชันสร้างโมเดลปกติใน keras model.compile()
เท่านี้โมเดลเราก็จะรันบน Multi-GPUs หรือ TPU โดยอัตโนมัติอย่างน่ามหัศจรรย์ครับ ดูตัวอย่างการสร้าง TPU Strategy ได้ที่บทความก่อนหน้า สร้างโมเดลที่เข้าใจ 100 ภาษาบน TPU : https://bit.ly/thaikeras-kaggle-xlmr . . 2) เพิ่มประสิทธิภาพสูงสุดให้ Input Pipeline ด้วย tf.data.dataset การฝึกสอนโมเดลอย่างมีประสิทธิภาพนอกจากจะพึ่ง GPU หรือ TPU แล้ว ใน pipeline ทั้งระบบก่อนหน้าที่จะใช้งาน GPU/TPU จะต้องมีการอ่านข้อมูลจาก disk และการ preprocess ข้อมูล (เช่น normalization) การ transform ข้อมูล (เช่น data augmentation) ซึ่งโดยปกติ จะต้องทำบน CPU การที่ต้องผ่านกระบวนการบน disk และ CPU นี้ที่ทำให้การทำงานทั้งกระบวนการ "ช้า" ถึงแม้เราจะมี GPU หรือ TPU ขั้นเทพก็ตาม เนื่องจาก process บน disk และ CPU นั้นทำได้ไม่เร็วพอทำให้เกิด “คอขวด“ ใน pipeline ของเรา
ใน tf.data.dataset นี้ได้ออกแบบเพื่อให้ input pipeline ทั้้งหมดเร็วที่สุดเท่าที่จะเป็นไปได้ โดยจะทำ parallel disk reading ได้อัตโนมัติ ทำ parallel-CPU processing ได้อัตโนมัติ และยังสามารถดึงโค้ดที่สำคัญหลายส่วนเช่น data augmentation ให้ทำบน GPU/TPU โดยตรงศึกษาได้ที่นี่ครับ — เข้าใจ tf.data ภายใน 40 นาที : https://www.youtube.com/watch?v=ZnukSLKEw34 .
. 3) HuggingFace Transformers สนับสนุน tf.keras อย่างเป็นทางการ HuggingFace คือ NLP library ที่ดีที่สุดในปัจจุบันที่นักวิจัยทั่วโลกใช้เนื่องจากมีโมเดลตระกูล transformer ที่ดีที่สุดครบถ้วนที่สุด และอัดเดตเร็วที่สุด ไม่ว่าจะเป็นโมเดลที่ present ใน งานประชุมวิชาการที่ขึ้นชื่อว่าดีที่สุดอย่าง ICLR 2020 เช่น Electra, Albert, Reformer, PPLM หรือโมเดลระดับบ SOTAที่ยังไม่ได้ตีพิมพ์อย่าง T5 และ Longformer ก็มาอยู่บน HuggingFace libray ให้เราเรียกใช้งานกันง่ายๆ ได้แล้ว
เมื่อ HuggingFace สนับสนุน tf.keras ก็ทำให้โมเดลทั้งหมดที่กล่าวมาอยู่ในรูป keras model ทำให้เราสามารถนำโมเดลเหล่านี้ไปรวมกับ keras layers, optimizers หรือ keras models ที่มีอยู่แล้วอย่างง่ายดาย โดย keras layers, optimizers นั้นเพิ่มมาจากเวอร์ชั่นเก่ามากมายดังที่จะกล่าวในหัวข้อถัดๆ ไปครับ
นอกจากนี้ยังทำให้เรายังสามารถเรียกโมเดล keras Vision ที่เข้าใจ รูปภาพ เข้ามารวมกับโมเดล HuggingFace NLP ที่เข้าใจภาษาอย่างลึกซึ้ง ทำให้เราสามารถสร้าง keras โมเดลที่เข้าใจทั้งรูปภาพและภาษาได้อย่างง่ายดาย
ตัวอย่างการใช้งาน keras+Huggingface ดูได้จากตัวอย่างการสร้างโมเดล 100 ภาษาที่กล่าวในหัวข้อที่ 1) หรือตัวอย่างการสร้างสรรค์เรื่องราวไร้ขีดจำกัดด้วย GPT-2: https://bit.ly/thaikeras-kaggle-gpt2thai
. . 4) เพิ่มความยืดหยุ่นให้ model.fit สามารถฝึกสอนข้อมูลได้ทุกประเภท การสอนโมเดลด้วยฟังก์ชัน model.fit นับเป็นจุดเด่นที่สำคัญของ keras ที่ทำให้การฝึกสอนโมเดลจากข้อมูลที่ยุ่งยาก และจุกจิกเสร็จภายในบรรทัดเดียว
อย่างไรก็ตามในเวอรชั่นเก่าๆ model.fit สามารถใช้งานได้กับปัญหามาตรฐาน แต่ปัญหาที่ input pipeline มีความซับซ้อน เช่น การสร้างรูปภาพด้วย GAN ที่โมเดลจะต้องประกอบไปด้วย 2 โมเดลย่อย นั้นไม่สามารถใช้ model.fit ได้
ใน TF2.2 นั้นได้ทำลายข้อจำกัดนี้และอนุญาตให้เราแก้ model.fit ได้ (ถ้าเราต้องการ) โดยการเขียน model method ที่ชื่อว่า “model.train_step” ซึ่งจะกำหนดให้ model.fit เปลี่ยนพฤติกรรมไปตาม model.train_step นี้
การแก้ไข model.train_step เพื่อใช้งาน model.fit นี้ทำให้เรายังสามารถใช้ฟังก์ชั่นอื่นๆ ใน keras model class เช่น Callbacks, LRSchedule อื่นๆ ของ keras ได้ตามปกติไม่ต้องเขียนเองครับ
สามารถดูวิธีการเขียน model.fit สำหรับ gan ได้ที่ : https://keras.io/examples/generative/dcgan_overriding_train_step/ . .
5) Tutorials และ code examples เพิ่มเติมมากมายบน tensorflow officials, keras official, tfhub และ Kaggle นอกจากฟังก์ชันการใช้งานแล้ว documents ของ keras ก็ได้มีการปรับปรุงให้ดีขึ้นมากๆๆ รวมทั้งโค้ดตัวอย่างนั้น F.Chollet ผู้ให้กำเนิด Keras ก็ลงมา update และเพิ่ม ตัวอย่างสำคัญๆ ด้วยตัวเองโดยเฉพาะใน official keras website นั่นคือ https://keras.io/examples ได้มีการปรับปรุงใหม่ทั้งหมด
เราจึงมีโค้ด keras ชั้นยอดให้นำไปต่อยอด หรือ ศึกษามากมาย ในลิงก์ข้างต้น อาทิเช่น - Image Segmentation ด้วย Keras U-Net - Video Prediction ด้วย CNN-LSTM - การเรียน point cloud จากวัตถุ 3 มิติ - การใช้ Huggingface Q&A extraction บน Keras - การสร้างโมเดล Keras Movie Recommendation - การสร้างโมเดล Keras credit card fraud detection - การสร้างโมเดล DC/WGAN ด้วย Keras model.fit - การทำนายรูปภาพด้วย Keras pixel CNN - อื่นๆ อีกมากมาย
ถ้าเรารวมกับตัวอย่างโค้ด Keras บน tensorflow official และบน Kaggle แล้วเรียกได้ว่าเรามีตัวอย่างโค้ดแทบจะครบทุก applications ที่ต้องการเลยทีเดียว ใครหาโค้ดตัวอย่างอะไรไม่เจอ สามารถ message ถามทีมงาน thaikeras ได้นะคร้าบ .
. 6) Eager execution mode ใน TF1.0 นั้นการเขียนโปรแกรมค่อนข้างเข้าใจยาก เช่น สมมติเรามีตัวแปร tensor ชื่อ x อยู่และเราอยากรู้ว่า ถ้ารันไปสักพักหนึ่ง x จะมีค่าเป็นเท่าไร บน jupyter notebook เราจะไม่สามารถสั่้ง
print(x)
เพื่อเช็คค่าของ x ได้ เนื่องจาก TF เวอร์ชั่น 1 นั้นจะยังไม่ทำ operation ใดๆ แม้นเราจะรันผ่าน cell เหล่านั้นมาแล้วก็ตาม โดย TF จะรันโปรแกรมทั้งหมดเมื่อมีการสั่ง session.run() แล้วเท่านั้น (กระบวนการนี้ของ TF1 เรียกว่า graph-mode โดยที่ทำกระบวนการนี้ก็เพื่อเพิ่มประสิทธิภาพการรันให้เร็วที่สุด)
เหล่านี้ทำให้การเขียนและ debug โปรแกรมใน TF1 นั้นทำงานยาก แต่ใน TF2 นั้นได้สนับสนุนการทำงานที่เรียกว่า “Eager execution mode” ที่จะทำ operation อาทิเช่น x+10, print(x) ทันที ทำให้เราสามารถ debug โปรแกรมเราได้ง่ายๆ
ในขณะที่เมื่อเราเรียก keras model.fit ตัว tf.keras จะเปลี่ยนจาก eager mode เป็น graph mode อัตโนมัติ ทำให้ประสิทธิภาพการฝึกสอนโมเดลของ keras บน TF2 ยังรวดเร็วเหมือนเดิม
ดูเรื่อง eager mode เพิ่มเติมที่ : https://www.tensorflow.org/guide/eager .
. 7) Tensorflow Addons (tfa) - พบกับ loss ใหม่ๆ มากมายบน tfa.loss นอกจาก official tensorflow implementations แล้ว TF ยังมี tf.addons (เรียกว่า tfa) ซึ่งเพิ่มพลังของ TF อีกมหาศาล เช่น ใน tfa.losses นั้นมี loss function ที่ใช้ SOTA models ต่างๆ ให้เราเลือกใช้มากมาย อาทิเช่น
- Triplet loss สำหรับทำ face-recognition หรือ few-shots learning ดูวิธีการใช้งานง่าย ได้ที่ https://www.tensorflow.org/addons/tutorials/losses_triplet - GIoU loss สำหรับงาน Object Detection - Focal loss สำหรับงาน Object Detection และ Segmentation เป็นต้น ดู tfa.losses ทั้งหมดได้ที่ https://www.tensorflow.org/addons/api_docs/python/tfa/losses .
. 8) Layers ใหม่มากมายบน tfa.layers เช่นเดียวกับ loss functions, tfa ยังมี layers ที่ไม่มีใน official keras แต่เห็นในงาน SOTA หลายงาน เช่น - GroupNormalization layer - InstanceNormalization layer - MultiHeadAttention layer - GELU layer เป็นต้น ดู tfa.layers ทั้งหมดได้ที่ https://www.tensorflow.org/addons/api_docs/python/tfa/layers .
. 9) Optimizers ใหม่มากมายบน tfa.optimizers และ tfa ยังมี SOTA optimizers ใหม่ๆ อีกมากมายที่เพื่อเป็นทางเลือกนอกจาก Adam หรือ SGD เช่น AdamW, LAMB, Lookahead, RectifiedAdam, หรือ wrapper เช่น Stochastic Weighted Averaging (SWA) เป็นต้น
https://www.tensorflow.org/addons/api_docs/python/tfa/optimizers .
. 10) สร้าง probabilistic model ด้วย tfp (Tensorflow Probability)! tfp คือ library ที่ทำให้เรานำโมเดล Deep Learning ผนวกรวมกับทฤษฎี probability ได้อย่างกลมกลืน
การนำรวม probabilistic modules เข้ากับโมเดลมีประโยชน์หลายอย่าง อาทิเช่น ทำให้โมเดลสามารถบอกความมั่นใจของคำทำนาย หรือทำให้สุ่มตัวอย่าง (สร้าง data ใหม่) จาก data distribution ได้เช่นโมเดล variational autoencoders เป็นต้น
ดูรายละเอียดวิธีการใช้งาน tfp ได้ที่ https://www.tensorflow.org/probability/overview
----------------------
เพิ่มเติม
หัวใจของ Keras คือ Layer และ Model Classes อธิบาย F. Chollet ซึ่งเป็นผู้ที่สร้าง Keras ขึ้นมา
(ถ้าลิงก์ไม่ขึ้นคลิ้กที่นี่ )
ในวิดิโอจะเป็นเนื้อหาเดียวกับใน Official Tutorial นี้ครับ https://www.tensorflow.org/guide/keras/custom_layers_and_models
แท้จริงแล้ว Tensorflow และ Keras สามารถทำ Probabilistic Programmig เช่น Bayesian Inference หรือ Gaussian Process ได้อีกด้วย
(ถ้าวิดิโอไม่ขึ้นคลิ้กที่นี่ )
การสร้าง Data Pipeline ใน Tensorflow-Keras 2.x
ตอนที่ 1 สร้างได้กี่วิธี แตกต่างกันอย่างไร ?
ThaiKeras and Kaggle 7 Feb 2021
สวัสดีครับเพื่อนๆ ด้วยพลังของ TF-Keras นั้น การสร้างและฝึกสอนโมเดล Deep Learning สามารถทำได้ภายในไม่กี่บรรทัด ดังนั้นในทางปฏิบัติประสิทธิภาพของโมเดลที่เราสร้างขึ้นจะใช้งานจริงได้ดีแค่ไหน จะขึ้นอยู่กับ "การเตรียม" ข้อมูลฝึกสอนของเราเป็นหลักครับ
การเตรียมข้อมูลฝึกสอนนี้มักเรียกว่า "การสร้าง Data Pipeline" โดย Data Pipeline นี้ไม่ใช่แค่เพียงโหลดข้อมูลขึ้นมาแล้วก็เสร็จนะครับ แต่ครอบคลุม การดัดแปลงข้อมูล (transformation) เพิ่มความหลากหลายข้อมูล (augmentation) การพัฒนาความเร็วสูงสุด (speed optimizing) รวมทั้งเรื่องการทำ batch และสุ่ม (shuffling) ต่างๆ ด้วย
.
สร้างและฝึกสอนโมเดล (สบายเกิน) บน tf-keras
ทวนกันสักนิดว่า โดยในงานทั่วไปเราสามารถสร้างโมเดลที่ดีที่สุดในปัจจุบันสำหรับข้อมูลที่เรามีไม่ว่าจะเป็นงานด้านรูปภาพ (เช่น EfficientNet) หรือด้านภาษา (Huggingface Transformers) ด้วยการโหลด pretrained weights ยกตัวอย่างเช่นสมมติเราต้องการสร้างโมเดลจำแนกรูปภาพ (image classification) ด้วย EfficientNet B0 เราสามาถทำได้ดังนี้ (สำหรับด้านภาษาดูตัวอย่างใน Workshop หรือบทความที่ผ่านมาได้เช่นเดียวกันครับ)
from tensorflow.keras.applications import EfficientNetB0</p> <p>model = EfficientNetB0(weights='imagenet')
และสามารถดัดแปลงให้เข้ากับจำนวน class ในข้อมูลของเราได้เพียงดัดแปลงนิดหน่อย ผู้สนใจดูตัวอย่างใน อ้างอิง 1.
จากตัวอย่างในลิงก์จะเห็นว่าในส่วนการฝึกสอนเพื่อให้โมเดลเรียนรู้ข้อมูลของเรา นั้นก็ง่ายสุดๆ เพียงใช้คำสั่ง model.fit เท่านั้น
เนื่องจากการสร้างและสอนโมเดลทำกันเป็นมาตรฐานไม่กี่บรรทัด ในทางปฏิบัตินั้น โมเดลจะทำงานได้ดีหรือไม่ จึงขึ้นกับการเตรียมข้อมูลเป็นหลัก และเป็นที่มาของบทความชุดนี้ครับ
ซึ่งถ้าดูในรายละเอียดเจ้า model.fit นี้รับข้อมูลได้หลักๆ 3 แบบ (อ้างอิง 2.) คือ
- รับข้อมูลตรงๆ (numpy/tf tensor)
- รับข้อมูลผ่าน data generator ( tf.keras.utils.Sequence )
- รับข้อมูลผ่าน tensorflow data api (tf.data.dataset)
ซึ่งแต่ละวิธีมีข้อดีข้อเสียต่างกันอยู่ ดังจะอธิบายในหัวข้อถัดไป แต่ขอใบ้ก่อนว่าเราแนะนำ tensorflow data api เป็นอันดับหนึ่งในใจครับผม 😀
.
ความแตกต่างระหว่าง data pipelines ทั้ง 3 แบบ
สมมติเรามีรูปภาพจำนวน N รูปภาพอยู่ใน drive ของเรา
- สร้างข้อมูลตรงๆ ด้วย numpy หรือ tf tensor
วิธีการ : ใช้ python library สำหรับจัดการรูปภาพเช่น CV2 หรือ PIL วนลูปโหลดรูปภาพเก็บเข้า numpy array ชื่อ x และสร้าง label ใน array ชื่อ y และสั่งงาน model.fit(x,y)
และมี option เสริมคือ data augmentation เพื่อเพิ่มความหลากหลายของข้อมูลจะทำได้ โดยผ่าน keras preprocessing layers หรือใช้ keras ImageDataGenerator (อ้างอิง 3.)
ข้อดี : โค้ดสั้น เข้าใจง่ายและสะดวก เหมาะกับ dataset ขนาดเล็กที่จำนวนข้อมูล N ไม่มาก
ข้อเสีย : ต้องใช้ memory ทั้งหมดในการโหลดข้อมูล ดังนั้นถ้าเรามีข้อมูลจำนวนมหาศาล (แสน ล้าน หรือมากกว่า) ก็จำเป็นต้องใช้ hardware spec สูงมากตามไปด้วย
ตัวอย่าง : ภาพ x-ray เพื่อตรวจจับอาการปอดบวม โดยจำนวนข้อมูลฝึกสอนมีขนาดเล็กคือ N = 5216 ทำให้เราสามารถโหลดข้อมูลเข้า memory ได้ทั้งหมด
kaggle.com/rajpraveenpradhan/keras-based-cnn-model-for-pneumonia-detection
หมายเหตุ : ถ้าใช้ ImageDataGenerator ในการ augment ข้อมูล จริงๆ แล้วเป็นการเปลี่ยนรูปแบบ data pipeline จากวิธีที่ 1 (array) ไปเป็นวิธีที่ 2 คือ data generator อย่างง่ายครับ
2. สร้าง data pipeline ด้วย data generator ผ่าน class tf.keras.utils.Sequence
วิธีการ: เป็นส่วนขยายของวิธีที่ 1 โดยใช้งานได้แม้ว่าจะมีข้อมูลปริมาณมหาศาลมากกว่า memory ที่มีอยู่ โดยในการสร้าง generator class เราจะวนลูปโหลดเช่นเดียวกับวิธีที่ 1 เพียงแต่เราจะสามารถโหลดรูปเพียงทีละ batch เท่านั้นใน method __getitem__ ทำให้ไม่รบกวน memory ใน hardware
นอกจากนี้การทำ data augmentation ยังสามารถใช้งานได้อย่างอิสระ โดยสามารถใช้ library augmentation ภายนอกได้อย่างอิสระเช่น albumentations สำหรับ image และ nlpaug สำหรับ texts หรือ speech ครับ
ข้อดี: จัดการข้อมูลได้อย่างอิสระ วิธีการวนลูปโหลดข้อมูลทำตรงๆ โค้ดยาวหน่อย แต่เข้าใจได้ไม่ยาก นอกจากนี้ยังใช้ library ภายนอกได้อย่างที่กล่าวข้างต้น
ข้อเสีย: การ optimize ความเร็วทำได้ยาก เช่นการใช้ประโยชน์ของ hardware ในการอ่านข้อมูลแบบ parallel ในทุกๆ operation ทำได้ยาก นอกจากนี้จุดอ่อนที่สำคัญที่สุดคือเราไม่สามารถใช้ TPU (ดูบทความ : ) กับ data generator ได้ครับใน Tensorflow เวอร์ชันปัจจุบัน (TF 2.4) ซึ่งหวังว่าจะมีการปรับปรุงในอนาคตครับ
ตัวอย่าง : ตัวอย่าง thaikeras workshop ในอดีตของเราสมัยที่ไม่มี TPU จะใช้วิธีนี้ เช่นในปัญหาจัดประเภทของในพิพิธภัณฑ์หลายแสนชิ้น :
(ดู cell ที่ 14)
3. สร้าง data pipeline ด้วย tf.data.dataset
วิธีการ: วิธีนี้เราจะใช้ functions ทั้งหมดผ่าน library ของ tensorflow ไม่ว่าจะเป็นการโหลดรูป, augment, เพิ่ม speed ซึ่งเราจำเป็นต้องจำแนกขั้นตอนออกเป็นส่วนๆ และเรียกใช้ tensorflow api ในแต่ละส่วนนั้นๆ
ข้อดี: เป็นที่สุดในแง่ของความเร็ว (อ้างอิง 4.) ทุกขั้นตอนถูก optimize มาอย่างดีโดยทีมงาน Tensorflow และเป็น official pipeline ของ TPU ทำให้สามารถใช้งานได้กับ TPU ได้ง่ายที่สุดและปัญหาน้อยที่สุด นอกจากนี้ถ้าใช้คล่องแคล่วแล้ว จำนวนโค้ดในการสร้าง pipeline ในหลายๆ ส่วนก็จะง่ายกว่า Data Generator
ข้อเสีย: ต้องเรียนรู้ Tensorflow API ในกระบวนการใหม่ทั้งหมด ไม่ support การใช้งาน library ภายนอกอย่างเต็มรูปแบบ (เช่นใช้กับ TPU ไม่ได้ และโค้ดไม่ตรงไปตรงมา)
หมายเหตุ: ต้องใช้เวลาศึกษาใหม่ช่วงแรก แต่ถ้าใช้คล่องแล้ว เราจะพบว่าบางส่วนของ pipeline จะควบคุมได้ง่ายกว่า Data Generator
ตัวอย่าง: รู้จำเสียงสัตว์ประเภทต่างๆ ในป่าดงดิบด้วย TPU
</a></p>
<p>kaggle.com/yosshi999/rfcx-train-resnet50-with-tpu</p>
<p><a href="https://www.kaggle.com/rajpraveenpradhan/keras-based-cnn-model-for-pneumonia-detection" rel="nofollow">
(ดูรายละเอียดเพิ่มเติมได้จากบทความก่อนของเรา http://bit.ly/thaikeras-kaggle-rfcx )
เอาล่ะครับ ในตอนนี้เราก็ทราบความแตกต่างระหว่างการสร้าง data pipeline แต่ละแบบแล้ว
ในบทความหน้าเราจะมาลงเพิ่มเติมในส่วนของ tf.data.dataset กันโดยเฉพาะครับ
อ้างอิง: 1) ปรับโมเดลให้เข้ากับประเภทข้อมูล (ดู cell 16) : kaggle.com/pednoi/imet-workshop 2) model.fit https://keras.io/api/models/model_training_apis/ 3) ImageDataGenerator https://keras.io/api/preprocessing/image/#imagedatagenerator-class
4) TF Data Pipeline โดย Jiri Simsa - https://www.youtube.com/watch?v=ZnukSLKEw34
เร่งสปีด 2 เท่าด้วย mixed-precision ง่ายๆ ใน Tensorflow-Keras 2.4
ThaiKeras and Kaggle 18 Feb 2021
สวัสดีครับเพื่อนๆ ใน TF2.4 นั้น เทคนิคที่เรียกว่า Mixed-precision นั้นพัฒนาเสร็จสมบูรณ์และเสถียรแล้ว (ดูอ้างอิง 1) และเพื่อนๆ สามารถใช้เทคนิค mixed-precision ง่ายสุดๆ ด้วยการเพิ่มโค้ดไม่กี่บรรทัด เพื่อเพิ่มความเร็วในการสอนโมเดล Deep Learning ได้เกือบเท่าตัวเลยครับ (สำหรับ GPU รุ่นใหม่ๆ และ TPU เท่านั้น)
.
Mixed-precision คืออะไร?
แรกเริ่มเดิมทีนั้น GPU และ Deep Learning library นั้นสนับสนุนการทำงานบนตัวแปรขนาด 32 บิตเป็นหลัก (เรียก Floating-Point 32 หรือ FP32) อย่างไรก็ดีผู้พัฒนาตระหนักได้ว่าตัวแปรส่่วนใหญ่ในโมเดลนั้นเก็บบนตัวแปรขนาดเล็กคือ 16 บิต (FP16) ก็เพียงพอแล้ว
นั่นจึงทำให้ทั้งผู้ผลิต GPU และ TPU เช่น Nvidia และ Google หันมา optimize hardware สมัยใหม่ให้ทำงานกับตัวแปร FP16 ได้เร็วขึ้นมาก ทั้งนี้เพราะตัวแปร FP16 เล็กกว่า FP32 เท่าตัวจึงคำนวณได้เร็วกว่า และยังประหยัด memory กว่าเท่าตัวอีกด้วย
อย่างไรก็ดี ยังมีบางตัวแปรโดยเฉพาะตัวแปรที่เกี่ยวข้องกับการคำนวณ loss ยังต้องการความละเอียดสูงระดับ FP32 อยู่ จึงเป็นที่ของ "mixed-precision" หรือการผสมผสานตัวแปรที่ความละเอียดต่างกัน ให้ทำงานร่วมกันได้อย่างไร้รอยต่อนั่นเองครับ
โดยการทำ Mixed-precision บน TF2.4 นี้ถูกออกแบบมาให้ง่ายสุดๆ โดยผู้ใช้แค่เติม/ปรับโค้ดไป 2-3 ก็ใช้งานได้ทันทีครับ
.
การใช้งาน Mixed-precision ในโค้ดของเรา
สำหรับรายละเอียดฉบับเต็มสามารถดูได้ในอ้างอิง (1) นะครับ โดยทั่วไป keras โมเดลที่สอนด้วย model.fit เราเพียง ใส่บรรทัดนี้ลงไปตอนเริ่มต้นโปรแกรมเท่านั้น (สำหรับ advanced users จะมีรายละเอียดมากขึ้นเล็กน้อยดูในอ้างอิงนะครับ)
</p>
<p>from tensorflow.keras import mixed_precision</p>
<p>mixed_precision.set_global_policy('mixed_float16') # สำหรับ Nvidia GPU</p>
<p>
หรือ
</p>
<p>mixed_precision.set_global_policy('mixed_bfloat16') # สำหรับ Google TPU</p>
<p>
เมื่อใส่คำสั่งดังกล่าวในตอนต้นโปรแกรมแล้ว ตัวแปรทั้งหมดจะเป็นชนิด FP16 โดยอัตโนมัติ อย่างไรก็ตามในการสร้างโมเดล ตัวแปรที่จำเป็นต้องเป็น FP32 อยู่มักจะเป็นตัวแปรใน layer สุดท้ายที่เราจะทำนาย (เช่น Softmax หรือ Sigmoid) ให้เราระบุให้ชัดเจนว่าเป็น FP32 ครับ
เช่น โดยปกติใน Keras เราจะสร้าง layer สุดท้ายด้วย
tf.keras.layers.Dense(NUM_CLASSES, activation='softmax', name='prediction')
ให้ระบุชนิด FP32 ลงไปง่ายๆ แบบนี้
tf.keras.layers.Dense(NUM_CLASSES, activation='softmax', name='prediction', dtype='float32')
เป็นอันเสร็จสิ้นครับ
.
GPU/TPU รุ่นใดใช้ Mixed-Precision ได้บ้าง?
อย่างที่เกริ่นข้างต้นว่าการสนับสนุน mixed-precision เต็มรูปแบบนั้นอยุ่ใน Hardware รุ่นหลังๆ ซึ่งจะสามารถเพิ่มความเร็วได้ราวๆ 100% เลยทีเดียว ซึง GPU ที่สนับสนุนนั้นจะอยู่ในตระกูล RTX เป็นต้นมา เช่น RTX 2070 / 2080 / 3080 เป็นต้นครับ ส่วน GPU ใน cloud enterprise server นั้นจะอยู่ในรุ่น V100, T4 และ A100 เป็นต้น
น่าเสียดายมากที่ GPU ที่เราใช้ฟรีใน Colab/Kaggle ซึ่งมักจะเป็น P100 นั้นไม่สนับสนุน mixed-precision speed up ครับ แต่ก็ยังใช้ได้นะครับ ไม่ต้องเสียใจไป อย่างน้อยพอใช้ mixed-precision จะทำให้เราเพิ่ม Batch size เป็น 2 เท่าได้ และจะยังทำให้ฝึกสอนโมเดลเร็วขึ้นระดับนึงครับ
ส่วนใน TPU นั้นจะสนับสนุน mixed-precision อยู่แล้วครับ แต่ความเร็วจะไม่เพิ่มขึ้นมากเหมือน GPU ที่สนับสนุนเต็มตัว
นอกจากนี้ในอ้างอิง (1) ยังพูดถึงทริคเล็กๆ น้อยๆ ที่ควรทำเพื่อให้ใช้ประสิทธิภาพ Hardware ได้เต็มกำลังโดยการให้ตัวแปรทุกชนิดหารด้วย 8 ลงตัว ไม่ว่าจะเป็น Batch size / Hidden units / CNN filters เป็นต้น
สำหรับบทความนี้ขอจบเท่านี้ครับ 😀
อ้างอิง
(1) Mixed-precision TF tutorial : https://www.tensorflow.org/guide/mixed_precision
(2) https://www.quora.com/What-is-the-difference-between-FP16-and-FP32-when-doing-deep-learning
