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

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

เกี่ยวกับ Codelab นี้

subjectอัปเดตล่าสุดเมื่อ มิ.ย. 29, 2021
account_circleเขียนโดย Laurence Moroney

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 ยินดีด้วย

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

bug_report รายงานความผิดพลาด