เกี่ยวกับ Codelab นี้
1 ภาพรวม
ในห้องทดลองนี้ คุณจะได้เรียนรู้วิธีประกอบชั้นคอนโวลูชัน (Convolutional) ให้เป็นโมเดลโครงข่ายระบบประสาทเทียมที่สามารถจดจำดอกไม้ได้ ในคราวนี้ คุณจะได้สร้างโมเดลขึ้นมาเองตั้งแต่ต้นและใช้ความสามารถของ TPU เพื่อฝึกโมเดลภายในไม่กี่วินาทีและต่อยอดการออกแบบใหม่
ห้องปฏิบัติการนี้มีคำอธิบายทางทฤษฎีที่จำเป็นเกี่ยวกับโครงข่ายประสาทแบบคอนโวลูชัน (Convolutional Network) และเป็นจุดเริ่มต้นที่ดีสำหรับนักพัฒนาซอฟต์แวร์ซึ่งได้เรียนรู้เกี่ยวกับการเรียนรู้เชิงลึก
ห้องทดลองนี้เป็นส่วนที่ 3 ของ "Keras บน TPU" ซีรีส์ คุณสามารถดำเนินการตามลำดับต่อไปนี้หรือทำแยกต่างหากก็ได้
- ไปป์ไลน์ข้อมูลความเร็ว TPU: tf.data.Dataset และ TFRecords
- โมเดล Keras แรกของคุณที่มีการเรียนรู้การโอน
- [THIS LAB] โครงข่ายระบบประสาทเทียม Convolutional พร้อมด้วย Keras และ TPU
- Convnets, การบีบ, Xception พร้อม Keras และ TPU
สิ่งที่คุณจะได้เรียนรู้
- เพื่อสร้างตัวแยกประเภทรูปภาพแบบ Convolutional โดยใช้โมเดล Keras Sอีกมากมาย
- วิธีฝึกโมเดล Keras บน TPU
- เพื่อปรับแต่งโมเดลของคุณด้วยตัวเลือกเลเยอร์คอนโวลูชันที่ดี
ความคิดเห็น
โปรดแจ้งให้เราทราบหากพบข้อผิดพลาดใน 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 [INFO] ตัวแยกประเภทโครงข่ายระบบประสาทเทียม 101
สรุป
หากคุณทราบคำศัพท์ทั้งหมดในตัวหนาในย่อหน้าถัดไปแล้ว คุณสามารถย้ายไปยังแบบฝึกหัดถัดไป หากคุณเพิ่งเริ่มต้นในการเรียนรู้เชิงลึก ก็ยินดีและโปรดอ่านต่อไป
สำหรับโมเดลที่สร้างเป็นลำดับของเลเยอร์ Keras จะมี Sสัมผัสประสบการณ์ API ตัวอย่างเช่น ตัวแยกประเภทรูปภาพที่ใช้เลเยอร์แบบหนาแน่น 3 เลเยอร์สามารถเขียนด้วย Keras ดังนี้
model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
tf.keras.layers.Dense(500, activation="relu"),
tf.keras.layers.Dense(50, activation="relu"),
tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])
# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy']) # % of correct answers
# train the model
model.fit(dataset, ... )
โครงข่ายประสาทแบบหนาแน่น
นี่คือโครงข่ายระบบประสาทเทียมที่ง่ายที่สุดในการจัดประเภทรูปภาพ สร้างจาก "เซลล์ประสาท" จัดเรียงเป็นเลเยอร์ต่างๆ เลเยอร์แรกจะประมวลผลข้อมูลอินพุตและป้อนเอาต์พุตลงในเลเยอร์อื่นๆ เรียกว่า "หนาแน่น" เพราะเซลล์ประสาทแต่ละเซลล์เชื่อมต่อกับเซลล์ประสาททั้งหมดในชั้นก่อนหน้า
คุณสามารถนำภาพไปไว้ในเครือข่ายดังกล่าวได้โดยการปรับค่า RGB ของพิกเซลทั้งหมดให้เป็นเวกเตอร์แบบยาวและใช้เป็นอินพุต ไม่ใช่เทคนิคที่ดีที่สุดสำหรับการจดจำรูปภาพ แต่เราจะปรับปรุงในภายหลัง
ประสาท, การเปิดใช้งาน, RELU
"เซลล์ประสาท" คำนวณผลรวมถ่วงน้ำหนักของอินพุตทั้งหมด แล้วเพิ่มค่าที่เรียกว่า "อคติ" และป้อนผลลัพธ์ผ่านวิธีการที่เรียกว่า "ฟังก์ชันการเปิดใช้งาน" คุณจะไม่ทราบน้ำหนักและความเอนเอียงดังกล่าวในตอนแรก เขาเริ่มจากการสุ่มและ "เรียนรู้" โดยการฝึกโครงข่ายระบบประสาทเทียมกับข้อมูลที่รู้จักจำนวนมาก
ฟังก์ชันเปิดใช้งานที่ได้รับความนิยมสูงสุดเรียกว่า RELU สำหรับหน่วยเชิงเส้นแบบ Rectified Linear ซึ่งเป็นฟังก์ชันที่เรียบง่ายมากตามที่คุณเห็นบนกราฟด้านบน
การเปิดใช้งาน Softmax
เครือข่ายด้านบนลงท้ายด้วยชั้นเซลล์ 5 เซลล์ เนื่องจากเราจำแนกดอกไม้เป็น 5 หมวดหมู่ (กุหลาบ ทิวลิป แดนดิไลออน เดซี่ ดอกทานตะวัน) เซลล์ประสาทในชั้นกลางเปิดใช้งานโดยใช้ฟังก์ชันการเปิดใช้งาน RELU แบบดั้งเดิม แต่ในชั้นสุดท้าย เราต้องการคำนวณจำนวนระหว่าง 0 ถึง 1 ซึ่งแสดงถึงความน่าจะเป็นของดอกกุหลาบ ดอกทิวลิป และอื่นๆ สำหรับกรณีนี้ เราจะใช้ฟังก์ชันเปิดใช้งานที่ชื่อ "softmax"
การใช้ซอฟต์แมกซ์กับเวกเตอร์ทำได้โดยนำเลขชี้กำลังของแต่ละองค์ประกอบมาทำให้เวกเตอร์เป็นมาตรฐาน โดยทั่วไปจะใช้บรรทัดฐาน L1 (ผลรวมของค่าสัมบูรณ์) เพื่อให้ค่าบวกกันถึง 1 และตีความค่าเป็นความน่าจะเป็นได้
การสูญเสียครอสเอนโทรปี
ตอนนี้ที่โครงข่ายประสาทของเราสร้างการคาดคะเนจากรูปภาพอินพุต เราจึงต้องวัดว่ารูปภาพนั้นมีคุณภาพดีเพียงใด เช่น ระยะห่างระหว่างสิ่งที่เครือข่ายแจ้งเรากับคำตอบที่ถูกต้อง ซึ่งมักเรียกว่า "ป้ายกำกับ" อย่าลืมว่าเรามีป้ายกำกับที่ถูกต้องสำหรับรูปภาพทั้งหมดในชุดข้อมูล
สามารถใช้ระยะทางเท่าใดก็ได้ แต่สำหรับปัญหาการจำแนกประเภท สิ่งที่เรียกว่า "ระยะทางแบบครอสเอนโทรปี" มีประสิทธิภาพมากที่สุด เราจะเรียกสิ่งนี้ว่า "ความผิดพลาด" หรือ "Loss" ฟังก์ชัน:
การไล่ระดับสี
"การฝึก" โครงข่ายประสาทหมายถึงการใช้ภาพและป้ายกำกับการฝึกเพื่อปรับน้ำหนักและน้ำหนัก เพื่อลดฟังก์ชันการสูญเสียครอสเอนโทรปี วิธีการทำงานมีดังนี้
ครอสเอนโทรปีเป็นฟังก์ชันของน้ำหนัก การให้น้ำหนักพิเศษ พิกเซลของรูปภาพที่ใช้ในการฝึก และคลาสที่รู้จัก
หากเราคำนวณอนุพันธ์ย่อยของครอสเอนโทรปีที่เกี่ยวข้องกับน้ำหนักทั้งหมดและความลำเอียงทั้งหมด เราได้รับ "การไล่ระดับสี" มาคำนวณสำหรับรูปภาพ ป้ายกำกับ และค่าปัจจุบันของน้ำหนักและความลำเอียง โปรดจำไว้ว่าเรามีน้ำหนักและอคติได้หลายล้านรายการ ดังนั้นการคำนวณการไล่ระดับสีจะเป็นงานหนัก โชคดีที่ Tensorflow ดำเนินการแทนเรา คุณสมบัติทางคณิตศาสตร์ของการไล่ระดับสีคือการชี้ "ขึ้น" เนื่องจากเราต้องการไปยังจุดที่ครอสเอนโทรปีต่ำ เราจึงไปในทิศทางตรงกันข้าม เราอัปเดตน้ำหนักและความเอนเอียงตามเศษส่วนของการไล่ระดับสี จากนั้น เราจะทำสิ่งเดียวกันนี้ซ้ำแล้วซ้ำอีกโดยใช้อิมเมจและป้ายกำกับการฝึกชุดถัดไป ในลูปการฝึก หวังว่าจุดนี้จะบรรจบกันในบริเวณที่การครอสเอนโทรปีมีเพียงเล็กน้อย แต่ก็ไม่มีอะไรรับประกันว่าค่าขั้นต่ำนี้จะไม่ซ้ำกัน
แบบมินิแบตช์และโมเมนตัม
คุณสามารถคํานวณการไล่ระดับสีในรูปภาพตัวอย่างเพียงภาพเดียวและอัปเดตน้ำหนักและน้ำหนักค่าต่างๆ ได้ทันที แต่การไล่ระดับสี เช่น รูปภาพ 128 ภาพจะให้การไล่ระดับสีที่แสดงถึงข้อจำกัดที่กำหนดโดยรูปภาพตัวอย่างที่แตกต่างกันได้ดีกว่า และมีแนวโน้มที่จะบรรจบกันได้ดีกว่า ขนาดของมินิแบตช์เป็นพารามิเตอร์ที่ปรับได้
เทคนิคนี้ ซึ่งบางครั้งเรียกว่า "การไล่ระดับสีแบบสโตแคติก" มีประโยชน์ในทางปฏิบัติมากกว่าอีกข้อหนึ่ง คือการทำงานแบบกลุ่มยังหมายถึงการทำงานกับเมทริกซ์ขนาดใหญ่ และมักจะเพิ่มประสิทธิภาพให้กับ GPU และ TPU ได้ง่ายกว่า
การบรรจบกันอาจยังค่อนข้างยุ่งเหยิง และสามารถหยุดได้ถ้าเวกเตอร์การไล่ระดับสีเป็นเลข 0 ทั้งหมด หมายความว่าเราพบคะแนนขั้นต่ำแล้วใช่ไหม ไม่ได้เสมอไป คอมโพเนนต์การไล่ระดับสีอาจมีค่าต่ำสุดหรือสูงสุดเป็น 0 ได้ ด้วยเวกเตอร์การไล่ระดับสีที่มีองค์ประกอบนับล้าน ถ้าเป็นศูนย์ทั้งหมด ความน่าจะเป็นที่ทุกศูนย์จะสัมพันธ์กับค่าต่ำสุด และไม่มีองค์ประกอบใดถึงจุดสูงสุดค่อนข้างเล็ก ในพื้นที่ที่มีมิติหลากหลาย จุดหลักมักจะใช้กันทั่วไปและเราไม่อยากหยุดแค่จุดนั้น
ภาพประกอบ: จุดตัด การไล่ระดับสีมีค่า 0 แต่ไม่ได้มีค่าต่ำสุดในทุกทิศทาง (การระบุแหล่งที่มาของรูปภาพ Wikimedia: โดย Nicoguaro - ผลงานของตัวเอง CC BY 3.0)
วิธีแก้ไขคือให้เพิ่มแรงขับเคลื่อนบางส่วนให้อัลกอริทึมการเพิ่มประสิทธิภาพเพื่อให้แล่นผ่านจุดอานม้าได้โดยไม่หยุด
อภิธานศัพท์
กลุ่มหรือกลุ่มขนาดเล็ก: การฝึกจะดำเนินการกับกลุ่มของข้อมูลและป้ายกำกับการฝึกเสมอ ซึ่งจะช่วยให้อัลกอริทึมบรรจบกัน "กลุ่ม" ตามปกติแล้วเป็นมิติข้อมูลแรกของ Tensor ข้อมูล เช่น Tensor ของรูปร่าง [100, 192, 192, 3] จะมีภาพขนาด 192x192 พิกเซล 100 ภาพที่มี 3 ค่าต่อพิกเซล (RGB)
การสูญเสียการครอสเอนโทรปี: ฟังก์ชันการสูญเสียพิเศษที่มักใช้ในตัวแยกประเภท
ชั้นที่หนาแน่น: ชั้นของเซลล์ประสาทที่เซลล์ประสาทแต่ละเซลล์เชื่อมต่อกับเซลล์ประสาททั้งหมดในชั้นก่อนหน้านี้
features: อินพุตของโครงข่ายประสาทบางครั้งเรียกว่า "ฟีเจอร์" ศิลปะในการพิจารณาว่าส่วนใดของชุดข้อมูล (หรือการรวมส่วนต่างๆ) ที่จะป้อนลงในโครงข่ายระบบประสาทเทียมเพื่อรับการคาดการณ์ที่ดีเรียกว่า "Feature Engineering"
labels: อีกชื่อหนึ่งของ "ชั้นเรียน" หรือคำตอบที่ถูกต้องในโจทย์การจัดประเภทภายใต้การควบคุมดูแล
อัตราการเรียนรู้: เศษส่วนของการไล่ระดับสีที่มีการอัปเดตน้ำหนักและน้ำหนักพิเศษในแต่ละการวนซ้ำการฝึก
logits: เอาต์พุตของชั้นเซลล์ก่อนใช้ฟังก์ชันการเปิดใช้งานเรียกว่า "logits" คำนี้มาจาก "ฟังก์ชันโลจิสติก" หรือที่เรียกว่า "ฟังก์ชัน Sigmoid" ซึ่งเคยเป็นฟังก์ชันเปิดใช้งานที่ได้รับความนิยมสูงสุด "เอาต์พุตของประสาทก่อนฟังก์ชันโลจิสติกส์" ถูกย่อเป็น "logits"
loss: ฟังก์ชันข้อผิดพลาดที่เปรียบเทียบเอาต์พุตของโครงข่ายระบบประสาทเทียมกับคำตอบที่ถูกต้อง
เซลล์ประสาท: คำนวณผลรวมถ่วงน้ำหนักของอินพุต จะเพิ่มการให้น้ำหนักพิเศษ และป้อนผลลัพธ์ผ่านฟังก์ชันการเปิดใช้งาน
การเข้ารหัสแบบ One-Hot: คลาส 3 จาก 5 ได้รับการเข้ารหัสเป็นเวกเตอร์ขององค์ประกอบ 5 โดยค่า 0 ทั้งหมดยกเว้นค่าตัวที่ 3 ซึ่งก็คือ 1
relu: หน่วยเชิงเส้นที่แก้ไขแล้ว ฟังก์ชันการเปิดใช้งานยอดนิยมสำหรับเซลล์ประสาท
sigmoid: ฟังก์ชันเปิดใช้งานอีกอย่างที่เคยได้รับความนิยมและยังคงมีประโยชน์ในกรณีพิเศษ
softmax: ฟังก์ชันเปิดใช้งานพิเศษที่ดำเนินการกับเวกเตอร์ เพิ่มความแตกต่างระหว่างส่วนประกอบที่ใหญ่ที่สุดกับองค์ประกอบอื่นๆ ทั้งหมด และยังทำให้เวกเตอร์เป็นมาตรฐานเพื่อให้ได้ผลรวมของ 1 เพื่อให้สามารถตีความว่าเป็นเวกเตอร์ของความน่าจะเป็น ใช้เป็นขั้นตอนสุดท้ายในตัวแยกประเภท
tensor: A "tensor" คล้ายกับเมทริกซ์ แต่มีจำนวนมิติข้อมูลที่กำหนดเอง tensor 1 มิติคือเวกเตอร์ Tensor 2 มิติคือเมทริกซ์ และจากนั้นคุณสามารถมี Tensor ที่มีมิติข้อมูล 3, 4, 5 หรือมากกว่าได้
5 [ข้อมูลใหม่] โครงข่ายระบบประสาทเทียมแบบ Convolutional
สรุป
หากคุณทราบคำศัพท์ทั้งหมดในตัวหนาในย่อหน้าถัดไปแล้ว คุณสามารถย้ายไปยังแบบฝึกหัดถัดไป หากคุณเพิ่งเริ่มใช้โครงข่ายประสาทแบบคอนโวลูชัน (Convolutional Network) โปรดอ่านต่อ
ภาพประกอบ: การกรองรูปภาพด้วยฟิลเตอร์ต่อเนื่อง 2 รายการซึ่งมีน้ำหนัก 4x4x3=48 ที่เรียนรู้ได้ แต่ละตัวกรอง
นี่คือลักษณะของโครงข่ายประสาทแบบคอนโวลูชัน (Convolutional) แบบง่ายๆ ใน Keras
model = tf.keras.Sequential([
# input: images of size 192x192x3 pixels (the three stands for RGB channels)
tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
tf.keras.layers.Flatten(),
# classifying into 5 categories
tf.keras.layers.Dense(5, activation='softmax')
])
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy'])
โครงข่ายประสาทแบบ Convolutional 101
ในเลเยอร์ของเครือข่ายคอนโวลูชัน (Convolutional Network) จะมี "เซลล์ประสาท" 1 เซลล์ เป็นผลรวมถ่วงน้ำหนักของพิกเซลที่อยู่ด้านบนในพื้นที่เล็กๆ ของภาพเท่านั้น เซลล์นี้จะเพิ่มการให้น้ำหนักพิเศษและป้อนผลรวมผ่านฟังก์ชันเปิดใช้งาน เช่นเดียวกับที่เซลล์ประสาทในชั้นที่หนาแน่นปกติสามารถทำ การดำเนินการนี้จะทำซ้ำในทั้งรูปภาพโดยใช้น้ำหนักเดียวกัน อย่าลืมว่าในชั้นที่หนาแน่น เซลล์ประสาทแต่ละเซลล์มีน้ำหนักของตัวเอง ตรงนี้ เรามี "การแก้ไข" เพียงครั้งเดียว ของน้ำหนักที่เลื่อนผ่านภาพทั้ง 2 ทิศทาง ("Conversion") เอาต์พุตจะมีค่าเท่ากับจำนวนพิกเซลในรูปภาพ (แต่ต้องมีระยะห่างจากขอบบางจุด) เป็นการดำเนินการกรองโดยใช้ตัวกรองน้ำหนัก 4x4x3=48
อย่างไรก็ตาม น้ำหนัก 48 อาจไม่เพียงพอ หากต้องการเพิ่มองศาอิสระ เราจะดำเนินการซ้ำเดิมด้วยน้ำหนักชุดใหม่ ซึ่งจะสร้างเอาต์พุตตัวกรองชุดใหม่ ขอเรียกว่า "ช่อง" ของเอาต์พุตโดยการเปรียบเทียบกับช่อง R,G,B ในภาพอินพุต
น้ำหนักสองชุด (หรือมากกว่านั้น) สามารถสรุปเป็น 1 เซนเซอร์ได้โดยการเพิ่มมิติข้อมูลใหม่ ซึ่งทำให้เรามีรูปทรงทั่วไปของ Tensor น้ำหนักสำหรับชั้นคอนโวลูชัน (Convolutional) เนื่องจากจำนวนของแชแนลอินพุตและเอาต์พุตเป็นพารามิเตอร์ เราจึงสามารถเริ่มซ้อนและเชื่อมโยงเลเยอร์คอนโวลูชัน (Convolutional) ได้
ภาพ: โครงข่ายประสาทแบบคอนโวลูชัน (Convolutional) เปลี่ยนรูปแบบ "ลูกบาศก์" ของข้อมูลลงใน "ลูกบาศก์" อื่นๆ อีกด้วย
คอนโวลูชันแบบมีโครงสร้าง การรวมกันสูงสุด
การทำ Conversion ด้วยระยะก้าว 2 หรือ 3 ช่วยให้เราย่อลูกบาศก์ข้อมูลที่ได้ให้อยู่ในขนาดแนวนอนได้ วิธีทั่วไปมี 2 วิธีดังนี้
- Strided Convolution: ตัวกรองแบบเลื่อนตามด้านบนแต่มีระยะก้าว >1
- การรวมกลุ่มสูงสุด: หน้าต่างเลื่อนที่ใช้การดำเนินการ MAX (โดยปกติจะเป็นแพตช์ 2x2 ทำซ้ำทุก 2 พิกเซล)
ภาพ: การเลื่อนหน้าต่างการประมวลผลทีละ 3 พิกเซลจะทำให้ค่าเอาต์พุตลดลง Convolution ระยะก้าวหรือการรวมกันสูงสุด (สูงสุดในการเลื่อนหน้าต่างขนาด 2x2 ด้วยระยะก้าวที่ 2) เป็นวิธีย่อลูกบาศก์ข้อมูลในขนาดแนวนอน
ตัวแยกประเภทเชิงปฏิสัมพันธ์
สุดท้าย เราแนบส่วนหัวการแยกประเภทโดยทำให้ลูกบาศก์ข้อมูลสุดท้ายแบนแล้วป้อนผ่านเลเยอร์ที่เปิดใช้งาน Softmax อย่างหนาแน่น ตัวแยกประเภทแบบ Convolutional โดยทั่วไปจะมีลักษณะดังนี้
ภาพ: ตัวแยกประเภทรูปภาพที่ใช้เลเยอร์ Convolutional และ softmax ใช้ตัวกรอง 3x3 และ 1x1 โดยเลเยอร์สูงสุดคือกลุ่มจุดข้อมูลขนาด 2x2 ส่วนหัวการแยกประเภทมีการใช้งานด้วยเลเยอร์ที่หนาแน่นที่มีการเปิดใช้งาน Softmax
ใน Keras
สแต็ก Convolutional ที่แสดงด้านบนสามารถเขียนด้วยภาษา Keras ดังนี้
model = tf.keras.Sequential([
# input: images of size 192x192x3 pixels (the three stands for RGB channels)
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
tf.keras.layers.Flatten(),
# classifying into 5 categories
tf.keras.layers.Dense(5, activation='softmax')
])
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy'])
6 Convnet ที่กําหนดเอง
การลงมือปฏิบัติ
ให้เราสร้างและฝึกโครงข่ายประสาทแบบ Convolutional ตั้งแต่เริ่มต้น การใช้ TPU จะช่วยให้เราปรับปรุงได้เร็วขึ้น โปรดเปิดสมุดบันทึกต่อไปนี้ เรียกใช้เซลล์ (Shift-ENTER) และทำตามคำแนะนำที่เห็นข้อความ "ต้องดำเนินการ" ป้ายกำกับ
Keras_Flowers_TPU (playground).ipynb
เป้าหมายคือการเอาชนะความแม่นยำ 75% ของโมเดลการเรียนรู้การโอน โมเดลนี้มีข้อดีคือได้รับการฝึกล่วงหน้าด้วยชุดข้อมูลของรูปภาพหลายล้านรูป แต่ที่นี่เรามีรูปภาพเพียง 3, 670 รูป อย่างน้อยคุณจับคู่ได้ไหม
ข้อมูลเพิ่มเติม
มีกี่เลเยอร์ ใหญ่แค่ไหน
การเลือกขนาดเลเยอร์เป็นมากกว่าศิลปะ คุณต้องหาจุดสมดุลระหว่างการมีพารามิเตอร์ที่น้อยเกินไปหรือมากเกินไป (น้ำหนักและความลำเอียง) ด้วยน้ำหนักที่น้อยเกินไป โครงข่ายประสาทจะแสดงความซับซ้อนของรูปทรงดอกไม้ไม่ได้ หากมีจำนวนมากเกินไป ก็มีแนวโน้มที่จะ "ทำงานเกินความจำเป็น" ได้ เช่น เชี่ยวชาญด้านรูปภาพที่ใช้ฝึกและสรุปข้อมูลทั่วไปไม่ได้ หากมีพารามิเตอร์จำนวนมาก โมเดลก็จะฝึกได้ช้าด้วย ใน Keras ฟังก์ชัน model.summary() จะแสดงจำนวนโครงสร้างและจำนวนพารามิเตอร์ของโมเดลของคุณ ดังนี้
Layer (type) Output Shape Param #
=================================================================
conv2d (Conv2D) (None, 192, 192, 16) 448
_________________________________________________________________
conv2d_1 (Conv2D) (None, 192, 192, 30) 4350
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 96, 96, 30) 0
_________________________________________________________________
conv2d_2 (Conv2D) (None, 96, 96, 60) 16260
_________________________________________________________________
...
_________________________________________________________________
global_average_pooling2d (Gl (None, 130) 0
_________________________________________________________________
dense (Dense) (None, 90) 11790
_________________________________________________________________
dense_1 (Dense) (None, 5) 455
=================================================================
Total params: 300,033
Trainable params: 300,033
Non-trainable params: 0
_________________________________________________________________
เคล็ดลับ 2 ข้อมีดังนี้
- การมีเลเยอร์หลายชั้นทำให้ "ดูลึก" โครงข่ายประสาทที่มีประสิทธิภาพ สำหรับปัญหาการจดจำดอกไม้ง่ายๆ นี้ ควรใช้ 5 ถึง 10 เลเยอร์ซึ่งเหมาะสมที่สุด
- ใช้ตัวกรองขนาดเล็ก ปกติแล้วตัวกรอง 3x3 จะใช้ได้ในทุกที่
- ฟิลเตอร์ 1x1 ก็ใช้ได้เช่นกันและมีราคาถูก แต่ไม่ได้ "กรอง" จริงๆ ยกเว้นการคำนวณ การผสมแชแนลเชิงเส้น สลับผู้ชมด้วยฟิลเตอร์จริง (ดูข้อมูลเพิ่มเติมเกี่ยวกับ "Convolutions 1x1" ได้ในส่วนถัดไป)
- สำหรับปัญหาการจัดประเภทเช่นนี้ การลดลงของตัวอย่างมักมีเลเยอร์พูลสูงสุด (หรือคอนโวลูชันที่มีระยะก้าว >1) คุณไม่จำเป็นต้องสนใจว่าดอกไม้อยู่ตรงไหน เพียงแค่เป็นดอกกุหลาบหรือดอกแดนดิไลออน การสูญเสียข้อมูล x และ y ก็ไม่สำคัญ และการกรองพื้นที่เล็กๆ จะมีราคาถูกกว่า
- โดยทั่วไปจำนวนตัวกรองจะใกล้เคียงกับจำนวนคลาสเมื่อสิ้นสุดเครือข่าย (เพราะเหตุใด ลองดูเคล็ดลับ "การรวมค่าเฉลี่ยทั่วโลก" ด้านล่าง) หากคุณแยกประเภทเป็นหลายร้อยคลาส ให้เพิ่มจำนวนตัวกรองทีละน้อยในเลเยอร์ที่ต่อเนื่องกัน สำหรับชุดข้อมูลดอกไม้ที่มี 5 คลาส การกรองด้วยตัวกรองเพียง 5 รายการจึงไม่เพียงพอ คุณสามารถใช้จำนวนตัวกรองเดียวกันในเลเยอร์ส่วนใหญ่ เช่น 32 และลดจำนวนเลเยอร์ลงในตอนท้าย
- ชั้นที่หนาแน่นสุดท้ายมีราคาแพง อาจมีน้ำหนักมากกว่าชั้นคอนโวลูชัน (Convolutional) ทั้งหมดรวมกัน ตัวอย่างเช่น แม้ว่าจะมีผลลัพธ์ที่สมเหตุสมผลมากจากจุดข้อมูลขนาด 24x24x10 รายการสุดท้าย แต่เลเยอร์ความหนาแน่นของเซลล์ประสาท 100 เลเยอร์จะมีค่าใช้จ่าย 24x24x10x100=น้ำหนัก 576,000 !!! โปรดใช้ความรอบคอบ หรือลองรวบรวมข้อมูลเฉลี่ยทั่วโลก (ดูด้านล่าง)
การรวมเฉลี่ยทั่วโลก
คุณสามารถแยก "ลูกบาศก์" ของข้อมูลที่เข้ามาใหม่ แทนที่จะใช้ชั้นที่มีความหนาแน่นราคาแพงที่ตอนท้ายของโครงข่ายระบบประสาทเทียมแบบ Convolutional แบ่งเป็นส่วนต่างๆ ตามคลาสที่คุณมี หาค่าเฉลี่ยและค่าฟีดเหล่านี้ด้วยฟังก์ชันการเปิดใช้งาน softmax วิธีสร้างส่วนหัวการแยกประเภทในลักษณะนี้จะมีน้ำหนักเป็น 0 ใน Keras ไวยากรณ์คือ tf.keras.layers.GlobalAveragePooling2D().
โซลูชัน
นี่คือสมุดบันทึกโซลูชัน คุณสามารถใช้รหัสผ่านนี้ได้หากติดขัด
Keras_Flowers_TPU (solution).ipynb
หัวข้อที่ครอบคลุม
- 🤔 เล่นกับเลเยอร์คอนโวลูชัน (Convolutional)
- 🤓 ทดสอบกับการรวมกลุ่มสูงสุด ก้าวเดิน การรวมกลุ่มค่าเฉลี่ยทั่วโลก ...
- 😀 ทำซ้ำบนโมเดลในชีวิตจริงได้อย่างรวดเร็วบน TPU
โปรดใช้เวลาสักครู่เพื่อทบทวนรายการตรวจสอบนี้
7 ยินดีด้วย
คุณได้สร้างโครงข่ายระบบประสาทเทียมแบบคอนโวลูชัน (Convolutional) ที่ทันสมัยแห่งแรกและฝึกให้เครือข่ายมีความแม่นยำมากกว่า 80% โดยสามารถปรับปรุงสถาปัตยกรรมได้ในเวลาไม่กี่นาทีด้วย TPU โปรดไปยังห้องทดลองถัดไปเพื่อดูข้อมูลเกี่ยวกับสถาปัตยกรรมแบบคอนโวลูชันสมัยใหม่ (Convolutional)
- ไปป์ไลน์ข้อมูลความเร็ว TPU: tf.data.Dataset และ TFRecords
- โมเดล Keras แรกของคุณที่มีการเรียนรู้การโอน
- [THIS LAB] โครงข่ายระบบประสาทเทียม Convolutional พร้อมด้วย Keras และ TPU
- Convnets, การบีบ, Xception พร้อม Keras และ TPU
TPU ในทางปฏิบัติ
TPU และ GPU พร้อมใช้งานบน Cloud AI Platform ดังนี้
สุดท้ายนี้ เราให้ความสำคัญกับความคิดเห็น โปรดแจ้งให้เราทราบ หากคุณพบสิ่งที่ควรปรับปรุงในห้องทดลองนี้ หรือคุณคิดว่าเราควรปรับปรุง คุณแสดงความคิดเห็นได้ผ่านปัญหาเกี่ยวกับ GitHub [ feedback link]
|
