เกี่ยวกับ 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
- เพื่อปรับแต่งโมเดลด้วยการเลือกชั้น Conv ที่เหมาะ
ความคิดเห็น
โปรดแจ้งให้เราทราบหากพบข้อผิดพลาดใน Code Lab นี้ คุณสามารถแสดงความคิดเห็นผ่านปัญหาใน GitHub [ลิงก์ความคิดเห็น]
2 คู่มือเริ่มต้นใช้งานฉบับย่อของ Google Colaboratory
ห้องทดลองนี้ใช้ Google Collaboratory และคุณไม่จำเป็นต้องตั้งค่าใดๆ Colaboratory เป็นแพลตฟอร์มสมุดบันทึกออนไลน์สำหรับวัตถุประสงค์ด้านการศึกษา โดยมีการฝึกอบรม CPU, GPU และ TPU ฟรี
คุณเปิดสมุดบันทึกตัวอย่างนี้แล้ววิ่งผ่านเซลล์ 2-3 เซลล์เพื่อทำความคุ้นเคยกับ Colaboratory ได้
เลือกแบ็กเอนด์ TPU
ในเมนู Colab ให้เลือกรันไทม์ > เปลี่ยนประเภทรันไทม์ แล้วเลือก TPU ในโปรแกรมแก้ไขโค้ดนี้ คุณจะใช้ TPU (Tensor Processing Unit) ที่มีประสิทธิภาพซึ่งรองรับการฝึกด้วยฮาร์ดแวร์ที่เร่งความเร็ว การเชื่อมต่อกับรันไทม์จะเกิดขึ้นโดยอัตโนมัติเมื่อเรียกใช้ครั้งแรก หรือคุณจะใช้ปุ่ม "เชื่อมต่อ" ที่มุมขวาบนก็ได้
การดำเนินการกับสมุดบันทึก
เรียกใช้เซลล์ทีละรายการโดยคลิกที่เซลล์และใช้แป้น Shift-ENTER นอกจากนี้ คุณยังเรียกใช้ทั้งสมุดบันทึกได้ด้วย รันไทม์ > เรียกใช้ทั้งหมด
สารบัญ
สมุดบันทึกทั้งหมดมีสารบัญ คุณสามารถเปิดได้โดยใช้ลูกศรสีดำทางด้านซ้าย
เซลล์ที่ซ่อนอยู่
บางเซลล์จะแสดงเฉพาะชื่อเท่านั้น ฟีเจอร์นี้เป็นฟีเจอร์สำหรับสมุดบันทึกของ Colab โดยเฉพาะ คุณสามารถดับเบิลคลิกเพื่อดูโค้ดภายในได้ แต่โดยปกติแล้วโค้ดดังกล่าวไม่น่าตื่นเต้นมากนัก โดยทั่วไปจะรองรับหรือแสดงฟังก์ชันภาพ คุณยังต้องเรียกใช้เซลล์เหล่านี้เพื่อให้มีการกำหนดฟังก์ชันภายในเซลล์
การตรวจสอบสิทธิ์
Colab สามารถเข้าถึงที่เก็บข้อมูล Google Cloud Storage ส่วนตัวได้หากคุณตรวจสอบสิทธิ์ด้วยบัญชีที่ได้รับอนุญาต ข้อมูลโค้ดด้านบนจะทริกเกอร์ขั้นตอนการตรวจสอบสิทธิ์
3 [INFO] Tensor Compute 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 ชุดที่ประมวลผลผ่านโครงข่ายประสาทเทียมพร้อมกัน โปรดทำการคำนวณแบบคูณแถว x คอลัมน์ 1 รายการเพื่อยืนยันว่ากำลังทำผลรวมถ่วงน้ำหนักของค่าพิกเซลทั้งหมดของรูปภาพ เลเยอร์ Conv แสดงเป็นการคูณเมทริกซ์ได้ด้วย แม้ว่าจะซับซ้อนกว่าเล็กน้อย (ดูคำอธิบายที่นี่ในส่วนที่ 1)
ฮาร์ดแวร์
MXU และ VPU
แกน TPU v2 สร้างขึ้นจาก Matrix Multiply Unit (MXU) ซึ่งเรียกใช้การคูณเมทริกซ์ และ Vectorประมวลผลข้อมูล Unit (VPU) สำหรับงานอื่นๆ ทั้งหมด เช่น การเปิดใช้งาน, softmax เป็นต้น VPU จะจัดการการคำนวณ Float 32 และ int32 ส่วน MXU จะทำงานในรูปแบบจุดลอยตัว 16-32 บิตที่มีความแม่นยำแบบผสม
ผสมจุดทศนิยมที่มีความแม่นยำและ bFloat 16
MXU จะคำนวณการคูณเมทริกซ์โดยใช้อินพุต bfloat16 และเอาต์พุต Float32 การเก็บสะสมขั้นกลางจะเกิดขึ้นด้วยความแม่นยำ Float 32
โดยทั่วไปการฝึกโครงข่ายระบบประสาทเทียมจะต้านเสียงที่เกิดจากความแม่นยำของจุดลอยตัวที่ลดลง แต่ก็มีบางกรณีที่เสียงรบกวนช่วยให้เครื่องมือเพิ่มประสิทธิภาพเชื่อมต่อกันได้ โดยทั่วไปแล้วความแม่นยำของทศนิยม 16 บิตจะใช้เพื่อเร่งการคำนวณ แต่รูปแบบ float16 และ float32 มีช่วงที่แตกต่างกันมาก การลดความแม่นยำจาก Float32 เป็น Float 16 มักจะทำให้เกิดการไหลเกินหรือต่ำกว่าที่ควรจะเป็น ปัญหานี้แก้ไขได้ แต่โดยทั่วไปแล้วจะต้องดำเนินการเพิ่มเติมเพื่อให้ float16 ทำงานได้
ด้วยเหตุนี้ Google จึงเปิดตัวรูปแบบ bfloat16 ใน TPU โดย bfloat16 คือ float32 ที่ตัดทอนซึ่งมีบิตและช่วงของเลขชี้กำลังเหมือนกับ float32 ทุกประการ ด้วยเหตุนี้และเนื่องจาก TPU คำนวณการคูณเมทริกซ์ด้วยความแม่นยำแบบผสมโดยใช้อินพุต bfloat16 แต่เอาต์พุตเป็น float32 โดยทั่วไปแล้วคุณจึงไม่จำเป็นต้องเปลี่ยนแปลงโค้ดเพื่อรับประโยชน์จากประสิทธิภาพที่เพิ่มขึ้นจากการลดความแม่นยำ
อาร์เรย์แบบซิสโตลิก
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=16,000 ซึ่งโดยทั่วไปแล้วไม่สามารถทำได้ GPU ที่ใหญ่ที่สุดมีแกนประมาณ 4,000 แกน ในทางกลับกัน TPU ใช้ฮาร์ดแวร์ขั้นต่ำสำหรับหน่วยประมวลผลใน MXU ซึ่งก็คือตัวคูณสะสม bfloat16 x bfloat16 => float32 เท่านั้น หน่วยเหล่านี้มีขนาดเล็กมากจน TPU ติดตั้งใช้งานได้ 16,000 ตัวใน MXU ขนาด 128x128 และประมวลผลการดำเนินการคูณเมทริกซ์นี้พร้อมกันได้
ภาพ: อาร์เรย์แบบซิสโตลิคของ MXU องค์ประกอบที่ใช้คำนวณคือตัวคูณสะสม ระบบจะโหลดค่าของเมทริกซ์ 1 รายการเข้าไปในอาร์เรย์ (จุดสีแดง) ค่าของเมทริกซ์อื่นจะไหลผ่านอาร์เรย์ (จุดสีเทา) เส้นแนวตั้งจะแสดงค่าขึ้น เส้นแนวนอนจะแสดงผลรวมของบางส่วน ผู้ใช้ต้องตรวจสอบว่าเมื่อข้อมูลไหลผ่านอาร์เรย์แล้ว คุณจะได้รับผลลัพธ์ของการคูณเมทริกซ์จากด้านขวา
นอกจากนี้ ขณะที่ระบบกำลังคํานวณผลคูณแบบดอทใน MXU ผลรวมขั้นกลางจะไหลเวียนระหว่างหน่วยประมวลผลที่อยู่ติดกัน คุณไม่จำเป็นต้องเก็บและเรียกข้อมูลไปยัง/จากหน่วยความจำ หรือแม้แต่ไฟล์การลงทะเบียน ผลลัพธ์ที่ได้คือสถาปัตยกรรมอาร์เรย์แบบ Systolic ของ TPU มีข้อได้เปรียบด้านความหนาแน่นและกำลังไฟอย่างมาก รวมถึงข้อได้เปรียบด้านความเร็วที่ไม่ควรมองข้ามเมื่อเทียบกับ GPU เมื่อคำนวณการคูณเมทริกซ์
Cloud TPU
เมื่อขอ "Cloud TPU v2" 1 เครื่องใน Google Cloud Platform คุณจะได้รับเครื่องเสมือน (VM) ที่มีบอร์ด TPU ที่ต่อกับ PCI กระดาน TPU มีชิป TPU แบบ Dual-core 4 ชิป แต่ละแกน TPU มี VPU (หน่วยประมวลผลเวกเตอร์) และ MXU (หน่วยการคูณเมทริกซ์) ขนาด 128x128 จากนั้น "Cloud TPU" นี้จะเชื่อมต่อกับ VM ที่ขอผ่านเครือข่าย ภาพรวมทั้งหมดจะมีลักษณะดังนี้
ภาพประกอบ: VM ที่มีตัวเร่ง "Cloud TPU" ที่เชื่อมต่อเครือข่าย "Cloud TPU" ประกอบด้วย VM ที่มีบอร์ด TPU ที่ต่อกับ PCI ซึ่งมีชิป TPU แบบ Dual-Core 4 ตัว
พ็อด TPU
ในศูนย์ข้อมูลของ Google TPU จะเชื่อมต่อกับการเชื่อมต่อระหว่างการประมวลผลประสิทธิภาพสูง (HPC) ซึ่งทำให้ดูเหมือนเป็นอุปกรณ์เร่งความเร็วขนาดใหญ่เครื่องเดียว 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 กลุ่มโดยอัตโนมัติและเรียกใช้บน TPU 8 คอร์
ดูเคล็ดลับเพิ่มเติมเกี่ยวกับประสิทธิภาพได้ที่คู่มือประสิทธิภาพ TPU สำหรับกลุ่มที่มีขนาดใหญ่มาก บางโมเดลอาจต้องใช้ความระมัดระวังเป็นพิเศษ โปรดดูรายละเอียดเพิ่มเติมใน LARSOptimizer
กลไกภายใน: XLA
โปรแกรม Tensorflow จะกำหนดกราฟการคำนวณ TPU ไม่ได้เรียกใช้โค้ด Python โดยตรง แต่จะเรียกใช้กราฟการคำนวณที่กำหนดโดยโปรแกรม Tensorflow คอมไพเลอร์ชื่อ XLA (คอมไพเลอร์คณิตศาสตร์เชิงเส้นแบบเร่ง) จะเปลี่ยนกราฟ Tensorflow ของโหนดการประมวลผลเป็นรหัสเครื่อง TPU นอกจากนี้ คอมไพเลอร์นี้จะเพิ่มประสิทธิภาพขั้นสูงหลายอย่างในโค้ดและเลย์เอาต์หน่วยความจำด้วย การคอมไพล์จะเกิดขึ้นโดยอัตโนมัติเมื่อมีการส่งงานไปยัง TPU คุณไม่จำเป็นต้องใส่ XLA ไว้ในเชนบิลด์อย่างชัดเจน
ภาพประกอบ: หากต้องการเรียกใช้บน TPU ระบบจะแปลกราฟการคํานวณที่โปรแกรม Tensorflow กำหนดเป็นการแสดงผล XLA (คอมไพเลอร์คณิตศาสตร์เชิงเส้นแบบเร่ง) ก่อน จากนั้น 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คือส่วนที่ใช้การแจกแจงและอัลกอริทึมการซิงค์อนุพันธ์ "all-reduce"- นำกลยุทธ์ไปใช้ผ่านขอบเขต ต้องกำหนดโมเดลภายในขอบเขตกลยุทธ์()
- ฟังก์ชัน
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
- TPU ไม่รองรับ
tf.py_func
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 ของพิกเซลทั้งหมดให้เป็นเวกเตอร์แบบยาวและใช้เป็นอินพุต เทคนิคนี้ไม่ใช่เทคนิคที่ดีที่สุดสำหรับการจดจำรูปภาพ แต่เราจะปรับปรุงในภายหลัง
Neurons, activations, RELU
"เซลล์ประสาท" จะคำนวณผลรวมถ่วงน้ำหนักของอินพุตทั้งหมด เพิ่มค่าที่เรียกว่า "อคติ" และป้อนผลลัพธ์ผ่านวิธีการที่เรียกว่า "ฟังก์ชันการเปิดใช้งาน" ตอนแรกจะไม่ทราบน้ำหนักและค่ากําหนด โดยจะเริ่มจากการสุ่มและ "เรียนรู้" โดยการฝึกโครงข่ายประสาทด้วยข้อมูลจำนวนมากที่ทราบแล้ว
ฟังก์ชันการเปิดใช้งานที่ได้รับความนิยมสูงสุดเรียกว่า RELU ซึ่งย่อมาจาก Rectified Linear Unit ฟังก์ชันนี้เป็นฟังก์ชันที่ง่ายมากดังที่เห็นในกราฟด้านบน
การเปิดใช้งาน Softmax
เครือข่ายด้านบนลงท้ายด้วยชั้นเซลล์ 5 เซลล์ เนื่องจากเราจำแนกดอกไม้เป็น 5 หมวดหมู่ (กุหลาบ ทิวลิป แดนดิไลออน เดซี่ ดอกทานตะวัน) เซลล์ประสาทในชั้นกลางจะเปิดใช้งานโดยใช้ฟังก์ชันการเปิดใช้งาน RELU แบบคลาสสิก แต่ในชั้นสุดท้าย เราต้องการคำนวณจำนวนระหว่าง 0 ถึง 1 ซึ่งแสดงถึงความน่าจะเป็นของดอกกุหลาบ ดอกทิวลิป และอื่นๆ สำหรับกรณีนี้ เราจะใช้ฟังก์ชันเปิดใช้งานที่ชื่อ "softmax"
การใช้ซอฟต์แมกซ์กับเวกเตอร์ทำได้โดยนำเลขชี้กำลังของแต่ละองค์ประกอบมาทำให้เวกเตอร์เป็นมาตรฐาน โดยทั่วไปจะใช้บรรทัดฐาน L1 (ผลรวมของค่าสัมบูรณ์) เพื่อให้ค่าบวกกันถึง 1 และตีความค่าเป็นความน่าจะเป็นได้
การสูญเสียครอสเอนโทรปี
ตอนนี้ที่โครงข่ายประสาทของเราสร้างการคาดคะเนจากรูปภาพอินพุต เราจึงต้องวัดว่ารูปภาพนั้นดีเพียงใด เช่น ระยะห่างระหว่างสิ่งที่เครือข่ายแจ้งเรากับคำตอบที่ถูกต้อง ซึ่งมักเรียกว่า "ป้ายกำกับ" อย่าลืมว่าเรามีป้ายกำกับที่ถูกต้องสำหรับรูปภาพทั้งหมดในชุดข้อมูล
สามารถใช้ระยะทางเท่าใดก็ได้ แต่สำหรับปัญหาการจำแนกประเภท สิ่งที่เรียกว่า "ระยะทางแบบครอสเอนโทรปี" คือประสิทธิภาพมากที่สุด เราจะเรียกฟังก์ชันนี้ว่าฟังก์ชัน "ข้อผิดพลาด" หรือ "Loss"
การลดค่าการลาดชัน
"การฝึก" โครงข่ายประสาทหมายถึงการใช้ภาพและป้ายกำกับการฝึกเพื่อปรับน้ำหนักและน้ำหนัก เพื่อลดฟังก์ชันการสูญเสียครอสเอนโทรปี วิธีการทำงานมีดังนี้
ครอสเอนโทรปีเป็นฟังก์ชันของน้ำหนัก การให้น้ำหนักพิเศษ พิกเซลของรูปภาพที่ใช้ในการฝึก และคลาสที่รู้จัก
หากเราคํานวณอนุพันธ์บางส่วนของ Cross-Entropy เทียบกับน้ำหนักทั้งหมดและค่าอคติทั้งหมด เราจะได้ "อนุพันธ์" ซึ่งคํานวณสําหรับรูปภาพ ป้ายกำกับ และค่าปัจจุบันของน้ำหนักและค่าอคติที่ระบุ โปรดทราบว่าเราอาจมีน้ำหนักและค่ากําหนดล่วงหน้าหลายล้านรายการ ดังนั้นการคํานวณอนุพันธ์จึงดูเหมือนจะเป็นงานที่หนักมาก แต่โชคดีที่ Tensorflow ช่วยเราดำเนินการนี้ คุณสมบัติทางคณิตศาสตร์ของการไล่ระดับสีคือการชี้ "ขึ้น" เนื่องจากเราต้องการไปยังจุดที่ Cross-Entropy ต่ำ เราจึงเดินไปในทิศทางตรงกันข้าม เราจะอัปเดตน้ำหนักและค่ากําหนดด้วยเศษส่วนของอนุพันธ์ จากนั้นเราจะทำแบบเดิมซ้ำๆ โดยใช้รูปภาพและป้ายกำกับสำหรับการฝึกชุดถัดไปในลูปการฝึก เราหวังว่าค่านี้จะเป็นจุดที่ Cross-Entropy มีค่าต่ำสุด แม้ว่าจะไม่มีการรับประกันว่าค่าต่ำสุดนี้จะเป็นค่าเดียว
แบบมินิแบตช์และโมเมนตัม
คุณสามารถคํานวณการไล่ระดับสีในรูปภาพตัวอย่างเพียงภาพเดียวและอัปเดตน้ำหนักและน้ำหนักค่าต่างๆ ได้ทันที แต่การไล่ระดับสี เช่น รูปภาพ 128 ภาพจะให้การไล่ระดับสีที่แสดงถึงข้อจำกัดที่กำหนดโดยรูปภาพตัวอย่างที่แตกต่างกันได้ดีกว่า และมีแนวโน้มที่จะบรรจบกันในผลที่ได้เร็วกว่า ขนาดของมินิแบตช์จะเป็นพารามิเตอร์ที่ปรับได้
เทคนิคนี้ซึ่งบางครั้งเรียกว่า "การลดเชิงกริดแบบสุ่ม" มีประโยชน์อีกอย่างหนึ่งที่ใช้งานได้จริงมากขึ้น ซึ่งก็คือ การทำงานกับกลุ่มข้อมูลหมายถึงการทำงานกับเมทริกซ์ขนาดใหญ่ด้วย และโดยปกติแล้วเมทริกซ์เหล่านี้จะเพิ่มประสิทธิภาพใน GPU และ TPU ได้ง่ายกว่า
อย่างไรก็ตาม การบรรจบอาจยังสับสนอยู่บ้างและอาจหยุดลงได้หากเวกเตอร์ความชันเป็น 0 ทั้งหมด หมายความว่าเราพบค่าต่ำสุดแล้วใช่ไหม ไม่เสมอไป องค์ประกอบของไล่ระดับสีอาจเป็น 0 ที่ค่าต่ำสุดหรือสูงสุด ด้วยเวกเตอร์การไล่ระดับสีที่มีองค์ประกอบนับล้าน ถ้าเป็นศูนย์ทั้งหมด ความน่าจะเป็นที่ทุกศูนย์จะสัมพันธ์กับค่าต่ำสุด และไม่มีองค์ประกอบใดถึงจุดสูงสุดค่อนข้างเล็ก ในมิติข้อมูลที่มีหลายมิติ จุดยอดยอดขั้วค่อนข้างพบได้ทั่วไป และเราไม่ต้องการหยุดอยู่ที่จุดยอดยอดขั้ว
ภาพประกอบ: จุดตัด การไล่ระดับสีมีค่า 0 แต่ไม่ได้มีค่าต่ำสุดในทุกทิศทาง (การระบุแหล่งที่มาของรูปภาพ วิกิมีเดีย: โดย Nicoguaro - ผลงานของตนเอง, CC BY 3.0)
วิธีแก้ปัญหาคือการเพิ่มแรงกระตุ้นให้กับอัลกอริทึมการเพิ่มประสิทธิภาพเพื่อให้ข้ามจุดยอดได้โดยไม่ต้องหยุด
อภิธานศัพท์
กลุ่มหรือกลุ่มย่อย: การฝึกจะทํากับชุดข้อมูลและป้ายกำกับการฝึกอยู่เสมอ ซึ่งจะช่วยให้อัลกอริทึมบรรจบกัน มิติข้อมูล "กลุ่ม" มักจะเป็นมิติข้อมูลแรกของเทนเซอร์ข้อมูล เช่น Tensor ของรูปร่าง [100, 192, 192, 3] จะมีภาพขนาด 192x192 พิกเซล 100 ภาพที่มี 3 ค่าต่อพิกเซล (RGB)
การสูญเสียการครอสเอนโทรปี: ฟังก์ชันการสูญเสียพิเศษที่มักใช้ในตัวแยกประเภท
ชั้นที่หนาแน่น: ชั้นของเซลล์ประสาทที่เซลล์ประสาทแต่ละเซลล์เชื่อมต่อกับเซลล์ประสาททั้งหมดในชั้นก่อนหน้านี้
features: อินพุตของโครงข่ายประสาทบางครั้งเรียกว่า "ฟีเจอร์" ศิลปะในการหาว่าส่วนใดของชุดข้อมูล (หรือชุดค่าผสมของส่วนต่างๆ) ที่จะป้อนลงในเครือข่ายประสาทเพื่อให้ได้การคาดการณ์ที่ดีเรียกว่า "การปรับแต่งฟีเจอร์"
ป้ายกำกับ: อีกชื่อหนึ่งของ "ชั้นเรียน" หรือคำตอบที่ถูกต้องในปัญหาการแยกประเภทภายใต้การควบคุมดูแล
อัตราการเรียนรู้: เศษส่วนของการไล่ระดับสีที่มีการอัปเดตน้ำหนักและน้ำหนักพิเศษในแต่ละการวนซ้ำการฝึก
Logit: เอาต์พุตของชั้นนิวรอนก่อนใช้ฟังก์ชันการเปิดใช้งานเรียกว่า "Logit" คำนี้มาจาก "ฟังก์ชันโลจิสติก" หรือที่รู้จักกันในชื่อ "ฟังก์ชัน sigmoid" ซึ่งเคยเป็นฟังก์ชันเปิดใช้งานที่ได้รับความนิยมสูงสุด "เอาต์พุตระบบประสาทก่อนฟังก์ชันโลจิสติกส์" ถูกย่อเป็น "logits"
loss: ฟังก์ชันข้อผิดพลาดที่เปรียบเทียบเอาต์พุตของเครือข่ายประสาทกับคำตอบที่ถูกต้อง
neuron: คํานวณผลรวมถ่วงน้ำหนักของอินพุต เพิ่มค่ากําหนด และส่งผลลัพธ์ผ่านฟังก์ชันการเปิดใช้งาน
การเข้ารหัสแบบฮอตเวิร์ก: คลาส 3 จาก 5 ได้รับการเข้ารหัสเป็นเวกเตอร์ที่มีองค์ประกอบ 5 รายการ โดยเป็น 0 ทั้งหมดยกเว้นองค์ประกอบที่ 3 ซึ่งเป็น 1
relu: หน่วยเชิงเส้นที่แก้ไขแล้ว ฟังก์ชันการเปิดใช้งานยอดนิยมสําหรับเซลล์ประสาท
sigmoid: ฟังก์ชันการเปิดใช้งานอีกรูปแบบหนึ่งที่เคยได้รับความนิยมและยังคงมีประโยชน์ในบางกรณี
softmax: ฟังก์ชันเปิดใช้งานพิเศษที่ทำงานกับเวกเตอร์ เพิ่มความแตกต่างระหว่างส่วนประกอบที่ใหญ่ที่สุดกับองค์ประกอบอื่นๆ ทั้งหมด และยังทำให้เวกเตอร์มีผลรวมเป็น 1 ด้วย เพื่อให้สามารถตีความว่าเป็นเวกเตอร์ของความน่าจะเป็น ใช้เป็นขั้นตอนสุดท้ายในการจัดประเภท
tensor: "tensor" คล้ายกับเมทริกซ์ แต่มีมิติข้อมูลเป็นจำนวนที่กําหนดเอง Tensor หนึ่งมิติคือเวกเตอร์ เทนเซอร์ 2 มิติคือเมทริกซ์ จากนั้นคุณจะมีเทนเซอร์ที่มีมิติข้อมูล 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 Neural Nets 101
ในเลเยอร์ของเครือข่าย ConvNet "เซลล์ประสาท" 1 เซลล์จะทำการรวมพิกเซลที่มีน้ำหนักเหนือกว่าในบริเวณเล็กๆ ของรูปภาพเท่านั้น โดยจะเพิ่มค่ากําหนดล่วงหน้าและส่งผลรวมผ่านฟังก์ชันการเปิดใช้งาน เช่นเดียวกับที่เซลล์ประสาทในชั้นหนาแน่นปกติจะทํา จากนั้นระบบจะดําเนินการนี้ซ้ำไปทั่วทั้งรูปภาพโดยใช้น้ำหนักเดียวกัน อย่าลืมว่าในชั้นที่หนาแน่น เซลล์ประสาทแต่ละเซลล์มีน้ำหนักของตัวเอง ในที่นี้ "แพทช์" เดียวของน้ำหนักจะเลื่อนไปทั่วทั้งรูปภาพในทั้ง 2 ทิศทาง ("การกรองเชิงซ้อน") เอาต์พุตจะมีค่าเท่ากับจำนวนพิกเซลในรูปภาพ (แต่ต้องเว้นขอบไว้บ้าง) การดำเนินการกรองโดยใช้ตัวกรองที่มีน้ำหนัก 4x4x3=48
อย่างไรก็ตาม น้ำหนัก 48 อาจไม่เพียงพอ หากต้องการเพิ่มระดับอิสระ เราจะทําการดำเนินการเดียวกันซ้ำด้วยชุดน้ำหนักใหม่ ซึ่งจะสร้างเอาต์พุตตัวกรองชุดใหม่ สมมติว่าเป็น "ช่อง" ของเอาต์พุตโดยเปรียบเทียบกับช่อง R,G,B ในภาพอินพุต
น้ำหนัก 2 ชุด (หรือมากกว่า) สามารถรวมกันเป็นเทนเซอร์ 1 ชุดได้โดยการเพิ่มมิติข้อมูลใหม่ ซึ่งจะให้รูปร่างทั่วไปของเทนเซอร์น้ำหนักสําหรับชั้น Conv เนื่องจากจำนวนช่องอินพุตและเอาต์พุตเป็นพารามิเตอร์ เราจึงเริ่มวางซ้อนและต่อเลเยอร์ Conv ได้
ภาพ: โครงข่ายประสาทแบบคอนโวลูชัน (Convolutional Neural Network) แปลง "คิวบ์" ของข้อมูลเป็น "คิวบ์" อื่นๆ ของข้อมูล
Convlution แบบเพิ่มระยะการกรอง, การรวมข้อมูลสูงสุด
การทำ Convolution ด้วยระยะ 2 หรือ 3 จะช่วยให้เราย่อขนาดคิวบข้อมูลที่ได้ในมิติข้อมูลแนวนอนได้ด้วย วิธีทั่วไปมี 2 วิธีดังนี้
- การกรองแบบ Strided: ตัวกรองแบบเลื่อนเช่นเดียวกับด้านบน แต่มีระยะการเลื่อนมากกว่า 1
- การรวมกลุ่มสูงสุด: หน้าต่างเลื่อนที่ใช้การดำเนินการ MAX (โดยปกติจะเป็นแพตช์ 2x2 ทำซ้ำทุก 2 พิกเซล)
ภาพประกอบ: การเลื่อนกรอบเวลาการคํานวณ 3 พิกเซลส่งผลให้ค่าเอาต์พุตน้อยลง Convolution ระยะก้าวหรือการรวมกันสูงสุด (สูงสุดในการเลื่อนหน้าต่างขนาด 2x2 ด้วยระยะก้าวที่ 2) เป็นวิธีย่อลูกบาศก์ข้อมูลในขนาดแนวนอน
ตัวแยกประเภทแบบ Convolutive
สุดท้าย เราจะแนบส่วนหัวการจัดประเภทโดยทำให้คิวบข้อมูลสุดท้ายแบนราบและส่งผ่านเลเยอร์แบบหนาแน่นที่เปิดใช้งาน Softmax ตัวแยกประเภทแบบ Convolutional โดยทั่วไปจะมีลักษณะดังนี้
ภาพประกอบ: ตัวจัดประเภทรูปภาพโดยใช้เลเยอร์ Convolutive และ Softmax โดยจะใช้ฟิลเตอร์ขนาด 3x3 และ 1x1 โดยเลเยอร์สูงสุดคือกลุ่มจุดข้อมูลขนาด 2x2 ส่วนหัวการจัดประเภทใช้เลเยอร์แบบหนาแน่นที่มีการเปิดใช้งาน Softmax
ใน Keras
กองคอลเล็กชันภาพที่แสดงด้านบนเขียนเป็น 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 ที่กําหนดเอง
การลงมือปฏิบัติ
มาสร้างและฝึกโครงข่ายประสาทเทียมแบบ ConvNet ตั้งแต่ต้นกัน การใช้ 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 ได้ด้วย ซึ่งราคาไม่แพง โดยไม่ได้ "กรอง" อะไรเลย แค่คำนวณคู่แชแนลเชิงเส้นเท่านั้น ใส่ฟิลเตอร์จำลองสลับกับฟิลเตอร์จริง (ดูข้อมูลเพิ่มเติมเกี่ยวกับ "Convlution 1x1" ในส่วนถัดไป)
- สําหรับปัญหาการจัดประเภทเช่นนี้ ให้ลดขนาดบ่อยครั้งด้วยเลเยอร์ Max-pooling (หรือการฟัซชันที่มีระยะห่าง >1) คุณไม่สนใจว่าดอกไม้อยู่ตรงไหน แต่สนใจแค่ว่าเป็นดอกกุหลาบหรือดอกแดนเดไลออน การสูญเสียข้อมูล x และ y จึงไม่ใช่สิ่งสําคัญ และการกรองพื้นที่ขนาดเล็กจะประหยัดกว่า
- โดยทั่วไปจำนวนตัวกรองจะใกล้เคียงกับจำนวนคลาสเมื่อสิ้นสุดเครือข่าย (เพราะเหตุใด ลองดูเคล็ดลับ "การรวมค่าเฉลี่ยทั่วโลก" ด้านล่าง) หากคุณแยกประเภทเป็นหลายร้อยคลาส ให้เพิ่มจำนวนตัวกรองทีละน้อยในเลเยอร์ที่ต่อเนื่องกัน สําหรับชุดข้อมูลดอกไม้ที่มี 5 คลาส การกรองด้วยตัวกรองเพียง 5 ตัวอาจไม่เพียงพอ คุณใช้จำนวนฟิลเตอร์เดียวกันในเลเยอร์ส่วนใหญ่ได้ เช่น 32 และลดจำนวนฟิลเตอร์ลงเมื่อใกล้ถึงจุดสิ้นสุด
- เลเยอร์แบบหนาแน่นสุดท้ายมีราคาแพง โดยอาจมีน้ำหนักมากกว่าเลเยอร์ Conv ทั้งหมดรวมกัน เช่น แม้ว่าจะมีเอาต์พุตที่สมเหตุสมผลมากจากคิวบ์ข้อมูลล่าสุดซึ่งมีจุดข้อมูล 24x24x10 แต่ชั้นหนาแน่นที่มีเซลล์ประสาท 100 เซลล์ก็จะมีน้ำหนัก 24x24x10x100=576,000 รายการ โปรดพิจารณาอย่างรอบคอบหรือลองใช้การรวมข้อมูลเฉลี่ยทั่วโลก (ดูด้านล่าง)
การรวมข้อมูลเฉลี่ยทั่วโลก
แทนที่จะใช้ชั้นที่มีความหนาแน่นราคาแพงที่ตอนท้ายของโครงข่ายระบบประสาทเทียมแบบ Convolutional คุณสามารถแยก "ลูกบาศก์" ที่เข้ามาใหม่ออกเป็นส่วนต่างๆ ตามที่มีคลาส หาค่าเฉลี่ยและป้อนข้อมูลค่าเหล่านี้ผ่านฟังก์ชันการเปิดใช้งาน Softmax วิธีสร้างส่วนหัวการแยกประเภทในลักษณะนี้จะมีน้ำหนักเป็น 0 ใน Keras ไวยากรณ์คือ tf.keras.layers.GlobalAveragePooling2D().
โซลูชัน
โน้ตบุ๊กโซลูชันมีดังนี้ คุณสามารถใช้รหัสผ่านนี้ได้หากติดขัด
Keras_Flowers_TPU (solution).ipynb
สิ่งที่เราได้พูดถึง
- 🤔 เล่นกับเลเยอร์ Conv
- 🤓 ทดลองใช้ Max Pooling, Strides, Global Average Pooling, ...
- 😀 ปรับปรุงโมเดลในชีวิตจริงได้อย่างรวดเร็วบน TPU
โปรดใช้เวลาสักครู่เพื่อทบทวนรายการตรวจสอบนี้
7 ยินดีด้วย
คุณได้สร้างโครงข่ายระบบประสาทเทียมแบบคอนโวลูชัน (Convolutional) ที่ทันสมัยแห่งแรกและฝึกให้เครือข่ายมีความแม่นยำมากกว่า 80% โดยสามารถปรับปรุงสถาปัตยกรรมได้ในไม่กี่นาทีด้วย TPU โปรดไปยังห้องทดลองถัดไปเพื่อดูข้อมูลเกี่ยวกับสถาปัตยกรรมแบบคอนโวลูชันสมัยใหม่ (Conolutional)
- ไปป์ไลน์ข้อมูลที่ทำงานด้วยความเร็ว TPU: tf.data.Dataset และ TFRecords
- โมเดล Keras แรกของคุณที่มีการเรียนรู้การโอน
- [THIS LAB] โครงข่ายระบบประสาทเทียมแบบ Convolutional พร้อมด้วย Keras และ TPU
- ConvNet, SqueezeNet, Xception สมัยใหม่ด้วย Keras และ TPU
การใช้งาน TPU
TPU และ GPU พร้อมให้บริการใน Cloud AI Platform
สุดท้ายนี้ เรายินดีรับฟังความคิดเห็น โปรดแจ้งให้เราทราบหากพบสิ่งผิดปกติในห้องทดลองนี้หรือคิดว่าควรปรับปรุง คุณสามารถแสดงความคิดเห็นผ่านปัญหาใน GitHub [ลิงก์ความคิดเห็น]
|
