เกี่ยวกับ Codelab นี้
1 ภาพรวม
TPU ทำงานเร็วมาก สตรีมข้อมูลการฝึกต้องยึดตามความเร็วในการฝึก ในห้องทดลองนี้ คุณจะได้ดูวิธีโหลดข้อมูลจาก GCS ด้วย tf.data.Dataset API เพื่อป้อน TPU
ห้องทดลองนี้เป็นส่วนที่ 1 ของ "Keras บน TPU" ซีรีส์ คุณสามารถดำเนินการตามลำดับต่อไปนี้หรือทำแยกต่างหากก็ได้
- [THIS LAB] ไปป์ไลน์ข้อมูลความเร็ว TPU: tf.data.Dataset และ TFRecords
- โมเดล Keras แรกของคุณที่มีการเรียนรู้การโอน
- โครงข่ายระบบประสาทเทียมแบบ Convolutional ที่มี Keras และ TPU
- Convnets, การบีบ, Xception พร้อม Keras และ TPU
สิ่งที่คุณจะได้เรียนรู้
- วิธีใช้ tf.data.Dataset API เพื่อโหลดข้อมูลการฝึก
- เพื่อใช้รูปแบบ TFRecord เพื่อโหลดข้อมูลการฝึกอย่างมีประสิทธิภาพจาก GCS
ความคิดเห็น
โปรดแจ้งให้เราทราบหากพบข้อผิดพลาดใน Code Lab นี้ คุณแสดงความคิดเห็นได้ผ่านปัญหาเกี่ยวกับ GitHub [ feedback link]
2 คู่มือเริ่มต้นฉบับย่อสำหรับ Google Colaboratory
ห้องทดลองนี้ใช้ Google Collaboratory และคุณไม่จำเป็นต้องตั้งค่าใดๆ Colaboratory เป็นแพลตฟอร์มสมุดบันทึกออนไลน์สำหรับวัตถุประสงค์ด้านการศึกษา โดยมีการฝึกอบรม CPU, GPU และ TPU ฟรี
คุณเปิดสมุดบันทึกตัวอย่างนี้แล้ววิ่งผ่านเซลล์ 2-3 เซลล์เพื่อทำความคุ้นเคยกับ Colaboratory ได้
เลือกแบ็กเอนด์ TPU
ในเมนู Colab ให้เลือกรันไทม์ > เปลี่ยนประเภทรันไทม์ จากนั้นเลือก TPU ใน Code Lab นี้ คุณจะได้ใช้ TPU (Tensor Processing Unit) ที่มีประสิทธิภาพซึ่งได้รับการสนับสนุนไว้สำหรับการฝึกแบบเร่งฮาร์ดแวร์ การเชื่อมต่อกับรันไทม์จะเกิดขึ้นโดยอัตโนมัติในการดำเนินการครั้งแรก หรือคุณจะใช้การเชื่อมต่อ "เชื่อมต่อ" ก็ได้ ที่มุมบนขวา
การดำเนินการกับสมุดบันทึก
เรียกใช้ทีละเซลล์ด้วยการคลิกที่เซลล์แล้วกด Shift-ENTER นอกจากนี้ คุณยังเรียกใช้สมุดบันทึกทั้งหมดได้ด้วยรันไทม์ > เรียกใช้ทั้งหมด
สารบัญ
สมุดบันทึกทั้งหมดมีสารบัญ คุณสามารถเปิดได้โดยใช้ลูกศรสีดำทางด้านซ้าย
เซลล์ที่ซ่อนอยู่
บางเซลล์จะแสดงเฉพาะชื่อเท่านั้น ฟีเจอร์นี้เป็นฟีเจอร์สำหรับสมุดบันทึกของ Colab โดยเฉพาะ คุณสามารถดับเบิลคลิกเพื่อดูโค้ดที่อยู่ด้านในได้ แต่ปกติแล้วสิ่งนี้ไม่ค่อยน่าสนใจนัก โดยทั่วไปจะรองรับหรือฟังก์ชันการแสดงผล คุณยังต้องเรียกใช้เซลล์เหล่านี้เพื่อให้มีการกำหนดฟังก์ชันภายในเซลล์
การตรวจสอบสิทธิ์
Colab อาจเข้าถึงที่เก็บข้อมูล Google Cloud Storage ส่วนตัวได้หากคุณตรวจสอบสิทธิ์ด้วยบัญชีที่ได้รับอนุญาต ข้อมูลโค้ดด้านบนจะทริกเกอร์ขั้นตอนการตรวจสอบสิทธิ์
3 [INFO] Tensor Processing Unit (TPU) คืออะไร
สรุป
โค้ดสำหรับการฝึกโมเดลบน TPU ใน Keras (และกลับไปใช้ GPU หรือ CPU หากไม่มี TPU):
try: # detect TPUs
tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines
# use TPUStrategy scope to define model
with strategy.scope():
model = tf.keras.Sequential( ... )
model.compile( ... )
# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)
ในวันนี้เราจะใช้ TPU เพื่อสร้างและเพิ่มประสิทธิภาพตัวแยกประเภทดอกไม้ด้วยความเร็วแบบอินเทอร์แอกทีฟ (นาทีต่อการฝึกแต่ละครั้ง)
ทำไมต้องใช้ TPU
GPU สมัยใหม่ได้รับการจัดระเบียบตาม "แกน" ที่ตั้งโปรแกรมได้ ซึ่งเป็นสถาปัตยกรรมที่มีความยืดหยุ่นมากซึ่งช่วยให้จัดการงานต่างๆ ได้มากมาย เช่น การแสดงภาพ 3 มิติ การเรียนรู้เชิงลึก การจำลองทางกายภาพ ฯลฯ อีกฝั่งหนึ่งจะเป็น TPU ที่จะจับคู่กับหน่วยประมวลผลเวกเตอร์แบบคลาสสิกกับหน่วยการคูณเมทริกซ์โดยเฉพาะ และทำได้อย่างดีเยี่ยมในทุกๆ งานที่มีการใช้การคูณเมทริกซ์ขนาดใหญ่ เช่น โครงข่ายระบบประสาทเทียม
ภาพประกอบ: ชั้นโครงข่ายระบบประสาทเทียมแบบคูณเมทริกซ์ โดยมีรูปภาพ 8 รูปประมวลผลผ่านโครงข่ายประสาทพร้อมกัน โปรดทำการคูณคอลัมน์ 1 บรรทัด x เพื่อยืนยันว่าเป็นการทำผลรวมแบบถ่วงน้ำหนักของค่าพิกเซลทั้งหมดของรูปภาพ เลเยอร์คอนโวลูชัน (Convolution) อาจแสดงเป็นการคูณเมทริกซ์ได้ด้วย แม้ว่าจะซับซ้อนกว่าเล็กน้อย ( มีคำอธิบายในส่วนที่ 1)
ฮาร์ดแวร์
MXU และ VPU
แกน TPU v2 สร้างขึ้นจาก Matrix Multiply Unit (MXU) ซึ่งเรียกใช้การคูณเมทริกซ์ และ Vectorประมวลผลข้อมูล Unit (VPU) สำหรับงานอื่นๆ ทั้งหมด เช่น การเปิดใช้งาน, softmax เป็นต้น VPU จะจัดการการคำนวณ Float32 และ int32 ส่วน MXU จะทำงานในรูปแบบจุดทศนิยม 16-32 บิตที่มีความแม่นยำแบบผสม
ผสมจุดทศนิยมที่มีความแม่นยำและ bFloat 16
MXU จะคำนวณการคูณเมทริกซ์โดยใช้อินพุต bfloat16 และเอาต์พุต Float32 การเก็บสะสมขั้นกลางจะเกิดขึ้นด้วยความแม่นยำ Float 32
โดยทั่วไปการฝึกโครงข่ายระบบประสาทเทียมจะต้านเสียงที่เกิดจากความแม่นยำของจุดลอยตัวที่ลดลง แต่ก็มีบางกรณีที่เสียงรบกวนช่วยให้เครื่องมือเพิ่มประสิทธิภาพเชื่อมต่อกันได้ เดิมทีมีการใช้ความแม่นยำของจุดลอยตัว 16 บิตเพื่อเร่งการคำนวณ แต่รูปแบบ Float 16 และ Float 32 มีช่วงที่ต่างกันมาก การลดความแม่นยำจาก Float32 เป็น Float 16 มักจะทำให้เกิดการไหลเกินหรือต่ำกว่าที่ควรจะเป็น มีโซลูชันอยู่ แต่โดยทั่วไปแล้วต้องมีการดำเนินการเพิ่มเติมเพื่อให้ Float 16 ทำงานได้
Google จึงเปิดตัวรูปแบบ bFlo 16 ใน TPU bFloat16 คือ Float 32 ที่ถูกตัดซึ่งมีบิตและช่วงเลขชี้กำลังเหมือนกับ Float 32 นอกจากข้อเท็จจริงที่ว่า TPU จะคํานวณการคูณเมทริกซ์ด้วยความแม่นยำแบบผสมกับอินพุต bFloat16 แต่เอาต์พุต Float 32 หมายความว่าโดยทั่วไปแล้วไม่จําเป็นต้องเปลี่ยนแปลงโค้ดเพื่อให้ได้รับประโยชน์จากประสิทธิภาพที่เพิ่มขึ้นจากความแม่นยำที่ลดลง
อาร์เรย์แบบซิสโตลิก
MXU ใช้การคูณเมทริกซ์ในฮาร์ดแวร์โดยใช้สิ่งที่เรียกว่า "อาร์เรย์ซีสโตลิค" ที่ให้องค์ประกอบข้อมูลไหลผ่านอาร์เรย์ของหน่วยการคำนวณฮาร์ดแวร์ (ในทางการแพทย์ "ซิสโตลิค" หมายถึงการหดตัวของหัวใจและการไหลเวียนของเลือด ในที่นี้หมายถึงการไหลเวียนของข้อมูล)
องค์ประกอบพื้นฐานของการคูณเมทริกซ์คือผลคูณระหว่างเส้นจากเมทริกซ์หนึ่งและคอลัมน์จากเมทริกซ์อีกตัวหนึ่ง (ดูภาพประกอบที่ด้านบนของส่วนนี้) สำหรับการคูณเมทริกซ์ Y=X*W องค์ประกอบหนึ่งของผลลัพธ์จะเป็นดังนี้
Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]
บน GPU จะมีการเขียนโปรแกรมผลิตภัณฑ์จุดนี้เป็น "แกน" ของ GPU แล้วดำเนินการกับ "แกน" ได้มากเท่าที่ต้องการ ที่มีอยู่ควบคู่กันไป เพื่อลองคำนวณทุกค่าของเมทริกซ์ผลลัพธ์พร้อมกัน หากเมทริกซ์ผลลัพธ์ใหญ่ 128x128 ต้องใช้ 128x128=16K "แกน" ไม่พร้อมใช้งานซึ่งโดยทั่วไปแล้วเป็นไปไม่ได้ โดย GPU ขนาดใหญ่ที่สุดจะมีแกนประมาณ 4,000 แกน ส่วน TPU จะใช้ฮาร์ดแวร์ขั้นต่ำเพียงเล็กน้อยสำหรับหน่วยประมวลผลใน MXU โดยมีเพียง bfloat16 x bfloat16 => float32 ตัวสะสมแบบทวีคูณเท่านั้น ไม่ใช่อย่างอื่น ซึ่ง TPU เหล่านี้มีขนาดเล็กมากจนทำให้ TPU ขนาด 16K นำไปใช้ในขนาด 128x128 MXU และประมวลผลการคูณเมทริกซ์ได้ในคราวเดียว
ภาพ: อาร์เรย์แบบซิสโตลิคของ MXU องค์ประกอบที่ใช้คำนวณคือตัวคูณสะสม ระบบจะโหลดค่าของเมทริกซ์ 1 รายการเข้าไปในอาร์เรย์ (จุดสีแดง) ค่าของเมทริกซ์อื่นจะไหลผ่านอาร์เรย์ (จุดสีเทา) เส้นแนวตั้งจะถ่ายทอดค่าขึ้น เส้นแนวนอนจะแสดงผลรวมของบางส่วน จึงทิ้งไว้เป็นแบบฝึกหัดสำหรับผู้ใช้เพื่อยืนยันว่าขณะที่ข้อมูลไหลผ่านอาร์เรย์ คุณจะได้ผลลัพธ์ของการคูณเมทริกซ์จากด้านขวา
นอกจากนี้ ขณะที่ระบบคำนวณผลิตภัณฑ์แบบจุดใน MXU ผลรวมที่เป็นกลางจะไหลไปมาระหว่างหน่วยประมวลผลที่อยู่ติดกัน คุณไม่จำเป็นต้องเก็บและเรียกข้อมูลไปยัง/จากหน่วยความจำ หรือแม้แต่ไฟล์การลงทะเบียน ผลลัพธ์ที่ได้คือสถาปัตยกรรมอาร์เรย์แบบซิสโตลิคของ TPU มีความหนาแน่นและประโยชน์ด้านพลังงานที่สำคัญ รวมถึงให้ข้อได้เปรียบด้านความเร็วในระดับที่ไม่สำคัญเมื่อเทียบกับ GPU เมื่อคำนวณการคูณเมทริกซ์
Cloud TPU
เมื่อคุณขอ " Cloud TPU v2" บน Google Cloud Platform คุณจะได้รับเครื่องเสมือน (VM) ที่มีกระดาน TPU ติด PCI กระดาน TPU มีชิป TPU แบบ Dual-core 4 ชิป แกน TPU แต่ละแกนมี VPU (Vector Workflow Unit) และ 128x128 MXU (MatriXส่งต่อหน่วย) "Cloud TPU" นี้ จากนั้นมักจะเชื่อมต่อผ่านเครือข่ายกับ VM ที่ขอ ภาพรวมทั้งหมดจะมีลักษณะดังนี้
ภาพประกอบ: VM ที่มี "Cloud TPU" แนบกับเครือข่าย Accelerator "Cloud TPU" สร้างจาก VM ที่มีบอร์ด TPU ประกอบ PCI ซึ่งมีชิป TPU แบบ Dual-core 4 ชิปอยู่
พ็อด TPU
ในศูนย์ข้อมูลของ Google นั้น TPU จะเชื่อมต่อกับการเชื่อมต่อระหว่างการประมวลผลประสิทธิภาพสูง (HPC) ซึ่งทำให้ปรากฏเป็น Accelerator ขนาดใหญ่มากตัวเดียว Google เรียกอุปกรณ์นี้ว่าพ็อดและรวมแกน TPU v2 ได้สูงสุด 512 แกน หรือแกน TPU v3 2048 แกน
ภาพประกอบ: พ็อด TPU v3 บอร์ดและชั้นวาง TPU เชื่อมต่อกันผ่านการเชื่อมต่อถึงกัน HPC
ในระหว่างการฝึก ระบบจะแลกเปลี่ยนการไล่ระดับสีระหว่างแกน TPU โดยใช้อัลกอริทึม All-reduce ( มีคำอธิบายที่ดีของ all-reduce ที่นี่) โมเดลที่กำลังฝึกจะใช้ประโยชน์จากฮาร์ดแวร์ได้ด้วยการฝึกในแบบกลุ่มขนาดใหญ่
ภาพประกอบ: การซิงค์การไล่ระดับสีระหว่างการฝึกโดยใช้อัลกอริทึม All-Reduce ในเครือข่าย HPC แบบ Toroidal Mesh แบบ 2 มิติของ Google TPU
ซอฟต์แวร์
การฝึกอบรมแบบกลุ่มขนาดใหญ่
ขนาดกลุ่มที่เหมาะที่สุดสำหรับ TPU คือรายการข้อมูล 128 ครั้งต่อแกน TPU แต่ฮาร์ดแวร์สามารถแสดงการใช้งานที่ดีจากรายการข้อมูล 8 ครั้งต่อแกน TPU ได้แล้ว โปรดทราบว่า Cloud TPU 1 แกนมี 8 แกน
เราจะใช้ Keras API ใน Code Lab นี้ ใน Keras แบทช์ที่คุณระบุคือขนาดกลุ่มทั่วโลกสำหรับ TPU ทั้งหมด แบทช์จะแยกเป็น 8 โดยอัตโนมัติและทำงานบน 8 แกนของ TPU
สำหรับเคล็ดลับด้านประสิทธิภาพเพิ่มเติม โปรดดูคู่มือประสิทธิภาพของ TPU สำหรับชุดอาหารที่มีขนาดใหญ่มาก อาจต้องมีการดูแลเป็นพิเศษในบางรุ่น ดูรายละเอียดเพิ่มเติมได้ที่ LARSOptimizer
ขั้นสูง: XLA
โปรแกรม Tensorflow จะกำหนดกราฟการคำนวณ TPU ไม่ได้เรียกใช้โค้ด Python โดยตรง แต่จะเรียกใช้กราฟการคำนวณที่กำหนดโดยโปรแกรม Tensorflow สำหรับเบื้องหลังการทำงาน คอมไพเลอร์ชื่อ XLA (Accelerated Linear Algebra) จะแปลงกราฟ Tensorflow ของโหนดการคำนวณเป็นโค้ดเครื่อง TPU คอมไพเลอร์นี้จะดำเนินการเพิ่มประสิทธิภาพขั้นสูงหลายอย่างกับโค้ดและเลย์เอาต์หน่วยความจำของคุณ การคอมไพล์จะเกิดขึ้นโดยอัตโนมัติเมื่อมีการส่งงานไปยัง TPU คุณไม่จำเป็นต้องใส่ XLA ไว้ในเชนบิลด์อย่างชัดเจน
ภาพ: หากต้องการเรียกใช้บน TPU กราฟการคำนวณที่กำหนดโดยโปรแกรม Tensorflow จะได้รับการแปลเป็นการนำเสนอแบบ XLA (Accelerated Linear Algebra) ก่อน จากนั้นจึงคอมไพล์ด้วย XLA ลงในโค้ดเครื่อง TPU
การใช้ TPU ใน Keras
TPU ได้รับการสนับสนุนผ่าน Keras API ใน Tensorflow 2.1 การรองรับ Keras ทำงานบน TPU และพ็อด TPU ต่อไปนี้คือตัวอย่างที่ทำงานได้บน TPU, GPU และ CPU
try: # detect TPUs
tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines
# use TPUStrategy scope to define model
with strategy.scope():
model = tf.keras.Sequential( ... )
model.compile( ... )
# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)
ในข้อมูลโค้ดนี้
TPUClusterResolver().connect()พบ TPU ในเครือข่าย ซึ่งทำงานโดยไม่ต้องใช้พารามิเตอร์ในระบบ Google Cloud ส่วนใหญ่ (งาน AI Platform, Colaboratory, Kubeflow, VM ของ Deep Learning ที่สร้างผ่านยูทิลิตี "ctpu up") ระบบเหล่านี้จะทราบว่า TPU ของตนอยู่ที่ใดด้วยตัวแปรสภาพแวดล้อม TPU_NAME หากคุณสร้าง TPU ด้วยตนเอง ให้ตั้งค่าสภาพแวดล้อม TPU_NAME ตัวแปร บน VM ที่คุณใช้ หรือเรียกใช้TPUClusterResolverด้วยพารามิเตอร์ที่ชัดแจ้ง:TPUClusterResolver(tp_uname, zone, project)TPUStrategyเป็นส่วนที่ใช้การกระจายและ "ลดทั้งหมด" อัลกอริทึมการซิงค์แบบไล่ระดับสี- นำกลยุทธ์ไปใช้ผ่านขอบเขต ต้องกำหนดโมเดลภายใน strategy scope()
- ฟังก์ชัน
tpu_model.fitคาดหวังออบเจ็กต์ tf.data.Dataset สำหรับอินพุตสำหรับการฝึก TPU
งานการย้าย TPU ทั่วไป
- แม้ว่าการโหลดข้อมูลในรูปแบบ Tensorflow จะมีหลายวิธี แต่สำหรับ TPU จำเป็นต้องมีการใช้ API ของ
tf.data.Dataset - TPU ทำงานเร็วมากและการส่งผ่านข้อมูลมักกลายเป็นจุดคอขวดเมื่อทำงานบน TPU คุณสามารถใช้เครื่องมือในการตรวจหาจุดคอขวดของข้อมูลและเคล็ดลับด้านประสิทธิภาพอื่นๆ ได้ในคู่มือประสิทธิภาพ TPU
- หมายเลข int8 หรือ int16 จะถือว่าเป็น int32 TPU ไม่มีฮาร์ดแวร์จำนวนเต็มที่ทำงานบนขนาดน้อยกว่า 32 บิต
- ไม่รองรับการดำเนินการบางอย่างของ Tensorflow ดูรายชื่อได้ที่นี่ ข่าวดีคือข้อจำกัดนี้จะใช้กับโค้ดการฝึกเท่านั้น เช่น การส่งผ่านไปข้างหน้าและข้างหลังผ่านโมเดลของคุณ คุณยังคงใช้การดำเนินการ Tensorflow ทั้งหมดในไปป์ไลน์อินพุตข้อมูลได้เนื่องจากการดำเนินการดังกล่าวจะเกิดขึ้นบน CPU
- ไม่รองรับ
tf.py_funcบน TPU
4 กำลังโหลดข้อมูล
เรากำลังจะใช้ชุดข้อมูลของรูปภาพดอกไม้ เป้าหมายคือการจัดหมวดหมู่ดอกไม้ออกเป็น 5 ชนิด การโหลดข้อมูลดำเนินการโดยใช้ API ของ tf.data.Dataset ก่อนอื่น มาทำความรู้จักกับ API กัน
ลงมือปฏิบัติ
โปรดเปิดสมุดบันทึกต่อไปนี้ เรียกใช้เซลล์ (Shift-ENTER) และทำตามคำแนะนำที่เห็นข้อความ "ต้องดำเนินการ" ป้ายกำกับ
Fun with tf.data.Dataset (playground).ipynb
ข้อมูลเพิ่มเติม
เกี่ยวกับ "ดอกไม้" ชุดข้อมูล
ระบบจะจัดระเบียบชุดข้อมูลใน 5 โฟลเดอร์ แต่ละโฟลเดอร์จะมีดอกไม้ชนิดเดียว โฟลเดอร์มีชื่อว่า ทานตะวัน เดซี่ แดนดิไลออน ทิวลิป และกุหลาบ ข้อมูลจะโฮสต์ในที่เก็บข้อมูลสาธารณะบน Google Cloud Storage ข้อความที่ตัดตอนมา:
gs://flowers-public/sunflowers/5139971615_434ff8ed8b_n.jpg
gs://flowers-public/daisy/8094774544_35465c1c64.jpg
gs://flowers-public/sunflowers/9309473873_9d62b9082e.jpg
gs://flowers-public/dandelion/19551343954_83bb52f310_m.jpg
gs://flowers-public/dandelion/14199664556_188b37e51e.jpg
gs://flowers-public/tulips/4290566894_c7f061583d_m.jpg
gs://flowers-public/roses/3065719996_c16ecd5551.jpg
gs://flowers-public/dandelion/8168031302_6e36f39d87.jpg
gs://flowers-public/sunflowers/9564240106_0577e919da_n.jpg
gs://flowers-public/daisy/14167543177_cd36b54ac6_n.jpg
เหตุใดจึงควรใช้ tf.data.Dataset
Keras และ Tensorflow ยอมรับชุดข้อมูลในฟังก์ชันการฝึกและการประเมินทั้งหมด เมื่อคุณโหลดข้อมูลในชุดข้อมูล API จะมีฟังก์ชันการทำงานทั่วไปทั้งหมดที่เป็นประโยชน์สำหรับข้อมูลการฝึกโครงข่ายระบบประสาทเทียม ดังนี้
dataset = ... # load something (see below)
dataset = dataset.shuffle(1000) # shuffle the dataset with a buffer of 1000
dataset = dataset.cache() # cache the dataset in RAM or on disk
dataset = dataset.repeat() # repeat the dataset indefinitely
dataset = dataset.batch(128) # batch data elements together in batches of 128
AUTOTUNE = tf.data.AUTOTUNE
dataset = dataset.prefetch(AUTOTUNE) # prefetch next batch(es) while training
ดูเคล็ดลับด้านประสิทธิภาพและแนวทางปฏิบัติแนะนำสำหรับชุดข้อมูลได้ในบทความนี้ เอกสารอ้างอิงอยู่ที่นี่
ข้อมูลเบื้องต้นเกี่ยวกับ tf.data.Dataset
ข้อมูลมักจะมาในหลายไฟล์ ตามรูปภาพนี้ คุณสร้างชุดข้อมูลของชื่อไฟล์ได้โดยการเรียกใช้
filenames_dataset = tf.data.Dataset.list_files('gs://flowers-public/*/*.jpg')
# The parameter is a "glob" pattern that supports the * and ? wildcards.
จากนั้นเลือก "แมป" ฟังก์ชันให้กับชื่อไฟล์แต่ละชื่อ ซึ่งโดยทั่วไปจะโหลดและถอดรหัสไฟล์ให้เป็นข้อมูลจริงในหน่วยความจำ
def decode_jpeg(filename):
bits = tf.io.read_file(filename)
image = tf.io.decode_jpeg(bits)
return image
image_dataset = filenames_dataset.map(decode_jpeg)
# this is now a dataset of decoded images (uint8 RGB format)
วิธีทำซ้ำในชุดข้อมูล
for data in my_dataset:
print(data)
ชุดข้อมูลของ Tuples
ในการเรียนรู้ที่มีการควบคุมดูแล ชุดข้อมูลการฝึกอบรมมักจะประกอบด้วยคู่ข้อมูลการฝึกและคำตอบที่ถูกต้อง ซึ่งฟังก์ชันถอดรหัสอาจแสดงผล Tuple ได้ จากนั้นคุณจะมีชุดข้อมูลของ Tuples และ Tuples จะส่งคืนเมื่อคุณทำซ้ำ ค่าที่แสดงผลคือ Tensorflow Tensor ที่โมเดลของคุณจะใช้งาน คุณสามารถโทรหา .numpy() บนอุปกรณ์เหล่านั้นเพื่อดูค่าดิบ:
def decode_jpeg_and_label(filename):
bits = tf.read_file(filename)
image = tf.io.decode_jpeg(bits)
label = ... # extract flower name from folder name
return image, label
image_dataset = filenames_dataset.map(decode_jpeg_and_label)
# this is now a dataset of (image, label) pairs
for image, label in dataset:
print(image.numpy().shape, label.numpy())
สรุป:การโหลดรูปภาพทีละรายการช้า!
เมื่อทำซ้ำชุดข้อมูลนี้ คุณจะเห็นว่าโหลดได้ประมาณ 1-2 ภาพต่อวินาที ช้าเกินไป ตัวเร่งฮาร์ดแวร์ที่เราจะใช้สำหรับการฝึกสามารถคงอัตรานี้ไว้ได้หลายครั้ง ไปที่ส่วนถัดไปเพื่อดูว่าเราจะบรรลุเป้าหมายนี้ได้อย่างไร
โซลูชัน
นี่คือสมุดบันทึกโซลูชัน คุณสามารถใช้รหัสผ่านนี้ได้หากติดขัด
Fun with tf.data.Dataset (solution).ipynb
หัวข้อที่ครอบคลุม
- 🤔 tf.data.Dataset.list_files
- 🤔 tf.data.Dataset.map
- 🤔 ชุดข้อมูลของ Tuples
- 😀 เป็นการทำซ้ำผ่านชุดข้อมูล
โปรดใช้เวลาสักครู่เพื่อทบทวนรายการตรวจสอบนี้
5 การโหลดข้อมูลเร็ว
ตัวเร่งฮาร์ดแวร์ Tensor Compute Unit (TPU) ที่เราจะใช้ในห้องทดลองนี้ทำงานเร็วมาก ความท้าทายคือการให้ข้อมูลแก่นักเรียนให้เร็วพอที่จะทำให้นักเรียนไม่ว่าง Google Cloud Storage (GCS) มีความสามารถในการคงอัตราการส่งข้อมูลที่สูงมาก แต่เช่นเดียวกับระบบพื้นที่เก็บข้อมูลระบบคลาวด์อื่นๆ การเริ่มเชื่อมต่อมีค่าใช้จ่ายระหว่างบางเครือข่าย ดังนั้น การจัดเก็บข้อมูลของเราเป็นไฟล์จำนวนหลายพันไฟล์จึงไม่ใช่วิธีที่ดีที่สุด เราจะจัดกลุ่มไฟล์เหล่านั้นให้เป็นไฟล์จำนวนน้อยลงและใช้พลังของ tf.data.Dataset เพื่ออ่านจากไฟล์หลายไฟล์พร้อมกัน
อ่าน
โค้ดที่โหลดไฟล์ภาพ ปรับขนาดเป็นขนาดทั่วไป แล้วจัดเก็บไว้ในไฟล์ TFRecord 16 ไฟล์อยู่ในสมุดบันทึกต่อไปนี้ โปรดอ่านอย่างละเอียด คุณไม่จำเป็นต้องดำเนินการดังกล่าว เนื่องจากจะมีการแสดงข้อมูลที่มีรูปแบบ TFRecord อย่างเหมาะสมสำหรับ Codelab ที่เหลือ
Flower pictures to TFRecords.ipynb
เลย์เอาต์ข้อมูลที่เหมาะสำหรับอัตราการส่งข้อมูล GCS ที่เหมาะสมที่สุด
รูปแบบไฟล์ TFRecord
รูปแบบไฟล์ที่ Tensorflow ต้องการสำหรับการจัดเก็บข้อมูลคือรูปแบบ TFRecord ที่ใช้ protobuf รูปแบบอนุกรมอื่นๆ ก็ใช้ได้เช่นกัน แต่คุณสามารถโหลดชุดข้อมูลจากไฟล์ TFRecord โดยตรงได้โดยเขียนข้อความต่อไปนี้
filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...) # do the TFRecord decoding here - see below
เพื่อประสิทธิภาพที่ดีที่สุด ขอแนะนำให้ใช้โค้ดที่ซับซ้อนมากขึ้นต่อไปนี้เพื่ออ่านจากไฟล์ TFRecord หลายไฟล์พร้อมกัน โค้ดนี้จะอ่านจากไฟล์ N ไฟล์พร้อมกันและไม่สนใจลำดับข้อมูลเนื่องจากมีความเร็วในการอ่านมากกว่า
AUTOTUNE = tf.data.AUTOTUNE
ignore_order = tf.data.Options()
ignore_order.experimental_deterministic = False
filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTOTUNE)
dataset = dataset.with_options(ignore_order)
dataset = dataset.map(...) # do the TFRecord decoding here - see below
ข้อมูลสรุปของ TFRecord
คุณจัดเก็บข้อมูลได้ 3 ประเภทใน TFRecord ได้แก่ สตริงแบบไบต์ (รายการไบต์) จำนวนเต็ม 64 บิต และแบบลอย 32 บิต โดยจะจัดเก็บเป็นลิสต์รายการเสมอ โดยองค์ประกอบข้อมูลเดี่ยวจะเป็นรายการขนาด 1 คุณใช้ฟังก์ชันตัวช่วยต่อไปนี้เพื่อจัดเก็บข้อมูลลงใน TFRecord ได้
การเขียนสตริงไบต์
# warning, the input is a list of byte strings, which are themselves lists of bytes
def _bytestring_feature(list_of_bytestrings):
return tf.train.Feature(bytes_list=tf.train.BytesList(value=list_of_bytestrings))
การเขียนจำนวนเต็ม
def _int_feature(list_of_ints): # int64
return tf.train.Feature(int64_list=tf.train.Int64List(value=list_of_ints))
การลอยตัวในการเขียน
def _float_feature(list_of_floats): # float32
return tf.train.Feature(float_list=tf.train.FloatList(value=list_of_floats))
การเขียน TFRecord โดยใช้ตัวช่วยข้างต้น
# input data in my_img_bytes, my_class, my_height, my_width, my_floats
with tf.python_io.TFRecordWriter(filename) as out_file:
feature = {
"image": _bytestring_feature([my_img_bytes]), # one image in the list
"class": _int_feature([my_class]), # one class in the list
"size": _int_feature([my_height, my_width]), # fixed length (2) list of ints
"float_data": _float_feature(my_floats) # variable length list of floats
}
tf_record = tf.train.Example(features=tf.train.Features(feature=feature))
out_file.write(tf_record.SerializeToString())
หากต้องการอ่านข้อมูลจาก TFRecord คุณต้องประกาศเลย์เอาต์ของระเบียนที่จัดเก็บไว้ก่อน ในการประกาศ คุณสามารถเข้าถึงช่องที่มีชื่อเป็นรายการความยาวคงที่หรือรายการความยาวตัวแปรได้ ดังนี้
อ่านข้อมูลจาก TFRecord
def read_tfrecord(data):
features = {
# tf.string = byte string (not text string)
"image": tf.io.FixedLenFeature([], tf.string), # shape [] means scalar, here, a single byte string
"class": tf.io.FixedLenFeature([], tf.int64), # shape [] means scalar, i.e. a single item
"size": tf.io.FixedLenFeature([2], tf.int64), # two integers
"float_data": tf.io.VarLenFeature(tf.float32) # a variable number of floats
}
# decode the TFRecord
tf_record = tf.io.parse_single_example(data, features)
# FixedLenFeature fields are now ready to use
sz = tf_record['size']
# Typical code for decoding compressed images
image = tf.io.decode_jpeg(tf_record['image'], channels=3)
# VarLenFeature fields require additional sparse.to_dense decoding
float_data = tf.sparse.to_dense(tf_record['float_data'])
return image, sz, float_data
# decoding a tf.data.TFRecordDataset
dataset = dataset.map(read_tfrecord)
# now a dataset of triplets (image, sz, float_data)
ข้อมูลโค้ดที่มีประโยชน์
การอ่านองค์ประกอบข้อมูลเดี่ยว
tf.io.FixedLenFeature([], tf.string) # for one byte string
tf.io.FixedLenFeature([], tf.int64) # for one int
tf.io.FixedLenFeature([], tf.float32) # for one float
การอ่านรายการองค์ประกอบที่มีขนาดคงที่
tf.io.FixedLenFeature([N], tf.string) # list of N byte strings
tf.io.FixedLenFeature([N], tf.int64) # list of N ints
tf.io.FixedLenFeature([N], tf.float32) # list of N floats
การอ่านจำนวนตัวแปรของรายการข้อมูล
tf.io.VarLenFeature(tf.string) # list of byte strings
tf.io.VarLenFeature(tf.int64) # list of ints
tf.io.VarLenFeature(tf.float32) # list of floats
VarLenFeature แสดงผลเวกเตอร์บางส่วน และจำเป็นต้องมีขั้นตอนเพิ่มเติมหลังจากถอดรหัส TFRecord ดังนี้
dense_data = tf.sparse.to_dense(tf_record['my_var_len_feature'])
นอกจากนี้ ยังอาจมีช่องที่ไม่บังคับใน TFRecord ด้วย หากคุณระบุค่าเริ่มต้นเมื่ออ่านช่อง ระบบจะแสดงผลค่าเริ่มต้นแทนข้อผิดพลาดหากช่องดังกล่าวขาดหายไป
tf.io.FixedLenFeature([], tf.int64, default_value=0) # this field is optional
หัวข้อที่ครอบคลุม
- 🤔 ชาร์ดดิ้งไฟล์ข้อมูลเพื่อเข้าถึงจาก GCS ได้อย่างรวดเร็ว
- 😓 วิธีเขียน TFRecord (คุณลืมไวยากรณ์แล้วหรือยัง ไม่เป็นไร บุ๊กมาร์กหน้านี้เป็นข้อมูลสรุป)
- 🤔 กำลังโหลดชุดข้อมูลจาก TFRecord โดยใช้ TFRecordDataset
โปรดใช้เวลาสักครู่เพื่อทบทวนรายการตรวจสอบนี้
6 ยินดีด้วย
ตอนนี้คุณสามารถป้อนข้อมูลให้กับ TPU ได้แล้ว โปรดไปยังห้องทดลองถัดไป
- [THIS LAB] ไปป์ไลน์ข้อมูลความเร็ว TPU: tf.data.Dataset และ TFRecords
- โมเดล Keras แรกของคุณที่มีการเรียนรู้การโอน
- โครงข่ายระบบประสาทเทียมแบบ Convolutional ที่มี Keras และ TPU
- Convnets, การบีบ, Xception พร้อม Keras และ TPU
TPU ในทางปฏิบัติ
TPU และ GPU พร้อมใช้งานบน Cloud AI Platform ดังนี้
สุดท้ายนี้ เราให้ความสำคัญกับความคิดเห็น โปรดแจ้งให้เราทราบ หากคุณพบสิ่งที่ควรปรับปรุงในห้องทดลองนี้ หรือคุณคิดว่าเราควรปรับปรุง คุณแสดงความคิดเห็นได้ผ่านปัญหาเกี่ยวกับ GitHub [ feedback link]
|
|
