สร้างโมเดลคอมพิวเตอร์วิทัศน์ด้วย TensorFlow

1. ข้อควรทราบก่อนที่จะเริ่มต้น

ใน Codelab นี้ คุณจะสร้างโมเดลการมองเห็นคอมพิวเตอร์ที่จดจําเสื้อผ้าได้ด้วย TensorFlow

ข้อกำหนดเบื้องต้น

• ความรู้ที่ดีเกี่ยวกับ Python
• ทักษะการเขียนโปรแกรมพื้นฐาน

สิ่งที่จะได้เรียนรู้

ใน Codelab นี้ คุณจะทําสิ่งต่อไปนี้ได้

• ฝึกโครงข่ายระบบประสาทเทียมเพื่อจดจําเสื้อผ้า
• ทําแบบฝึกหัดชุดต่างๆ เพื่อแนะนําคุณผ่านการทดสอบกับเลเยอร์ต่างๆ ของเครือข่าย

สิ่งที่คุณจะสร้าง

• โครงข่ายระบบประสาทเทียมที่ระบุบทความเสื้อผ้า

สิ่งที่ต้องมี

หากไม่เคยสร้างเครือข่ายโครงข่ายประสาทสําหรับคอมพิวเตอร์วิทัศน์ด้วย TensorFlow เลย คุณจะใช้ Colaboratory ซึ่งเป็นสภาพแวดล้อมของเบราว์เซอร์ที่มีทรัพยากร Dependency ที่จําเป็นทั้งหมดได้ คุณค้นหาโค้ดสําหรับส่วนที่เหลือของ Codelab ได้อยู่ใน Colab

ไม่เช่นนั้น ภาษาหลักที่คุณใช้สําหรับโมเดลการฝึกคือ Python ดังนั้นคุณจะต้องติดตั้ง นอกจากนี้ คุณจะต้องมี TensorFlow และไลบรารี NumPy ด้วย ดูข้อมูลเพิ่มเติมเกี่ยวกับและติดตั้ง TensorFlow ได้ที่นี่ ติดตั้ง NumPy ที่นี่

2. เริ่มเขียนโค้ด

ขั้นแรก ให้ดูสมุดบันทึก Colab ที่ดําเนินการได้

เริ่มด้วยการนําเข้า TensorFlow

import tensorflow as tf
print(tf.__version__)

คุณจะฝึกเครือข่ายโครงข่ายประสาทให้จดจําเสื้อผ้าจากชุดข้อมูลทั่วไปที่เรียกว่าแฟชั่น MNIST ร้านเสื้อผ้าประกอบด้วยสินค้า 70,000 รายการใน 10 หมวดหมู่ เสื้อผ้าแต่ละชิ้นอยู่ในภาพโทนสีเทา 28x28 ดูตัวอย่างได้ที่นี่

ป้ายกํากับที่เชื่อมโยงกับชุดข้อมูล ได้แก่

ป้ายกํากับ	คำอธิบาย
0	การสกรีนเสื้อยืด
1	กางเกง
2	เสื้อสวมหัว
3	เสื้อชุดสตรี
4	เสื้อโค้ท
5	รองเท้ามีสายรัด
6	เสื้อ
7	รองเท้าผ้าใบ
8	กระเป๋า
9	รองเท้าบูทหุ้มข้อ

ข้อมูล Fashion MNIST มีอยู่ใน tf.keras.datasets API โหลดดังนี้

mnist = tf.keras.datasets.fashion_mnist

การเรียกใช้ load_data ในออบเจ็กต์นั้นประกอบด้วยรายการ 2 ชุด ได้แก่ ค่า training และ test ซึ่งแสดงถึงกราฟิกที่แสดงรายการเสื้อผ้าและป้ายกํากับ

(training_images, training_labels), (test_images, test_labels) = mnist.load_data()

ค่าเหล่านั้นมีลักษณะอย่างไร พิมพ์รูปภาพการฝึกอบรมและป้ายกํากับการฝึกอบรมเพื่อดู คุณอาจทดสอบกับดัชนีต่างๆ ในอาร์เรย์

import matplotlib.pyplot as plt
plt.imshow(training_images[0])
print(training_labels[0])
print(training_images[0])

การพิมพ์ข้อมูลของรายการ 0 มีลักษณะดังนี้

คุณจะสังเกตเห็นว่าค่าทั้งหมดเป็นจํานวนเต็มระหว่าง 0 ถึง 255 เมื่อฝึกเครือข่ายระบบประสาท จะสามารถรักษาค่าทั้งหมดระหว่าง 0 ถึง 1 กระบวนการที่เรียกว่าการปรับให้สอดคล้องตามมาตรฐานได้ง่ายขึ้น โชคยังดีที่ Python มอบวิธีที่ง่ายในการปรับรายการให้เป็นปกติโดยไม่ต้องวนซ้ํา

training_images  = training_images / 255.0
test_images = test_images / 255.0

คุณอาจพิจารณาที่ 42 ซึ่งเป็นการเปิดเครื่องอื่นที่ไม่ใช่เครื่องที่ดัชนี 0

ตอนนี้คุณอาจสงสัยว่าทําไมถึงมีชุดข้อมูล 2 ชุด ได้แก่ การฝึกอบรมและการทดสอบ

แนวคิดคือการมีชุดข้อมูลหนึ่งสําหรับการฝึกอบรม และอีกชุดข้อมูลหนึ่งที่โมเดลยังไม่พบ เพื่อดูว่าโมเดลแยกประเภทค่าได้ดีเพียงใด เมื่อทําเสร็จแล้ว คุณจะต้องใช้โมเดลกับข้อมูลที่ยังไม่เคยเห็นมาก่อน นอกจากนี้ เมื่อไม่มีข้อมูลการทดสอบแยกต่างหาก คุณจะที่ให้ความเสี่ยงด้านเครือข่ายที่จดจําข้อมูลการฝึกอบรมเท่านั้นโดยไม่ต้องระบุทั่วไปถึงความรู้

3. ออกแบบโมเดล

มาออกแบบโมเดลกันเลย คุณจะมี 3 เลเยอร์ เลือกดูทีละรายการและศึกษาเลเยอร์และพารามิเตอร์ประเภทต่างๆ ที่ใช้สําหรับแต่ละรายการ

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), 
                                    tf.keras.layers.Dense(128, activation=tf.nn.relu), 
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

• Sequential กําหนดลําดับของเลเยอร์ในเครือข่ายระบบประสาท
• Flatten ใช้รูปสี่เหลี่ยมจัตุรัสและเปลี่ยนให้เป็นเวกเตอร์มิติเดียว
• Dense เพิ่มเลเยอร์เซลล์ประสาท
• ฟังก์ชัน Activation บอกชั้นเซลล์ประสาทว่าต้องทําอะไร มีตัวเลือกมากมายแต่ให้ใช้ตอนนี้
• Relu หมายความว่าหาก X มากกว่า 0 แสดงผล X จะหมายถึง 0 แสดงผล ระบบจะส่งเฉพาะค่า 0 ขึ้นไปไปยังเลเยอร์ถัดไปในเครือข่าย
• Softmax จะใช้ชุดค่าและเลือกค่าที่ดีที่สุดอย่างมีประสิทธิภาพ ตัวอย่างเช่น หากเอาต์พุตของเลเยอร์สุดท้ายมีลักษณะเป็น [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05] ก็จะไม่ต้องจัดเรียงให้ค่าสูงสุด กล่าวคือจะแสดงผล [0,0,0,0,1,0,0,0,0]

4. คอมไพล์และฝึกโมเดล

เมื่อกําหนดรูปแบบแล้ว สิ่งที่คุณต้องทําก็คือสร้างโมเดล สร้างโมเดลโดยคอมไพล์ก่อนด้วยฟังก์ชัน optimizer และ loss แล้วฝึกโมเดลในข้อมูลการฝึกและป้ายกํากับ โดยมีเป้าหมายเพื่อให้โมเดลเข้าใจความสัมพันธ์ระหว่างข้อมูลการฝึกอบรมและป้ายกํากับการฝึก ต่อมา คุณสามารถอยากให้โมเดลเห็นข้อมูลที่คล้ายกับข้อมูลการฝึก จากนั้นให้คาดการณ์ลักษณะของข้อมูลนั้น

สังเกตการใช้ metrics= เป็นพารามิเตอร์ซึ่งช่วยให้ TensorFlow รายงานความแม่นยําของการฝึกอบรมด้วยการตรวจสอบผลลัพธ์ที่คาดการณ์กับคําตอบที่รู้จัก (ป้ายกํากับ)

model.compile(optimizer = tf.keras.optimizers.Adam(),
              loss = 'sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(training_images, training_labels, epochs=5)

เมื่อ model.fit ดําเนินการ คุณจะเห็นการสูญเสียและความถูกต้อง:

Epoch 1/5
60000/60000 [=======] - 6s 101us/sample - loss: 0.4964 - acc: 0.8247
Epoch 2/5
60000/60000 [=======] - 5s 86us/sample - loss: 0.3720 - acc: 0.8656
Epoch 3/5
60000/60000 [=======] - 5s 85us/sample - loss: 0.3335 - acc: 0.8780
Epoch 4/5
60000/60000 [=======] - 6s 103us/sample - loss: 0.3134 - acc: 0.8844
Epoch 5/5
60000/60000 [=======] - 6s 94us/sample - loss: 0.2931 - acc: 0.8926

เมื่อฝึกโมเดลเสร็จแล้ว คุณจะเห็นค่าความแม่นยําในตอนท้ายของยุคสุดท้าย อาจอยู่ในรูปแบบ 0.8926 ด้านบน สัญญาณนี้จะบอกคุณว่าโครงข่ายระบบประสาทเทียมมีความแม่นยําในการแยกประเภทข้อมูลการฝึกประมาณ 89% กล่าวอีกนัยหนึ่งคือ รูปแบบได้จับคู่รูปแบบกับรูปภาพที่มีประสิทธิภาพ 89% ของเวลาทั้งหมด ไม่ได้มีดีนักแต่ก็ไม่ถือว่าถูกฝึกมาเพียง 5 ตอนและเสร็จสิ้นอย่างรวดเร็ว

5. ทดสอบโมเดล

โมเดลจะใช้งานข้อมูลที่ไม่เห็นได้อย่างไร คุณจึงมีชุดการทดสอบ คุณเรียก model.evaluate และโอนในทั้ง 2 ชุด แล้วรายงานการสูญเสียแต่ละชุด ลองใช้เลย

model.evaluate(test_images, test_labels)

และผลลัพธ์ที่ได้มีดังนี้

10000/10000 [=====] - 1s 56us/sample - loss: 0.3365 - acc: 0.8789
[0.33648381242752073, 0.8789]

ตัวอย่างดังกล่าวแสดงผล .8789 ได้อย่างถูกต้อง ซึ่งหมายความว่ามีความถูกต้องประมาณ 88% (คุณอาจมีค่าต่างกันเล็กน้อย)

โมเดลก็ไม่ถูกต้องด้วยข้อมูลที่ไม่รู้จักเท่าที่ฝึกกับข้อมูลการฝึก ขณะที่คุณดูข้อมูลเพิ่มเติมเกี่ยวกับ TensorFlow จะพบวิธีปรับปรุง

หากต้องการสํารวจเพิ่มเติม ให้ลองออกกําลังกายในขั้นตอนถัดไป

6. แบบฝึกหัดการสํารวจ

การออกกําลังกาย 1

ทําแบบฝึกหัดแรกโดยเรียกใช้โค้ดต่อไปนี้

classifications = model.predict(test_images)
print(classifications[0])

จากนั้นจะสร้างชุดการแยกประเภทรูปภาพทดสอบแต่ละภาพ จากนั้นพิมพ์รายการแรกในการแยกประเภท ผลลัพธ์หลังจากที่คุณเรียกใช้จะเป็นรายการตัวเลข คุณคิดว่าตัวเลขดังกล่าวคืออะไรและตัวเลขเหล่านั้นแสดงถึงอะไร

ลองเรียกใช้ print(test_labels[0]) แล้วคุณจะได้รับ 9 วิธีนี้จะช่วยให้คุณเข้าใจสาเหตุที่ทําให้รายการมีลักษณะเป็นอย่างไร

ผลลัพธ์ที่ได้จากโมเดลนี้ประกอบด้วยตัวเลข 10 หลัก ตัวเลขเหล่านั้นมีแนวโน้มที่ค่าที่จะจัดประเภทจะเป็นป้ายกํากับที่เกี่ยวข้อง เช่น ค่าแรกในรายการคือความน่าจะเป็นที่เสื้อผ้าจะเป็นคลาส 0 และถัดไปเป็น 1 โปรดสังเกตว่ามีความน่าจะเป็นต่ํามาก ยกเว้นอย่างใดอย่างหนึ่ง นอกจากนี้ เนื่องจาก Softmax ความน่าจะเป็นทั้งหมดในรายการจะเท่ากับ 1.0

รายการและป้ายกํากับเป็นเลข 0 ดังนั้นรองเท้าบูทหุ้มข้อที่มีป้ายกํากับ 9 หมายความว่าเป็นที่ 10 ของทั้ง 10 คลาส รายการที่มีองค์ประกอบที่ 10 เป็นค่าสูงสุดหมายความว่าโครงข่ายระบบประสาทเทียมได้คาดเดาว่ารายการที่ได้รับการจัดประเภทนั้นมีแนวโน้มสูงสุดที่จะเปิดข้อเท้า

การออกกําลังกาย 2

ดูเลเยอร์ในโมเดลของคุณ ทดลองใช้ค่าที่แตกต่างกันสําหรับเลเยอร์ที่หนาแน่นด้วยเซลล์ประสาท 512 เซลล์

ผลลัพธ์ใดที่คุณได้รับจากการสูญเสียและการฝึกอบรม คุณคิดว่าเป็นกรณีอะไร

ตัวอย่างเช่น หากเพิ่มเซลล์ประสาทเป็น 1,024 เซลล์ คุณจะต้องคํานวณเพิ่มเติมซึ่งทําให้กระบวนการช้าลง แต่ในกรณีนี้ รูปแบบนั้นให้ผลลัพธ์ที่ดีเนื่องจากโมเดลมีความแม่นยํามากกว่า และไม่ได้หมายความว่าจะดีขึ้นเสมอไป คุณสามารถลดการลดจํานวนผลตอบแทนได้อย่างรวดเร็ว

การออกกําลังกาย 3

จะเกิดอะไรขึ้นหากคุณนําเลเยอร์ Flatten() ออก คุณคิดว่าเป็นกรณีอะไร

คุณจะได้รับข้อผิดพลาดเกี่ยวกับรูปร่างของข้อมูล รายละเอียดของข้อผิดพลาดอาจดูไม่ชัดเจนในตอนนี้ แต่จะช่วยเสริมหลักการสําคัญว่าเลเยอร์แรกในเครือข่ายของคุณควรมีรูปทรงเดียวกับข้อมูล ตอนนี้ข้อมูลของคุณคือขนาด 28x28 และขนาด 28 ชั้นของเซลล์ประสาท 28 ชั้นคงทําไม่ได้ ดังนั้นคุณจึงควรแยกขนาด 28.28 เป็นขนาด 784x1 แทน

แทนที่จะต้องเขียนโค้ดทั้งหมด ให้เพิ่มเลเยอร์ Flatten() ไว้ที่ตอนต้น เมื่อมีการโหลดอาร์เรย์ลงในโมเดลในภายหลัง ระบบจะแยกอาร์เรย์เหล่านั้นให้คุณโดยอัตโนมัติ

การออกกําลังกาย 4

พิจารณาเลเยอร์สุดท้าย (เอาต์พุต) เหตุใดจึงมี 10 ช่อง จะเกิดอะไรขึ้นหากคุณมีจํานวนเงินที่ต่างจาก 10

ลองฝึกเครือข่ายด้วย 5 คุณจะได้รับข้อผิดพลาดทันทีที่พบค่าที่ไม่คาดคิด กฎทั่วไปอีกข้อหนึ่งของจํานวนเซลล์ประสาทในเลเยอร์สุดท้ายควรตรงกับจํานวนคลาสที่คุณจัดประเภทให้ ในกรณีนี้ ตัวเลขนี้มีค่าตั้งแต่ 0 ถึง 9 ดังนั้นตัวเลข 10 หลักจึงมี 10 เซลล์ในเลเยอร์สุดท้าย

การออกกําลังกาย 5

พิจารณาผลกระทบของเลเยอร์เพิ่มเติมในเครือข่าย จะเกิดอะไรขึ้นหากคุณเพิ่มเลเยอร์อื่นระหว่างเลเยอร์ 512 กับเลเยอร์สุดท้ายที่มี 10 ชั้น

ไม่มีผลกระทบที่มีนัยสําคัญ เนื่องจากนี่เป็นข้อมูลที่ค่อนข้างเรียบง่าย สําหรับข้อมูลที่ที่ซับซ้อนกว่านั้น มักจะต้องใช้เลเยอร์เพิ่มเติม

การออกกําลังกาย 6

ก่อนการฝึก คุณทําข้อมูลให้เป็นมาตรฐาน โดยเริ่มจากค่า 0 ถึง 255 เป็นค่า 0 ถึง 1 การนําโฆษณาออกจะส่งผลอย่างไร ลองดูโค้ดแบบเต็มนี้เพื่อลองใหม่ (โปรดทราบว่าจะมีการตรวจสอบทั้ง 2 บรรทัดที่ทําให้ข้อมูลถูกต้อง)

ทําไมคุณจึงคิดว่าได้ผลลัพธ์ที่ต่างกัน เรามีคําตอบที่ยอดเยี่ยมให้ที่นี่เกี่ยวกับ Stack Overflow

import tensorflow as tf
print(tf.__version__)
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
#training_images=training_images/255.0
#test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5)
model.evaluate(test_images, test_labels)
classifications = model.predict(test_images)
print(classifications[0])
print(test_labels[0])

7. สํารวจโค้ดเรียกกลับ

ก่อนหน้านี้เมื่อคุณฝึกสําหรับ Epoch เพิ่มเติม คุณพบปัญหาที่อาจสูญเสียไป ซึ่งอาจต้องใช้เวลาสักระยะหนึ่งเพื่อรอให้การฝึกอบรมเสร็จสิ้น และคุณอาจคิดว่าการฝึกอบรมก็คงจะดีหากคุณหยุดการฝึกอบรมได้เมื่อได้ค่าตามที่ต้องการ เช่น ความแม่นยํา 95% หากเข้าถึงหลังจาก 3 Epoch แล้ว ให้รอจนจะต้องทํา Epoch อีกหลายรอบก่อน

เช่นเดียวกับโปรแกรมอื่น คุณมีสิทธิ์โทรกลับ ดูของจริง

import tensorflow as tf

class myCallback(tf.keras.callbacks.Callback):
  def on_epoch_end(self, epoch, logs={}):
    if(logs.get('accuracy')>0.95):
      print("\nReached 95% accuracy so cancelling training!")
      self.model.stop_training = True

callbacks = myCallback()
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images/255.0
test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5, callbacks=[callbacks])

8. ยินดีด้วย

คุณได้สร้างรูปแบบคอมพิวเตอร์วิทัศน์เป็นครั้งแรกแล้ว หากต้องการดูวิธีเพิ่มประสิทธิภาพโมเดลคอมพิวเตอร์วิทัศน์ของคุณ โปรดไปที่หัวข้อสร้างการปฏิวัติและรวบรวมกฎ