TensorFlow, Keras และการเรียนรู้เชิงลึก ไม่ต้องมีปริญญาเอก

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

Codelab นี้ใช้ชุดข้อมูล MNIST ซึ่งเป็นคอลเล็กชันที่ประกอบด้วยตัวเลข 60,000 หลักที่มีป้ายกํากับซึ่งช่วยให้ปริญญาเอกออกต่อเนื่องกันมานานเกือบ 2 ทศวรรษ คุณจะแก้ไขปัญหาโค้ด Python / TensorFlow น้อยกว่า 100 บรรทัดได้

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

  • โครงข่ายระบบประสาทเทียมและวิธีฝึกอบรม
  • วิธีสร้างเครือข่ายระบบประสาทเทียมแบบ 1 ชั้นโดยใช้ tf.keras
  • วิธีเพิ่มเลเยอร์อีก
  • วิธีตั้งค่ากําหนดเวลาอัตราการเรียนรู้
  • วิธีสร้างโครงข่ายประสาทเทียม
  • วิธีการใช้เทคนิคการปรับให้สอดคล้องตามมาตรฐาน: เมนูแบบเลื่อนลง การกําหนดรูปแบบมาตรฐาน
  • สิ่งที่เน้นมากเกินไป

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

แค่เบราว์เซอร์ สามารถจัดเวิร์กช็อปนี้กับ Google Colaboratory ได้ทั้งหมด

ความคิดเห็น

โปรดแจ้งให้เราทราบหากพบสิ่งผิดปกติในห้องทดลองนี้หรือคิดว่าควรปรับปรุง เราจัดการความคิดเห็นผ่านปัญหา GitHub [ลิงก์ความคิดเห็น]

ห้องปฏิบัติการนี้ใช้ Google Colaboratory และไม่จําเป็นต้องมีการตั้งค่าใดๆ คุณสามารถเรียกใช้ได้จาก Chromebook โปรดเปิดไฟล์ด้านล่างและเรียกใช้เซลล์เพื่อทําความคุ้นเคยกับสมุดบันทึก Colab

Welcome to Colab.ipynb

วิธีการเพิ่มเติมด้านล่าง

เลือกแบ็กเอนด์ GPU

ในเมนู Colab ให้เลือก Runtime > ให้เปลี่ยนรันไทม์ประเภทต่างๆ แล้วเลือก GPU การเชื่อมต่อกับรันไทม์จะเกิดขึ้นโดยอัตโนมัติเมื่อทําการค้นหาครั้งแรก หรือคุณจะใช้ปุ่ม "Connect" ที่มุมขวาบนก็ได้

การดําเนินการของสมุดบันทึก

ดําเนินการทีละเซลล์โดยคลิกเซลล์และใช้ Shift-ENTER นอกจากนี้คุณยังเรียกใช้สมุดบันทึกทั้งหมดได้ด้วย Runtime > Run all

สารบัญ

สมุดบันทึกทั้งหมดมีสารบัญ โดยใช้ลูกศรสีดําที่อยู่ทางด้านซ้าย

เซลล์ที่ซ่อนอยู่

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

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

keras_01_mnist.ipynb

ขณะที่คุณเรียกใช้สมุดบันทึก ให้เน้นที่การแสดงภาพ โปรดดูคําอธิบายด้านล่าง

ข้อมูลการฝึกอบรม

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

โครงข่ายระบบประสาทเทียมที่เราจะสร้างตัวเลขที่เขียนด้วยลายมือใน 10 คลาส (0, .., 9) โดยยึดตามพารามิเตอร์ภายในที่จําเป็นต้องมีค่าที่ถูกต้องสําหรับการแยกประเภทจึงจะทํางานได้ดี "ค่าที่ถูกต้อง"" เรียนรู้ผ่านขั้นตอนการฝึกอบรมซึ่งต้องมี &"ชุดข้อมูลที่ติดป้ายกํากับ&ทั้งหมด; พร้อมรูปภาพและคําตอบที่ถูกต้องที่เกี่ยวข้อง

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

ฝึกอบรม

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

ส่วนทางด้านขวา &&tt;ความถูกต้องแม่นยํา&โควต้าคือเปอร์เซ็นต์ของตัวเลขที่ได้รับการยอมรับอย่างถูกต้อง ความคืบหน้าจะสูงขึ้นเรื่อยๆ การฝึกอบรมเป็นสิ่งที่ดี

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

แกน X แสดงจํานวน &&tt;epochs" หรือการทําซ้ําผ่านชุดข้อมูลทั้งหมด

การคาดการณ์

เมื่อมีการฝึกโมเดล เราสามารถใช้โมเดลเพื่อจดจําตัวเลขที่เขียนด้วยลายมือได้ การแสดงภาพถัดไปแสดงประสิทธิภาพการทํางานของตัวเลข 2-3 หลักที่แสดงผลจากแบบอักษรในพื้นที่ (บรรทัดแรก) และตัวเลข 10,000 หลักในชุดข้อมูลการตรวจสอบ คลาสที่คาดไว้จะปรากฏใต้ตัวเลขแต่ละหลักเป็นสีแดงหากไม่ถูกต้อง

ดังจะเห็นได้ว่ารูปแบบเริ่มต้นนี้ไม่ค่อยดีนักแต่ก็ยังคงจดจําตัวเลขที่ถูกต้องได้ ความถูกต้องของการตรวจสอบขั้นสุดท้ายอยู่ที่ประมาณ 90% ซึ่งไม่แย่มากสําหรับโมเดลความเรียบง่ายที่เราเริ่มต้นด้วย แต่ยังมีข้อผิดพลาดว่าพลาดหมายเลขตรวจสอบ 1, 000 หลักจาก 10,000 หลัก ซึ่งแสดงผลออกมาได้มากกว่าส่วนนี้ ดังนั้นคําตอบทั้งหมดจึงไม่ถูกต้อง (สีแดง)

Tensor

และเก็บข้อมูลไว้ในเมทริกซ์ ภาพโทนสีเทาขนาด 28x28 พิกเซลจะสอดคล้องกับเมตริกซ์ขนาด 28x28 พิกเซล แต่สําหรับรูปภาพสี เราต้องใส่ขนาดเพิ่มเติม ค่าสีมี 3 ค่าต่อพิกเซล (แดง เขียว น้ําเงิน) ดังนั้นตาราง 3 มิติจะต้องใช้มิติข้อมูล [28, 28, 3] และหากต้องการจัดเก็บรูปภาพสี 128 ภาพ คุณต้องมีตารางแบบ 4 มิติที่มีขนาด [128, 28, 28, 3]

ตารางมิติข้อมูลเหล่านี้เรียกว่า "tensors" และรายการมิติข้อมูลคือ "shape"

สรุป

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

witch.png

สําหรับโมเดลที่สร้างเป็นลําดับเลเยอร์ Keras มี Sequential API ตัวอย่างเช่น ตัวแยกประเภทรูปภาพที่ใช้เลเยอร์ความหนาแน่น 3 ชั้นสามารถเขียนใน Keras ได้ดังนี้

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[28, 28, 1]),
    tf.keras.layers.Dense(200, activation="relu"),
    tf.keras.layers.Dense(60, activation="relu"),
    tf.keras.layers.Dense(10, activation='softmax') # classifying into 10 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, ... )

ชั้นเดียวที่หนาแน่น

ตัวเลขที่เขียนด้วยลายมือในชุดข้อมูล MNIST คือรูปภาพขนาด 28x28 พิกเซลสีเทา วิธีที่ง่ายที่สุดในการแยกประเภทคือการใช้ขนาด 28x28=784 พิกเซลเป็นอินพุตสําหรับเครือข่ายโครงข่ายประสาทแบบ 1 ชั้น

Screen Shot 2016-07-26 เวลา 12.32.24.png

"neuron" ในโครงข่ายระบบประสาทเทียมแบบสรุปรวมอินพุตทั้งหมด เพิ่มค่าคงที่ที่เรียกว่า ""bias" แล้วให้ผลลัพธ์ผ่าน"ฟังก์ชันการเปิดใช้งาน&quotแบบไม่เป็นเชิงเส้น "weights" และ "biases" คือพารามิเตอร์ที่จะระบุผ่านการฝึก ระบบจะเริ่มต้นด้วยค่าแบบสุ่มในตอนแรก

รูปภาพด้านบนแสดงโครงข่ายระบบประสาทเทียม 1 ชั้นที่มีเซลล์ประสาทเอาต์พุต 10 เซลล์ เนื่องจากเราต้องการจัดประเภทตัวเลขเป็น 10 คลาส (0 ถึง 9)

มีการคูณเมทริกซ์

วิธีการที่เลเยอร์โครงข่ายระบบประสาทเทียมที่ประมวลผลคอลเล็กชันรูปภาพอาจแสดงโดยการคูณเมทริกซ์ดังนี้

matmul.gif

เราคํานวณผลรวมของการถ่วงน้ําหนักของพิกเซลทั้งหมดของรูปภาพแรกโดยใช้คอลัมน์แรกของน้ําหนักในเมทริกซ์น้ําหนัก ผลรวมนี้ตรงกับเซลล์ประสาทแรก เราจะควบคุมแบบเดียวกันกับเซลล์เซลล์ที่ 2 และเซลล์ประสาทจนถึงวันที่ 10 ด้วย จากนั้น เราจะดําเนินการกับรูปภาพ 99 รูปที่เหลือซ้ําได้ หากเราเรียกว่า X เมทริกซ์ที่มีรูปภาพ 100 ภาพ ผลรวมของน้ําหนักที่ถ่วงน้ําหนักทั้งหมดสําหรับ 10 เซลล์ของเรา ที่คํานวณด้วยรูปภาพ 100 ภาพจะเป็น X.W ซึ่งก็คือการคูณเมทริกซ์

ตอนนี้เซลล์ประสาทแต่ละค่าจะต้องเพิ่มการให้น้ําหนักพิเศษของเซลล์นั้น (ค่าคงที่) เรามีเซลล์ประสาท 10 เซลล์ เราจึงมีการให้น้ําหนักพิเศษ 10 เซลล์ เราจะเรียกเวกเตอร์นี้ของ 10 ค่า b คุณต้องเพิ่มในแต่ละบรรทัดของเมทริกซ์ที่คํานวณไว้ก่อนหน้านี้ การใช้เวทมนตร์ที่มีชื่อว่า "broadcasting" เราจะเขียนสิ่งนี้ด้วยเครื่องหมายบวกง่ายๆ

ท้ายที่สุดแล้วเราใช้ฟังก์ชันเปิดใช้งาน เช่น "softmax" (อธิบายด้านล่าง) และรับสูตรที่อธิบายเครือข่ายระบบประสาทเทียมแบบ 1 ชั้น ซึ่งนําไปใช้กับรูปภาพ 100 รูป ดังนี้

Screen Shot 2016-07-26 เวลา 16.02.36.png

ใน Keras

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

tf.keras.layers.Dense(10, activation='softmax')

เจาะลึก

การสร้างโครงข่ายโครงข่ายประสาทเทียม เลเยอร์แรกจะคํานวณผลรวมของการถ่วงน้ําหนักพิกเซล เลเยอร์ที่ตามมาจะคํานวณผลรวมของน้ําหนักที่ถ่วงน้ําหนักของเลเยอร์ก่อนหน้า

ความแตกต่างเพียงอย่างเดียวจากจํานวนเซลล์ประสาทคือตัวเลือกของฟังก์ชันการเปิดใช้งาน

ฟังก์ชันการเปิดใช้งาน: relu, softmax และ Sigmoid

โดยทั่วไปคุณอาจจะใช้ฟังก์ชันการเปิดใช้งาน "relu" สําหรับเลเยอร์ทั้งหมดยกเว้นส่วนสุดท้าย เลเยอร์สุดท้ายในตัวแยกประเภทจะใช้การเปิดใช้งาน "softmax"

& aquot;neuron" คํานวณผลรวมที่ถ่วงน้ําหนักของอินพุตทั้งหมด เพิ่มค่าที่เรียกว่า "bias" และป้อนผลลัพธ์ผ่านฟังก์ชันการเปิดใช้งาน

ฟังก์ชันการเปิดใช้งานที่ได้รับความนิยมสูงสุดเรียกว่า "RELU" สําหรับหน่วยเชิงเส้นแบบคงที่ ซึ่งเป็นฟังก์ชันง่ายๆ อย่างที่คุณเห็นในกราฟด้านบน

ฟังก์ชันการเปิดใช้งานแบบดั้งเดิมในโครงข่ายระบบประสาทเทียมคือ "sigmoid" แต่ระบบแสดง "relu" ให้มีพร็อพเพอร์ตี้การเชื่อมที่ดีขึ้นเกือบทุกที่

การเปิดใช้งาน Softmax สําหรับการแยกประเภท

โครงข่ายระบบประสาทเทียมส่วนสุดท้ายของเรามีเซลล์ประสาท 10 เซลล์ เนื่องจากเราต้องการจัดประเภทตัวเลขที่เขียนด้วยลายมือเป็น 10 คลาส (0,..9) เอาต์พุตควรเป็นตัวเลข 10 จํานวนระหว่าง 0 ถึง 1 แทนความน่าจะเป็นของตัวเลขนี้เป็น 0, 1, 2 และอื่นๆ ในเลเยอร์สุดท้าย เราจะใช้ฟังก์ชันการเปิดใช้งานที่เรียกว่า "softmax"

การใช้ Softmax กับเวกเตอร์จะดําเนินการโดยคูณเลขคูณขององค์ประกอบแต่ละรายการ แล้วนํามาทําให้เป็นเวกเตอร์นั้นตามปกติ โดยการหารค่านั้นด้วย "L1" ค่ามาตรฐาน (เช่น ผลรวมของค่าสัมบูรณ์) เพื่อค่าที่เป็นค่ามาตรฐานจะเพิ่มเป็น 1 และตีความเป็นความน่าจะเป็นได้

เอาต์พุตของเลเยอร์สุดท้ายก่อนเรียกใช้บางครั้งเรียกว่า "logits" หากเวกเตอร์นี้คือ L = [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9]:

การสูญเสียไขมันเอนโทรปี

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

ระยะทางไหนก็ใช่ แต่สําหรับปัญหาการแยกประเภท จะเรียกว่า "โควต้าการปล่อยก๊าซเรือนกระจก" และมีประสิทธิภาพมากที่สุด เราเรียกสิ่งนี้ว่าข้อผิดพลาดหรือฟังก์ชัน "loss"

การไล่ระดับแบบไล่ระดับสี

"Training" โครงข่ายระบบประสาทเทียมหมายถึงการใช้ภาพและฉลากการฝึกเพื่อปรับน้ําหนักและการให้น้ําหนักพิเศษ เพื่อลดฟังก์ชันการสูญเสียครอสเอนโทรปี วิธีการมีดังนี้

ครอสเอนโทรปีเป็นหน้าที่ของน้ําหนัก การให้น้ําหนักพิเศษ พิกเซลของรูปภาพการฝึก และคลาสที่รู้จัก

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

การไล่ระดับสี descent2.png

การต่อสู้กันเล็กน้อยและแรงกระตุ้น

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

เทคนิคนี้บางครั้งเรียกว่า "stochastic การไล่ระดับสี descent" มีประโยชน์ที่ใช้ประโยชน์ได้จริงมากกว่าอีกแบบหนึ่งคือ การทํางานกับกลุ่มหมายถึงการทํางานกับเมทริกซ์ที่ใหญ่ขึ้นและมักเพิ่มประสิทธิภาพด้วย GPU และ TPU ได้ง่ายขึ้น

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

ภาพประกอบ: จุดอานม้า การไล่ระดับสีเป็น 0 แต่ไม่ต่ําสุดในทุกทิศทาง (การระบุแหล่งที่มาของรูปภาพ Wikimedia: โดย Nicoguaro - งานของตนเอง CC BY 3.0)

วิธีแก้ปัญหาคือการเพิ่มกระแสความนิยมลงในอัลกอริทึมการเพิ่มประสิทธิภาพเพื่อให้เรือใบผ่านจุดอานม้าได้โดยไม่หยุด

อภิธานศัพท์

การทํางานเป็นกลุ่มหรือมินิแบตช์: การฝึกอบรมจะดําเนินการเป็นกลุ่มของข้อมูลและป้ายกํากับการฝึกอบรมเสมอ เพราะจะช่วยให้อัลกอริทึมเชื่อมกัน "batch" มิติข้อมูลโดยทั่วไปคือมิติข้อมูลแรกของ Tensor ข้อมูล เช่น Tenor ของรูปร่าง [100, 192, 192, 3] จะมีรูปภาพขนาด 192x192 พิกเซลจํานวน 100 ภาพที่มี 3 ค่าต่อพิกเซล (RGB)

การสูญเสียจากครอสเอนโทรปี: ฟังก์ชันการสูญเสียพิเศษที่มักใช้ในตัวแยกประเภท

เลเยอร์ที่หนาแน่น: เลเยอร์ของเซลล์ประสาทที่เซลล์ประสาทแต่ละชั้นเชื่อมต่อกับเซลล์ทั้งหมดในเลเยอร์ก่อนหน้า

ฟีเจอร์: บางครั้งอินพุตของเครือข่ายโครงข่ายประสาทจะเรียกว่า "features" ศิลปะการคิดหาส่วนต่างๆ ของชุดข้อมูล (หรือชุดค่าผสมของชิ้นส่วน) ที่จะใส่ลงในโครงข่ายระบบประสาทเทียมเพื่อการคาดเดาที่ดีเรียกว่า "feature Engineering"

labels: ชื่ออื่นสําหรับ "classes" หรือแก้ไขคําตอบที่ถูกต้องในการแยกประเภทการควบคุมดูแล

อัตราการเรียนรู้: สัดส่วนของการไล่ระดับสีที่น้ําหนักและการให้น้ําหนักพิเศษจะอัปเดตทุกครั้งที่วนซ้ําวนซ้ํา

logits: เอาต์พุตของเลเยอร์ของเซลล์ประสาทก่อนใช้ฟังก์ชันการเรียกใช้จะเรียกว่า "logits" คํานี้มาจาก "logicalฟังก์ชัน" หรือที่เรียกว่า "sigmoidฟังก์ชัน" ซึ่งเคยเป็นฟังก์ชันเปิดใช้งานที่ได้รับความนิยมสูงสุด "ผลลัพธ์ในยุโรปก่อนฟังก์ชันโลจิสติกส์และย่อให้สั้นลง "logits"

loss: ฟังก์ชันข้อผิดพลาดที่เปรียบเทียบเอาต์พุตของโครงข่ายระบบประสาทเทียมกับคําตอบที่ถูกต้อง

neuron: คํานวณผลรวมของน้ําหนักของอินพุต เพิ่มการให้น้ําหนักพิเศษ และฟีดผลลัพธ์ผ่านฟังก์ชันการเปิดใช้งาน

การเข้ารหัสแบบครั้งเดียว: คลาส 3 จาก 5 เข้ารหัสเป็นเวกเตอร์ของเอลิเมนต์ 5 รายการ เลขศูนย์ทั้งหมดยกเว้นเลข 3 ซึ่งก็คือ 1

relu: หน่วยเชิงเส้นแบบคงที่ ฟังก์ชันเปิดใช้งานยอดนิยมของเซลล์ประสาท

sigmoid: ฟังก์ชันการเปิดใช้งานอื่นที่เคยได้รับความนิยมและยังคงมีประโยชน์ในกรณีพิเศษ

softmax: ฟังก์ชันการเปิดใช้งานพิเศษที่ทําหน้าที่เป็นเวกเตอร์ ทั้งยังเพิ่มความแตกต่างระหว่างคอมโพเนนต์ที่ใหญ่ที่สุดและองค์ประกอบอื่นๆ ทั้งหมด และยังปรับเวกเตอร์ให้เป็นมาตรฐานเพื่อให้มีผลรวมเป็น 1 เพื่อให้ระบบตีความเป็นเวกเตอร์ของความน่าจะเป็นได้ ใช้เป็นขั้นตอนสุดท้ายในตัวแยกประเภท

tensor: A "tensor" เป็นเหมือนเมทริกซ์ แต่มีจํานวนมิติข้อมูลที่กําหนดเอง ตัวปรับขนาด 1 มิติคือเวกเตอร์ ตัวสแกน 2 มิติคือเมทริกซ์ จากนั้นคุณสามารถมี Tensor ที่มีขนาด 3, 4, 5 หรือหลายรายการ

กลับไปที่สมุดบันทึกการศึกษา และครั้งนี้ให้อ่านรหัสกัน

keras_01_mnist.ipynb

มาดูเซลล์ทั้งหมดในสมุดบันทึกนี้กัน

C &llt;Parameters"

กําหนดขนาดกลุ่ม จํานวน Epoch การฝึก และตําแหน่งของไฟล์ข้อมูล ไฟล์ข้อมูลจะโฮสต์อยู่ในที่เก็บข้อมูล Google Cloud Storage (GCS) ซึ่งเป็นเหตุผลที่อีเมลขึ้นต้นด้วย gs://

C &llt;Imports"

ไลบรารี Python ที่จําเป็นทั้งหมดถูกนําเข้าที่นี่ รวมถึง TensorFlow และ Matmattlib สําหรับการแสดงภาพด้วย

เซลล์ "ยูทิลิตี ภาพ [RUN ME]"

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

Cell "tf.data.Dataset: แยกวิเคราะห์ไฟล์และเตรียมชุดข้อมูลการฝึกอบรมและการตรวจสอบ"

เซลล์นี้ใช้ tf.data.Dataset API เพื่อโหลดชุดข้อมูล MNIST เพื่อสร้างไฟล์ข้อมูล ไม่จําเป็นต้องใช้เวลากับเซลล์นี้มากเกินไป หากสนใจ tf.data.Dataset API โปรดดูบทแนะนําที่หัวข้อไปป์ไลน์ข้อมูลความเร็ว TPU ข้อมูลพื้นฐานมีดังนี้

รูปภาพและป้ายกํากับ (คําตอบที่ถูกต้อง) จากชุดข้อมูล MNIST จะเก็บไว้ในระเบียนความยาวคงที่ในไฟล์ 4 ไฟล์ ไฟล์จะโหลดด้วยฟังก์ชันระเบียนคงที่โดยเฉพาะดังนี้

imagedataset = tf.data.FixedLengthRecordDataset(image_filename, 28*28, header_bytes=16)

ตอนนี้เรามีชุดข้อมูลของไบต์รูปภาพแล้ว และต้องถอดรหัสเป็นรูปภาพ เรากําหนดฟังก์ชันสําหรับการดําเนินการดังกล่าว รูปภาพจะไม่ถูกบีบอัด ดังนั้นฟังก์ชันดังกล่าวไม่จําเป็นต้องถอดรหัสข้อมูลใดๆ (decode_raw ไม่ต้องทําอะไรเลย) รูปภาพจะถูกแปลงเป็นค่าลอยตัวระหว่าง 0 ถึง 1 เราสามารถปรับรูปร่างใหม่ในส่วนนี้เป็นรูปภาพ 2 มิติได้ แต่จริงๆ แล้วเราทําให้เป็นพิกเซลขนาดคงที่ขนาด 28*28 พิกเซล ซึ่งเป็นสิ่งที่เลเยอร์แรกเริ่มที่เราคาดการณ์ไว้

def read_image(tf_bytestring):
    image = tf.decode_raw(tf_bytestring, tf.uint8)
    image = tf.cast(image, tf.float32)/256.0
    image = tf.reshape(image, [28*28])
    return image

เราจะใช้ฟังก์ชันนี้กับชุดข้อมูลโดยใช้ .map และรับชุดข้อมูลของรูปภาพ

imagedataset = imagedataset.map(read_image, num_parallel_calls=16)

เราอ่านและถอดรหัสป้ายกํากับเดียวกัน รวมถึง.zipรูปภาพและป้ายกํากับร่วมกันดังนี้

dataset = tf.data.Dataset.zip((imagedataset, labelsdataset))

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

dataset = dataset.cache()
dataset = dataset.shuffle(5000, reshuffle_each_iteration=True)
dataset = dataset.repeat()
dataset = dataset.batch(batch_size)
dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)

tf.data.Dataset API มีฟังก์ชันยูทิลิตีที่จําเป็นทั้งหมดสําหรับเตรียมชุดข้อมูล ดังนี้

.cache แคชชุดข้อมูลไว้ใน RAM นี่เป็นชุดข้อมูลขนาดเล็กที่ใช้งานได้ .shuffle จะสุ่มเพลงด้วยบัฟเฟอร์องค์ประกอบ 5,000 องค์ประกอบ การสับเปลี่ยนข้อมูลการฝึกเป็นสิ่งสําคัญ .repeat วนซ้ําชุดข้อมูล เราจะฝึกหัดในการฝึกอบรมหลายครั้ง (หลายช่วงเวลา) .batch จะดึงรูปภาพและป้ายกํากับหลายรายการมารวมในมินิขนาดเล็ก และสุดท้าย .prefetch สามารถใช้ CPU เพื่อเตรียมกลุ่มถัดไปขณะที่กําลังฝึกกลุ่มปัจจุบันบน GPU

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

Cell "Keras Model"

โมเดลทั้งหมดของเราจะเป็นลําดับของเลเยอร์โดยตรง เพื่อให้เราใช้รูปแบบ tf.keras.Sequential ในการสร้างได้ ในตอนแรก มันเป็นชั้นที่หนาทึบเดียว เรามีเซลล์ประสาท 10 เซลล์เนื่องจากเรากําลังจัดประเภทตัวเลขด้วยลายมือเป็น 10 คลาส โดยจะใช้ "softmax" การเปิดใช้งานเพราะเป็นชั้นสุดท้ายในตัวแยกประเภท

โมเดล Keras ยังต้องทราบรูปร่างของอินพุต ใช้ tf.keras.layers.Input เพื่อกําหนดได้ ในที่นี้ เวกเตอร์อินพุตคือเวกเตอร์คงที่ของค่าพิกเซลที่มีความยาว 28*28

model = tf.keras.Sequential(
  [
    tf.keras.layers.Input(shape=(28*28,)),
    tf.keras.layers.Dense(10, activation='softmax')
  ])

model.compile(optimizer='sgd',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# print model layers
model.summary()

# utility callback that displays training curves
plot_training = PlotTraining(sample_rate=10, zoom=1)

การกําหนดค่าโมเดลจะดําเนินการใน Keras โดยใช้ฟังก์ชัน model.compile เราใช้เครื่องมือเพิ่มประสิทธิภาพพื้นฐาน 'sgd' (Stochastic Gradient Descent) โมเดลการแยกประเภทต้องใช้ฟังก์ชันการสูญเสียเอนโทรปีที่เรียกว่า 'categorical_crossentropy' ใน Keras ประการสุดท้าย เราขอให้โมเดลคํานวณเมตริก 'accuracy' ซึ่งเป็นเปอร์เซ็นต์ของรูปภาพที่จัดประเภทอย่างถูกต้อง

Keras ใช้ประโยชน์ด้าน model.summary() ที่พิมพ์รายละเอียดของโมเดลที่คุณสร้างไว้ ผู้สอนประเภทของคุณได้เพิ่มยูทิลิตี PlotTraining (กําหนดไว้ใน "ยูทิลิตี้ภาพและเซลล์) ซึ่งจะแสดงเส้นโค้งของการฝึกต่างๆ ในระหว่างการฝึก

เซลล์ "ฝึกและตรวจสอบโมเดล&quot

นี่คือสถานที่สําหรับการฝึกอบรม โดยเรียกใช้ model.fit และส่งชุดข้อมูลการฝึกอบรมและการตรวจสอบ โดยค่าเริ่มต้น Keras จะดําเนินการตรวจสอบจนเสร็จเมื่อถึง 1 Epoch

model.fit(training_dataset, steps_per_epoch=steps_per_epoch, epochs=EPOCHS,
          validation_data=validation_dataset, validation_steps=1,
          callbacks=[plot_training])

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

Cell "แสดงภาพการคาดคะเน

เมื่อฝึกโมเดลแล้ว เราจะรับการคาดการณ์จากโมเดลได้โดยเรียกใช้ model.predict(): 

probabilities = model.predict(font_digits, steps=1)
predicted_labels = np.argmax(probabilities, axis=1)

เราได้เตรียมชุดตัวเลขที่พิมพ์จากแบบอักษรในพื้นที่เพื่อเป็นการทดสอบ โปรดทราบว่าโครงข่ายระบบประสาทเทียมจะแสดงเวกเตอร์ของความน่าจะเป็น 10 รายการจากค่าสุดท้าย "softmax" เราต้องดูว่าความน่าจะเป็นสูงสุดอยู่ในระดับใดเพื่อให้ได้ป้ายกํากับ np.argmax จากไลบรารีตัวเลขจะทําเช่นนั้น

เพื่อทําความเข้าใจว่าเหตุใดจึงต้องมีพารามิเตอร์ axis=1 โปรดทราบว่าเราได้ประมวลผลชุดรูปภาพ 128 ภาพแล้ว ดังนั้นโมเดลจึงแสดงเวกเตอร์ความน่าจะเป็น 128 ชุด รูปร่างของ Tensor เอาต์พุตคือ [128, 10] เรากําลังคํานวณอาร์กิวเมนต์ argmax ในความน่าจะเป็น 10 รายการที่แสดงผลแต่ละภาพ ดังนั้น axis=1 (แกนแรกคือ 0)

โมเดลง่ายๆ นี้รู้จักตัวเลข 90% อยู่แล้ว ไม่แย่ แต่คุณต้องปรับปรุงให้ดีขึ้นอย่างมาก

Godeep.png

เราจะเพิ่มเลเยอร์อื่นๆ ในโครงข่ายระบบประสาทเทียมเพื่อปรับปรุงความแม่นยําในการจดจํา

Screen Shot 2016-07-27 เวลา 15.36.55.png

เราเก็บ Softmax เป็นฟังก์ชันเปิดใช้งานในเลเยอร์สุดท้าย เพราะนั่นคือสิ่งที่ดีที่สุดสําหรับการแยกประเภท ในเลเยอร์ระดับกลาง แต่เราจะใช้ฟังก์ชันการเปิดใช้งานแบบคลาสสิก: sigmoid:

ตัวอย่างเช่น โมเดลของคุณจะมีลักษณะเช่นนี้ (อย่าลืมคอมมา tf.keras.Sequential จะใช้รายการเลเยอร์ที่คั่นด้วยคอมมา)

model = tf.keras.Sequential(
  [
      tf.keras.layers.Input(shape=(28*28,)),
      tf.keras.layers.Dense(200, activation='sigmoid'),
      tf.keras.layers.Dense(60, activation='sigmoid'),
      tf.keras.layers.Dense(10, activation='softmax')
  ])

ดู "summary" โมเดลของคุณ ตอนนี้มีพารามิเตอร์อย่างน้อย 10 เท่า ทําได้ดีกว่าถึง 10 เท่า! แต่ด้วยเหตุผลบางอย่าง นี่ไม่ใช่ ...

การสูญเสียก็อาจมีการยิงผ่านหลังคาด้วย มีบางอย่างไม่ถูกต้อง

คุณเพิ่งจะได้พบกับโครงข่ายระบบประสาทเทียม เนื่องจากผู้คนเคยออกแบบสิ่งเหล่านั้นในยุค 80 และ 99 และ 90 ไม่น่าแปลกใจเลยที่แนวคิดเหล่านี้มีต่อเรา! คือคํากล่าวที่ว่า ""AI Winter" อันที่จริงแล้ว เมื่อเพิ่มเลเยอร์ โครงข่ายระบบประสาทเทียมก็ยากมากขึ้นในการรวม

ดูเหมือนว่าเครือข่ายโครงข่ายประสาทแบบลึกที่มีหลายเลเยอร์ (20, 50 หรือ 100 ในปัจจุบัน) ทํางานได้ดีมาก ใช้กลการสกปรกทางคณิตศาสตร์ 2 ข้อเพื่อทําให้ประหลาดใจ การค้นพบเคล็ดลับง่ายๆ เหล่านี้คือหนึ่งในตัวอย่างของการฟื้นฟูการเรียนรู้เชิงลึกในปี 2010&#39

การเปิดใช้งาน RELU

relu.png

ฟังก์ชันการเปิดใช้งานซิกโมด์เป็นปัญหาที่ซับซ้อนมากในเครือข่ายที่ลึก โดยจะบีบค่าทั้งหมดระหว่าง 0 ถึง 1 และเมื่อคุณทําขั้นตอนนี้ซ้ําๆ เอาต์พุตของเซลล์ประสาทและการไล่ระดับสีอาจหายไปทั้งหมด โดยกล่าวถึงด้วยเหตุผลทางประวัติศาสตร์ แต่เครือข่ายสมัยใหม่ใช้ RELU (Rectified Linear Unit) ซึ่งมีลักษณะดังนี้

ในทางกลับกัน ลําธารที่ไม่ซ้ําจะมีอนุพันธ์ของ 1 เป็นอย่างน้อย การเปิดใช้งาน RELU ถึงแม้ว่าการไล่ระดับสีที่มาจากเซลล์ประสาทบางเซลล์อาจเป็น 0 ได้ แต่ก็มีบางสีที่ทดสอบการไล่ระดับสีที่ไม่ใช่ศูนย์อย่างชัดเจน และการฝึกก็ดําเนินต่อได้ในเวลาที่ดี

นักเพิ่มประสิทธิภาพที่ดีขึ้น

ในพื้นที่ที่มีมิติข้อมูลมากเช่นนี้ เรามีลําดับของน้ําหนัก 10,000 ลําดับและการให้น้ําหนักพิเศษ {/0} จุดเหล่านี้ไม่ใช่ค่าขั้นต่ําในท้องถิ่น แต่การไล่ระดับสียังคงเป็น 0 ส่วนเครื่องมือเพิ่มประสิทธิภาพการไล่ระดับการไล่ระดับสีจะค้างอยู่ที่จุดนั้น TensorFlow มีเครื่องมือเพิ่มประสิทธิภาพที่มีให้เลือกใช้มากมาย รวมถึงเครื่องมือบางอย่างที่ทํางานด้วยแรงเฉื่อยได้หลายระดับและจะผ่านจุดอานม้าได้อย่างปลอดภัย

การเริ่มต้นแบบสุ่ม

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

คุณไม่ต้องดําเนินการใดๆ เนื่องจาก Keras จะดําเนินการในสิ่งที่ถูกต้องแล้ว

NaN ???

สูตรครอสเอนโทรปีประกอบด้วยลอการิทึม และ ((0) ไม่ใช่ตัวเลข (NaN, ข้อขัดข้องที่เป็นตัวเลข หากต้องการ) อินพุตสําหรับเอนโทรปีเป็น 0 ได้ไหม อินพุตมาจาก Softmax ซึ่งเป็นฟังก์ชันเลขชี้กําลังและเลขชี้กําลังจะไม่เป็นศูนย์ เราจึงปลอดภัย

จริงหรือไม่ ในโลกของคณิตศาสตร์ที่สวยงาม เราจะปลอดภัย แต่โลกคอมพิวเตอร์ exp(-150) ที่แสดงในรูปแบบ Flo332 เป็น ZERO ตามที่ได้รับและการขัดข้องของเอนโทรปี

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

สําเร็จไหม

ตอนนี้คุณควรมีความแม่นยําถึง 97% แล้ว เป้าหมายของเวิร์กช็อปนี้คือการทําให้คะแนนสูงกว่า 99% อย่างมาก ดังนั้นมาลุยกันต่อเลย

หากยังพบปัญหาอยู่ โปรดดูวิธีแก้ปัญหาดังนี้

keras_02_mnist_dense.ipynb

เราอาจจะลองฝึกให้เร็วขึ้นได้ อัตราการเรียนรู้เริ่มต้นของเครื่องมือเพิ่มประสิทธิภาพ Adam คือ 0.001 มาลองเพิ่มกันดีกว่า

การทํางานได้เร็วกว่านั้นมักไม่ได้ช่วยอะไรมากเลย แต่เสียงรบกวนทั้งหมดนี้คืออะไร

เส้นโค้งการฝึกดังกล่าวจะมีเสียงดังมากและมีลักษณะโค้งของการตรวจสอบทั้ง 2 แบบ ได้แก่ การกระโดดขึ้นและลง ซึ่งหมายความว่าเราจะเร็วเกินไป เราอาจย้อนกลับไปที่ความเร็วก่อนหน้านี้ได้ แต่มีวิธีที่ดีกว่านี้

ช้าลง.

วิธีแก้ปัญหาที่ดีคือเริ่มต้นใช้งานอย่างรวดเร็วและเสื่อมสภาพการเรียนรู้ในอัตราทวีคูณ ใน Keras คุณดําเนินการนี้ได้โดยใช้โค้ดเรียกกลับ tf.keras.callbacks.LearningRateScheduler

โค้ดที่เป็นประโยชน์สําหรับการคัดลอกและวาง:

# lr decay function
def lr_decay(epoch):
  return 0.01 * math.pow(0.6, epoch)

# lr schedule callback
lr_decay_callback = tf.keras.callbacks.LearningRateScheduler(lr_decay, verbose=True)

# important to see what you are doing
plot_learning_rate(lr_decay, EPOCHS)

อย่าลืมใช้ lr_decay_callback ที่คุณสร้างขึ้น เพิ่มไปยังรายการโค้ดเรียกกลับใน model.fit:

model.fit(...,  callbacks=[plot_training, lr_decay_callback])

การเปลี่ยนแปลงเพียงเล็กน้อยนี้สร้างผลกระทบได้มาก คุณเห็นว่าเสียงรบกวนส่วนใหญ่หายไป และตอนนี้การทดสอบมีความแม่นยํามากกว่า 98% ในระยะยาว

โมเดลกําลังเริ่มคลาดเคลื่อนได้ดี มาลองเจาะลึกรายละเอียดกันมากขึ้น

มีประโยชน์ไหม

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

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

ยกเลิก

การยกเลิกการเชื่อมต่อนี้มักเรียกว่า "Overfitting" เมื่อเห็นข้อมูลดังกล่าว คุณอาจลองใช้เทคนิคการปรับให้สอดคล้องตามมาตรฐานชื่อ "dropout" เทคนิคการยิงออกจะยิงเซลล์ประสาทแบบสุ่มที่การฝึกซ้ําแต่ละครั้ง

ทำงานได้ดีหรือไม่

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

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

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

Overfitting.png

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

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

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

อย่าลืมว่าเราใช้รูปภาพของเราโดยแยกเป็นเวกเตอร์เดียวได้อย่างไร เป็นความคิดที่แย่จริงๆ ตัวเลขที่เขียนด้วยลายมือประกอบไปด้วยรูปทรงต่างๆ และเราได้ทิ้งข้อมูลรูปร่างไว้เมื่อแยกพิกเซล อย่างไรก็ตาม มีโครงข่ายระบบประสาทเทียมที่ใช้ประโยชน์จากข้อมูลรูปทรงได้ เช่น เครือข่ายปฏิวัติ ให้เราลองใช้

หากยังพบปัญหาอยู่ โปรดดูวิธีแก้ปัญหาดังนี้

keras_03_mnist_dense_lrdecay_dropout.ipynb

สรุป

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

convolutional.gif

ภาพประกอบ: การกรองรูปภาพด้วยฟิลเตอร์ต่อเนื่องกัน 2 ภาพซึ่งสร้างจากน้ําหนัก 4x4x3=48 ที่เรียนรู้ได้แต่ละตัว

โครงข่ายระบบประสาทเทียมเชิงรับปฏิกิริยามีลักษณะดังนี้ใน Keras

model = tf.keras.Sequential([
    tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(kernel_size=3, filters=12, activation='relu'),
    tf.keras.layers.Conv2D(kernel_size=6, filters=24, strides=2, activation='relu'),
    tf.keras.layers.Conv2D(kernel_size=6, filters=32, strides=2, activation='relu'),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(10, activation='softmax')
])

ในเลเยอร์ของเครือข่ายการปฏิวัติ One "neuron" รวมกันแบบถ่วงน้ําหนักของพิกเซลเหนือพื้นที่ใดๆ ในพื้นที่ขนาดเล็กของรูปภาพเท่านั้น โดยจะเพิ่มการให้น้ําหนักพิเศษและฟีดผลโดยรวมผ่านฟังก์ชันการเปิดใช้งาน เช่นเดียวกับเซลล์ประสาทในชั้นที่หนาแน่นปกติ จากนั้นระบบจะดําเนินการนี้กับรูปภาพทั้งหมดโดยใช้น้ําหนักเท่ากัน โปรดทราบว่าในชั้นที่หนาแน่น เซลล์ประสาทแต่ละเซลล์จะมีน้ําหนักเป็นของตัวเอง ที่นี่ &"patch" ของน้ําหนักสไลด์ในรูปภาพทั้ง 2 ทิศทาง (&"convolution") เอาต์พุตมีค่ามากเท่ากับพิกเซลในรูปภาพ (แม้ว่าระยะห่างจากขอบอาจจําเป็นที่ขอบ) ซึ่งเป็นการดําเนินการกรอง ในภาพประกอบด้านบน มีการใช้ตัวกรอง 4x4x3=48 น้ําหนัก

อย่างไรก็ตาม น้ําหนัก 48 ไม่เพียงพอ เพื่อเป็นการเพิ่มเสรีภาพในการทําซ้ํา เราจะทําซ้ําการดําเนินการเดียวกันด้วยน้ําหนักชุดใหม่ วิธีนี้จะสร้างเอาต์พุตของตัวกรองชุดใหม่ งั้นขอเรียกว่า ""channel" ของผลลัพธ์โดยเทียบเคียงกับช่อง R,G,B ในรูปภาพอินพุต

Screen Shot 2016-07-29 เวลา 16.02.37.png

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

ภาพประกอบ: โครงข่ายระบบประสาทเทียมที่ปฏิรูปโดยเปลี่ยน "cubes"ข้อมูลไปเป็น "cubes"ข้อมูลอื่นๆ

การปฏิวัติที่เข้มงวด การรวมเข้าด้วยกันสูงสุด

การปฏิวัติการประมวลผลข้อมูลด้วยขั้นตอน 2 หรือ 3 จะทําให้ช่องข้อมูลมีขนาดเล็กลงในแนวนอน ซึ่งทําได้ 2 วิธีด้วยกัน ดังนี้

  • การปฏิวัติครั้งหนึ่ง: ฟิลเตอร์เลื่อนด้านบนแต่มีทางเท้า >1
  • การรวมเข้าด้วยกันสูงสุด: หน้าต่างเลื่อนที่ใช้การดําเนินการ Max (โดยทั่วไปคือบนแพตช์ 2x2 ทําซ้ําทุก 2 พิกเซล)

ภาพประกอบ: การเลื่อนหน้าต่างการประมวลผลทีละ 3 พิกเซลจะทําให้ค่าเอาต์พุตน้อยลง การคดเคี้ยวที่คดเคี้ยวหรือการรวมน้ําสูงสุด (สูงสุดบนหน้าต่างขนาด 2x2 ที่เลื่อนไปตามจังหวะการก้าวของ 2) เป็นวิธีลดขนาดลูกบาศก์ในขนาดแนวนอน

เลเยอร์สุดท้าย

หลังเลเยอร์การปฏิวัติล่าสุด ข้อมูลจะอยู่ในรูปแบบ "cube" การให้อาหารผ่านเลเยอร์ที่หนาทึบมี 2 วิธีดังนี้

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

นอกจากการแบ่งชั้นที่มีราคาสูงแล้ว เรายังแบ่งข้อมูลที่เข้ามาใหม่ได้ด้วย "cube" แบ่งเป็นส่วนๆ หลายๆ ชั้น, เฉลี่ยค่าดังกล่าวและฟีดผ่านฟังก์ชันการเปิดใช้งาน Softmax วิธีสร้างส่วนหัวการแยกประเภทจะใช้น้ําหนัก 0 ใน Keras จะมีเลเยอร์สําหรับ: tf.keras.layers.GlobalAveragePooling2D()

ข้ามไปที่ส่วนถัดไปเพื่อสร้างเครือข่ายการปฏิวัติสําหรับปัญหาที่มีอยู่

ให้เราสร้างเครือข่ายการปฏิวัติการจดจําตัวเลขด้วยลายมือ เราจะใช้เลเยอร์การปฏิวัติ 3 ชั้นที่ด้านบน โดยเป็นเลเยอร์แบบซอฟต์แม็กซ์แบบดั้งเดิมที่ด้านล่างและเชื่อมต่อด้วยชั้นที่เชื่อมต่ออย่างสมบูรณ์แบบเดียว ดังนี้

โปรดสังเกตว่าเลเยอร์การปฏิวัติชั้นที่ 2 และ 3 นั้นมี 2 ชั้นซึ่งอธิบายสาเหตุที่นําจํานวนเอาต์พุตออกจาก 28x28 เป็น 14x14 และ 7x7

มาเขียนโค้ด Keras กันเถอะ

จําเป็นต้องให้ความสนใจเป็นพิเศษก่อนการปฏิวัติชั้นแรก ที่จริงแล้ว คาดว่าต้องมีข้อมูล 3D ‘cube' แต่ชุดข้อมูลของเราตั้งค่าจนถึงตอนนี้สําหรับเลเยอร์ที่หนาแน่นและทุกพิกเซลของรูปภาพจะแยกออกเป็นเวกเตอร์ เราต้องปรับแต่งรูปร่างใหม่ให้เป็นรูปภาพขนาด 28x28x1 (1 ช่องสําหรับรูปภาพสีเทา)

tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1))

คุณใช้บรรทัดนี้แทนที่จะใช้เลเยอร์ tf.keras.layers.Input ที่มีอยู่ได้ในตอนนี้

ใน Keras ไวยากรณ์สําหรับเลเยอร์ "การปฏิวัติ" ที่เปิดใช้งานคือ:

tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu')

สําหรับแนวคิดที่โหดเหี้ยม คุณจะต้องเขียนว่า

tf.keras.layers.Conv2D(kernel_size=6, filters=24, padding='same', activation='relu', strides=2)

ในการแยกส่วนลูกบาศก์เป็นเวกเตอร์เพื่อให้ใช้ในเลเยอร์ที่หนาแน่นได้ ให้ทําดังนี้

tf.keras.layers.Flatten()

และสําหรับชั้นที่หนาแน่น ไวยากรณ์ก็จะไม่เปลี่ยนแปลง ดังนี้

tf.keras.layers.Dense(200, activation='relu')

โมเดลของคุณทําให้อุปสรรคมีความแม่นยําถึง 99% ใช่ไหม ใกล้แล้ว... แต่ดูเส้นโค้งการเสียการตรวจสอบ รุ่นนี้ส่งเสียงกริ่งไหม

ดูการคาดการณ์ด้วย นี่เป็นครั้งแรกที่คุณจะเห็นว่าตัวเลขการทดสอบส่วนใหญ่ 10,000 หลักได้รับการยอมรับอย่างถูกต้อง มีการตรวจจับที่ไม่ถูกต้องประมาณ 41⁄2 แถวเท่านั้น (ประมาณ 110 หลักจาก 10,000 แถว)

หากยังพบปัญหาอยู่ โปรดดูวิธีแก้ปัญหาดังนี้

keras_04_mnist_convolutional.ipynb

การฝึกอบรมก่อนหน้านี้ได้แสดงสัญญาณที่ชัดเจนว่ามากเกินปกติ (และยังคงขาดความแม่นยํา 99%) เราควรลองยกเลิกอีกครั้งไหม

คราวนี้เป็นอย่างไรบ้าง

ดูเหมือนการออกจากบ้านยังได้ผลอยู่คราวนี้ การสูญเสียการตรวจสอบไม่คลาดเคลื่อนอีกต่อไป และความถูกต้องสุดท้ายควรสูงกว่า 99% ยินดีด้วย

ครั้งแรกที่พยายามตัดการแก้ไข เราคิดว่ามีปัญหาสําคัญที่มากเกินไป ทั้งที่จริงแล้วปัญหานั้นเกิดขึ้นในสถาปัตยกรรมของเครือข่ายระบบประสาท เราคงพัฒนาไปไกลๆ ไม่ได้หากขาดชั้นเกี่ยวกับการปฏิวัติ และไม่มีขั้นตอนอะไรที่จะทําเช่นนั้นได้

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

สุดท้าย มาลองเพิ่มการปรับให้สอดคล้องตามมาตรฐานเป็นกลุ่มกัน

ในทางทฤษฎีแล้ว แค่จํากฎ 2 ข้อมาได้ดังนี้

มาเล่นหนังสือกันตอนนี้ แล้วเพิ่มเลเยอร์บรรทัดฐานเป็นกลุ่มในเลเยอร์โครงข่ายระบบประสาทเทียมแต่ละชั้นแต่สุดท้าย อย่าเพิ่มเลเยอร์นี้ในเลเยอร์ "softmax" ล่าสุด คงไม่มีประโยชน์อะไรในส่วนนี้

# Modify each layer: remove the activation from the layer itself.
# Set use_bias=False since batch norm will play the role of biases.
tf.keras.layers.Conv2D(..., use_bias=False),
# Batch norm goes between the layer and its activation.
# The scale factor can be turned off for Relu activation.
tf.keras.layers.BatchNormalization(scale=False, center=True),
# Finish with the activation.
tf.keras.layers.Activation('relu'),

ความแม่นยําในปัจจุบันเป็นอย่างไร

ปรับแต่งเล็กน้อย (BATCH_SIZE=64, พารามิเตอร์ลดลงตามเวลาของการเรียนรู้ 0.666, อัตราการออกจากชั้นที่ 0.3) และโชคดีที่มีโอกาส 99.5% อัตราการเรียนรู้และการปรับจํานวนผู้ใช้ที่ทําหลังจากทําตามอัญประกาศ แนวทางปฏิบัติแนะนําสําหรับการใช้กลุ่มกฎ

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

สมุดบันทึกการแก้ปัญหามีการฝึกอบรม 99.5%:

keras_05_mnist_batch_norm.ipynb

คุณจะพบโค้ดเวอร์ชันที่พร้อมใช้ในระบบคลาวด์ในโฟลเดอร์ mlengine ใน GitHub พร้อมทั้งวิธีการเรียกใช้โค้ดใน Google Cloud AI Platform ก่อนที่จะเรียกใช้ส่วนนี้ คุณจะต้องสร้างบัญชี Google Cloud และเปิดใช้การเรียกเก็บเงิน ทรัพยากรที่จําเป็นในการใช้ห้องทดลองให้เสร็จสิ้นควรน้อยกว่า 2 ดอลลาร์ (ในกรณีที่ใช้เวลาฝึก 1 ชั่วโมงใน GPU 1 เครื่อง) วิธีเตรียมบัญชี

  1. สร้างโปรเจ็กต์ Google Cloud Platform (http://cloud.google.com/console)
  2. เปิดใช้การเรียกเก็บเงิน
  3. ติดตั้งเครื่องมือบรรทัดคําสั่ง GCP (GCP SDK ที่นี่)
  4. สร้างที่เก็บข้อมูล Google Cloud Storage (อยู่ในภูมิภาค us-central1) ซึ่งจะใช้เพื่อจัดโค้ดการฝึกอบรมและจัดเก็บโมเดลที่ฝึกแล้ว
  5. เปิดใช้ API ที่จําเป็นและขอโควต้าที่จําเป็น (เรียกใช้คําสั่งฝึกอบรม 1 ครั้งและคุณควรจะได้รับข้อความแสดงข้อผิดพลาดที่แจ้งว่าควรเปิดใช้อย่างไร)

คุณสร้างโครงข่ายระบบประสาทเทียมแรกและฝึกเครือข่ายให้มีความแม่นยํา 99% เทคนิคที่เรียนรู้ระหว่างทางไม่ได้มีไว้เฉพาะสําหรับชุดข้อมูล MNIST อันที่จริงแล้ว เทคนิคเหล่านี้มีการใช้กันอย่างแพร่หลายเมื่อทํางานกับเครือข่ายระบบประสาท ของขวัญเป็นของขวัญส่วนหนึ่งคือการ์ด "cliff's&tt; ห้องทดลอง" ในเวอร์ชันการ์ตูน ซึ่งใช้เพื่อจดจําสิ่งที่ได้เรียนรู้

หน้าผาอยู่ที่ tensorflow lab.png

ขั้นตอนถัดไป

  • คุณควรดูโครงข่ายระบบประสาทเทียมที่เกิดขึ้นหลังจากเครือข่ายที่เชื่อมต่ออย่างเต็มรูปแบบและมีรูปแบบการปฏิวัติแล้ว
  • Google Cloud มีAI Platform เพื่อดําเนินการฝึกหรืออนุมานในระบบคลาวด์บนโครงสร้างพื้นฐานแบบกระจาย
  • สุดท้ายนี้ เรายินดีรับฟังความคิดเห็น โปรดแจ้งให้เราทราบหากพบสิ่งผิดปกติในห้องทดลองนี้หรือคิดว่าควรปรับปรุง เราจัดการความคิดเห็นผ่านปัญหา GitHub [ลิงก์ความคิดเห็น]

HR.png

รหัส Martin Görner ขนาดเล็ก

ผู้เขียน: Martin Görner

Twitter: @martin_gorner

รูปภาพการ์ตูนทั้งหมดในลิขสิทธิ์ห้องทดลองนี้: alexpokusay/123RF photos photos