บทนำ

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

ฉันอยากจะแนะนำให้อ่านบทความเหล่านี้เพื่อความเข้าใจพื้นฐานใน ฟิตติ้งมากเกินไป, ฟิตติ้งน้อยเกินไป และ การแลกเปลี่ยนความแปรปรวนอคติ

เรียนรู้วัตถุประสงค์

• ทำความเข้าใจสาเหตุ ผลที่ตามมา และสถานการณ์จำลองของการติดตั้งมากเกินไป ConvNet.
• ตีความกราฟการเรียนรู้เพื่อตรวจจับการโอเวอร์ฟิตและอันเดอร์ฟิตในโมเดลโครงข่ายประสาทเทียม
• เรียนรู้เทคนิคต่างๆ เพื่อลดการติดตั้งมากเกินไป เช่น การหยุดก่อนกำหนด การออกจากระบบกลางคัน การทำให้เป็นมาตรฐานแบบกลุ่ม การทำให้เป็นมาตรฐาน และการเพิ่มข้อมูล
• นำเทคนิคเหล่านี้ไปใช้ TensorFlow และ Keras เพื่อฝึก ConvNets บนชุดข้อมูล CIFAR-10
• วิเคราะห์ผลกระทบของเทคนิคต่างๆ ต่อประสิทธิภาพของโมเดลและลักษณะทั่วไป

สถานการณ์ทั่วไปสำหรับการโอเวอร์ฟิตใน ConvNet

ให้เราดูสถานการณ์ทั่วไปของการติดตั้งมากเกินไปใน ConvNet:

สถานการณ์ที่ 1: โมเดลที่ซับซ้อนสูงโดยมีข้อมูลไม่เพียงพอ

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

ผลพวง

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

จะแก้ไขปัญหานี้ได้อย่างไร?

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

สถานการณ์ที่ 2: การฝึกอบรมมากเกินไป

การฝึกโมเดลอย่างต่อเนื่องสำหรับยุคที่มากเกินไปอาจนำไปสู่การฟิตติ้งมากเกินไปได้ เมื่อโมเดลเห็นข้อมูลการฝึกซ้ำๆ ก็อาจเริ่มจดจำข้อมูลแทนที่จะเรียนรู้รูปแบบพื้นฐาน

ผลพวง

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

จะแก้ไขปัญหานี้ได้อย่างไร?

ใช้การหยุดตั้งแต่เนิ่นๆ เพื่อหลีกเลี่ยงไม่ให้โมเดลเกินขนาดและบันทึกโมเดลที่ดีที่สุด 

สถานการณ์ที่ 3: ละเว้นการทำให้เป็นมาตรฐาน

เทคนิคการทำให้เป็นมาตรฐาน เช่น การทำให้เป็นมาตรฐาน L1 หรือ L2 ถูกนำมาใช้เพื่อป้องกันการติดตั้งมากเกินไปโดยการลงโทษโมเดลที่ซับซ้อน การเพิกเฉยหรือการปรับพารามิเตอร์การทำให้เป็นมาตรฐานไม่ถูกต้องอาจนำไปสู่การโอเวอร์ฟิตได้

ผลพวง

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

จะแก้ไขปัญหานี้ได้อย่างไร?

ใช้การทำให้เป็นมาตรฐาน การตรวจสอบข้าม การปรับพารามิเตอร์ Hyper 

ความจุของรุ่นคืออะไร?

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

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

การตีความเส้นโค้งการเรียนรู้

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

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

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

# list all data in history
print(history.history.keys())

Output:

['ความแม่นยำ', 'การสูญเสีย', 'val_accuracy', 'val_loss']

ประเภทข้อมูล

คุณอาจคิดว่าข้อมูลในข้อมูลการฝึกอบรมเป็นสองประเภท:

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

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

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

วิธีการหลีกเลี่ยงการสวมอุปกรณ์มากเกินไป

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

วิธีที่ 1: ใช้ข้อมูลเพิ่มเติม

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

วิธีที่ 2: การหยุดก่อนกำหนด

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

วิธีที่ 3: การออกกลางคัน

เรารู้ว่าการติดตั้งมากเกินไปนั้นเกิดจากรูปแบบการเรียนรู้เครือข่ายปลอม (สัญญาณรบกวน) ในข้อมูลการฝึกอบรม ในการรับรู้รูปแบบปลอมๆ เหล่านี้ เครือข่ายมักจะอาศัยการผสมน้ำหนักที่เฉพาะเจาะจงมากๆ ซึ่งเป็นประเภทของ "การสมรู้ร่วมคิด" ของน้ำหนัก เนื่องจากมีความเฉพาะเจาะจงมาก พวกมันจึงมีแนวโน้มที่จะเปราะบาง: เอาอันหนึ่งออกและการสมรู้ร่วมคิดจะแตกสลาย

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

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

วิธีที่ 4: การทำให้เป็นมาตรฐานแบบแบทช์

วิธีพิเศษถัดไปที่เราจะดูคือการดำเนินการ "การทำให้เป็นมาตรฐานแบบแบตช์" (หรือ "แบทช์นอร์ม") ซึ่งสามารถช่วยแก้ไขการฝึกที่ช้าหรือไม่เสถียรได้

โดยทั่วไปแล้ว เมื่อใช้โครงข่ายประสาทเทียม เป็นความคิดที่ดีที่จะวางข้อมูลทั้งหมดของคุณในระดับทั่วไป อาจมีบางอย่างเช่น StandardScaler หรือ MinMaxScaler ของ scikit-learn เหตุผลก็คือ SGD จะเปลี่ยนน้ำหนักเครือข่ายตามสัดส่วนของการเปิดใช้งานข้อมูลที่เกิดขึ้น คุณสมบัติที่มีแนวโน้มที่จะสร้างการเปิดใช้งานในขนาดที่แตกต่างกันมากอาจทำให้พฤติกรรมการฝึกไม่เสถียร

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

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

วิธีที่ 5: การทำให้เป็นมาตรฐาน L1 และ L2

การทำให้เป็นมาตรฐานของ L1 และ L2 เป็นเทคนิคที่ใช้ในการป้องกันการโอเวอร์ฟิตโดยการลงโทษน้ำหนักที่มากในโครงข่ายประสาทเทียม การทำให้เป็นมาตรฐาน L1 จะเพิ่มเงื่อนไขการลงโทษให้กับฟังก์ชันการสูญเสียตามสัดส่วนกับค่าสัมบูรณ์ของน้ำหนัก มันส่งเสริมความกระจัดกระจายในน้ำหนักและอาจนำไปสู่การเลือกคุณสมบัติ การทำให้เป็นมาตรฐานของ L2 หรือที่เรียกว่าการลดน้ำหนัก เพิ่มค่าปรับตามสัดส่วนของกำลังสองของน้ำหนักกับฟังก์ชันการสูญเสีย ช่วยป้องกันไม่ให้ตุ้มน้ำหนักใหญ่เกินไปและส่งเสริมการกระจายตุ้มน้ำหนักให้กระจายอย่างเท่าเทียมกันมากขึ้น

ทางเลือกระหว่างการทำให้เป็นมาตรฐาน L1 และ L2 มักขึ้นอยู่กับปัญหาเฉพาะและคุณสมบัติที่ต้องการของแบบจำลอง

การมีค่าที่มากสำหรับการทำให้เป็นมาตรฐานของ L1/L2 จะทำให้โมเดลไม่สามารถเรียนรู้ได้เร็วและเข้าถึงจุดอ่อนในการเรียนรู้ ส่งผลให้โมเดลไม่พอดี 

วิธีที่ 6: การเพิ่มข้อมูล

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

วิธีง่ายๆ วิธีหนึ่งในการรับข้อมูลเพิ่มเติมคือการใช้ข้อมูลที่คุณมีอยู่แล้ว หากเราสามารถแปลงรูปภาพในชุดข้อมูลของเราในลักษณะที่รักษาคลาสไว้ (ตัวอย่าง: การจำแนกประเภท MNIST Digit หากเราลองเพิ่ม 6 มันจะเป็นการยากที่จะแยกแยะความแตกต่างระหว่าง 6 และ 9) เราสามารถสอนตัวแยกประเภทของเราให้เพิกเฉยต่อการแปลงประเภทเหล่านั้นได้ ตัวอย่างเช่น ไม่ว่ารถจะหันหน้าไปทางซ้ายหรือขวาในรูปภาพก็ไม่ได้เปลี่ยนความจริงที่ว่าเป็นรถยนต์ไม่ใช่รถบรรทุก ดังนั้น หากเราเพิ่มข้อมูลการฝึกด้วยภาพที่พลิกกลับ ตัวแยกประเภทของเราจะเรียนรู้ว่า “ซ้ายหรือขวา” คือความแตกต่างที่ควรมองข้าม

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

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

การใช้วิธีการข้างต้นด้วยข้อมูล

ให้เราสำรวจขั้นตอนการใช้งานสำหรับวิธีการข้างต้น:

ขั้นตอนที่ 1: กำลังโหลดไลบรารีที่จำเป็น

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras import datasets, layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.callbacks import ModelCheckpoint
import keras
from keras.preprocessing import image
from keras import models, layers, regularizers
from tqdm import tqdm
import warnings
warnings.filterwarnings(action='ignore')

ขั้นตอนที่ 2: กำลังโหลดชุดข้อมูลและการประมวลผลล่วงหน้า

#Here all the images are in the form of a numpy array
cifar10 = tf.keras.datasets.cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train = x_train / 255.0
x_test = x_test / 255.0

ขั้นตอนที่ 3: ชุดข้อมูลการเรียนรู้

x_train.shape, y_train.shape, x_test.shape, y_test.shape 

Output:

np.unique(y_train)

Output:

#These labels are in the order and taken from the documentaion
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
               'dog', 'frog', 'horse', 'ship', 'truck']

ขั้นตอนที่ 4: การแสดงภาพจากชุดข้อมูล

def show_image(IMG_INDEX):
    plt.imshow(x_train[20] ,cmap=plt.cm.binary)
    plt.xlabel(class_names[y_train[IMG_INDEX][0]])
    plt.show()
show_image(20)

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))
model.summary()

ให้เราเริ่มต้นพารามิเตอร์ไฮเปอร์และคอมไพล์โมเดลด้วยเครื่องมือเพิ่มประสิทธิภาพ ฟังก์ชันการสูญเสีย และเมตริกการประเมินผล

train_hyperparameters_config={'optim':keras.optimizers.Adam(learning_rate=0.001),
                             'epochs':20,
                              'batch_size':16
                             }
model.compile(optimizer=train_hyperparameters_config['optim'],
                  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                  metrics=['accuracy'])

ขั้นตอนที่ 6: โมเดลการฝึกอบรม

history = model.fit(x_train, y_train, 
                        epochs=train_hyperparameters_config['epochs'], 
                        batch_size=train_hyperparameters_config['batch_size'], 
                        verbose=1,
                        validation_data=(x_test, y_test))

ขั้นตอนที่ 7: ประเมินแบบจำลอง

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

print(history.history.keys()) 

def learning_curves(history):
# Plotting Accuracy
    plt.figure(figsize=(14, 5))  # Adjust the figure size as needed
    plt.subplot(1, 2, 1)  # Subplot with 1 row, 2 columns, and index 1
    plt.plot(history.history['accuracy'], label='train_accuracy', marker='s', markersize=4)
    plt.plot(history.history['val_accuracy'], label='val_accuracy', marker='*', markersize=4)
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.legend(loc='lower right')

    # Plotting Loss
    plt.subplot(1, 2, 2)  # Subplot with 1 row, 2 columns, and index 2
    plt.plot(history.history['loss'], label='train_loss', marker='s', markersize=4)
    plt.plot(history.history['val_loss'], label='val_loss', marker='*', markersize=4)
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.legend(loc='lower right')

    plt.show()
learning_curves(history)

จากเส้นโค้ง เราจะเห็นว่าความแม่นยำในการตรวจสอบความถูกต้องถึงระดับสูงสุดหลังจากยุคที่ 4 และแบบจำลองเริ่มจับสัญญาณรบกวน ดังนั้น เราจะดำเนินการหยุดตั้งแต่เนิ่นๆ เพื่อหลีกเลี่ยงไม่ให้โมเดลมีการติดตั้งมากเกินไป และเรียกคืนน้ำหนักที่ดีที่สุดตาม val_loss เราจะใช้ val_loss เพื่อติดตามการหยุดก่อนกำหนด เนื่องจากโครงข่ายประสาทเทียมของเราพยายามลดการสูญเสียโดยใช้เครื่องมือเพิ่มประสิทธิภาพ ความแม่นยำและความแม่นยำในการตรวจสอบความถูกต้องขึ้นอยู่กับเกณฑ์ (ความน่าจะเป็นที่จะแยกคลาส – โดยปกติคือ 0.5 สำหรับการจำแนกประเภทไบนารี่) ดังนั้นหากชุดข้อมูลของเราไม่สมดุล ก็จะสูญเสีย เราควรกังวลในกรณีส่วนใหญ่ 

ขั้นตอนที่ 8: การดำเนินการหยุดก่อนกำหนด

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

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))
model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 5,
    'epochs': 50,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)

def model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config):
    model.compile(optimizer=train_hyperparameters_config['optim'],
                      loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                      metrics=['accuracy'])
    ht = model.fit(x_train, y_train, 
                            epochs=train_hyperparameters_config['epochs'], 
                            batch_size=train_hyperparameters_config['batch_size'],
                            callbacks=[callback],
                            verbose=1,
                            validation_data=(x_test, y_test))
    return ht

ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

เพื่อทราบน้ำหนักที่ดีที่สุดของเราที่โมเดลทำได้ 

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

ขั้นตอนที่ 9: การเพิ่มความซับซ้อนของโมเดล

เนื่องจากโมเดลของเราทำงานได้ไม่ดีและไม่เหมาะสมเนื่องจากไม่สามารถเก็บข้อมูลได้เพียงพอ เราควรเพิ่มความซับซ้อนของโมเดลและประเมินผล 

model = models.Sequential()

model.add(layers.Conv2D(128, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
model.summary()

เราจะเห็นได้ว่ามีการเพิ่มขึ้นของพารามิเตอร์รวม ซึ่งจะช่วยในการค้นหาความสัมพันธ์ที่ซับซ้อนมากขึ้นในแบบจำลองของเรา หมายเหตุ: ชุดข้อมูลของเรามีรูปภาพขนาด 32X32; นี่เป็นภาพที่ค่อนข้างเล็ก ดังนั้นการใช้โมเดลที่ซับซ้อนมากขึ้นในตอนเริ่มต้นจะทำให้โมเดลมีความเหมาะสมมากเกินไป ดังนั้นเราจึงมีแนวโน้มที่จะเพิ่มความซับซ้อนของโมเดลของเราอย่างช้าๆ

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 5,
    'epochs': 50,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

จากกราฟด้านบน เราสามารถพูดได้อย่างชัดเจนว่าโมเดลมีการใช้งานมากเกินไป ดังนั้นเราจะใช้วิธีอื่นที่เรียกว่า Drop out Normalization และ Batch Normalization

ขั้นตอนที่ 10: การใช้เลเยอร์การออกกลางคันและเลเยอร์การทำให้เป็นมาตรฐานแบบแบทช์

model = models.Sequential()

model.add(layers.Conv2D(128, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.3))

model.add(layers.Dense(128, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.3))

model.add(layers.Dense(10, activation='softmax'))
model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 5,
    'epochs': 50,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

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

ขั้นตอนที่ 11: การเพิ่มเลเยอร์ Convolution

ลดพารามิเตอร์ที่ฝึกได้ แต่เพิ่มเลเยอร์การบิดเพื่อแยกคุณสมบัติเพิ่มเติม

model = models.Sequential()

model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.2))

model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.3))

model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.4))

model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.5))

model.add(layers.Dense(10, activation='softmax'))

model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 5,
    'epochs': 50,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

จากผลลัพธ์ข้างต้นและกราฟการเรียนรู้ เราสามารถอนุมานได้ว่าโมเดลทำงานได้ดีมากและหลีกเลี่ยงการติดตั้งมากเกินไป ความแม่นยำในการฝึกอบรมและความแม่นยำในการตรวจสอบอยู่ใกล้มาก ในสถานการณ์นี้ เราจะไม่จำเป็นต้องมีวิธีการเพิ่มเติมในการลดการติดตั้งมากเกินไป แต่เราจะสำรวจการทำให้ L1/L2 เป็นมาตรฐาน 

ขั้นตอนที่ 12: การใช้การทำให้เป็นมาตรฐาน L1/L2

from tensorflow.keras import regularizers

model = models.Sequential()

model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', kernel_regularizer=regularizers.l1(0.0005)))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.2))

model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same', kernel_regularizer=regularizers.l2(0.0005)))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.3))

model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.4))

model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu', kernel_regularizer=regularizers.l1_l2(0.0005, 0.0005)))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(10, activation='softmax'))

model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 7,
    'epochs': 70,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

ตอนนี้เราจะเห็นได้ว่าการทำให้ L1/L2 เป็นมาตรฐานแม้หลังจากใช้คะแนนการลงโทษต่ำที่ 0.0001 ก็ทำให้แบบจำลองของเรามีความฟิตลดลง 4% ดังนั้นจึงแนะนำให้ใช้ทุกวิธีร่วมกันอย่างระมัดระวัง เนื่องจาก Batch Normalization และ Regularization ส่งผลต่อโมเดลในลักษณะเดียวกัน เราจึงไม่จำเป็นต้องทำให้ L1/L2 เป็นมาตรฐาน 

ขั้นตอนที่ 13: การเพิ่มข้อมูล

เราจะใช้ ImageDataGenerator จาก tensorflow keras

# creates a data generator object that transforms images
datagen = ImageDataGenerator(
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest')

# pick an image to transform
test_img = x_train[20]
img = image.img_to_array(test_img)  # convert image to numpy arry
img = img.reshape((1,) + img.shape)  # reshape image

i = 0

for batch in datagen.flow(img, save_prefix='test', save_format='jpeg'):  # this loops runs forever until we break, saving images to current directory with specified prefix
    plt.figure(i)
    plot = plt.imshow(image.img_to_array(batch[0]))
    i += 1
    if i > 4:  # show 4 images
        break

plt.show()

เหล่านี้เป็นภาพเสริมสี่ภาพและภาพต้นฉบับหนึ่งภาพ

# Create an instance of the ImageDataGenerator
datagen = ImageDataGenerator(
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest'
)

# Create an iterator for the data generator
data_generator = datagen.flow(x_train, y_train, batch_size=32)

# Create empty lists to store the augmented images and labels
augmented_images = []
augmented_labels = []

# Loop over the data generator and append the augmented data to the lists
num_batches = len(x_train) // 32
progress_bar = tqdm(total=num_batches, desc="Augmenting data", unit="batch")

for i in range(num_batches):
    batch_images, batch_labels = next(data_generator)
    augmented_images.append(batch_images)
    augmented_labels.append(batch_labels)
    progress_bar.update(1)

progress_bar.close()

# Convert the lists to NumPy arrays
augmented_images = np.concatenate(augmented_images, axis=0)
augmented_labels = np.concatenate(augmented_labels, axis=0)

# Combine the original and augmented data
x_train_augmented = np.concatenate((x_train, augmented_images), axis=0)
y_train_augmented = np.concatenate((y_train, augmented_labels), axis=0)

เราได้ใช้ไลบรารี tqdm เพื่อทราบความคืบหน้าของการเพิ่มของเรา

x_train_augmented.shape, y_train_augmented.shape

นี่คือชุดข้อมูลของเราหลังจากการเสริม ตอนนี้ให้ใช้ชุดข้อมูลนี้และฝึกฝนโมเดลของเรา

model = models.Sequential()

model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.2))

model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.3))

model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.4))

model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.5))

model.add(layers.Dense(10, activation='softmax'))

model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 10,
    'epochs': 70,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)

ht=model_train(model, x_train_augmented, y_train_augmented, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

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

สรุป

การติดตั้งมากเกินไปเป็นปัญหาทั่วไปในการเรียนรู้เชิงลึก โดยเฉพาะอย่างยิ่งกับสถาปัตยกรรมโครงข่ายประสาทเทียมที่ซับซ้อน เช่น ConvNets ผู้ปฏิบัติงานสามารถป้องกันการโอเวอร์ฟิตใน ConvNets ได้โดยการทำความเข้าใจสาเหตุที่แท้จริงและรับรู้สถานการณ์ที่เกิดขึ้น เทคนิคต่างๆ เช่น การหยุดก่อนกำหนด การออกกลางคัน การทำให้เป็นมาตรฐานแบบกลุ่ม การทำให้เป็นมาตรฐาน และการเพิ่มข้อมูล สามารถช่วยบรรเทาปัญหานี้ได้ การใช้เทคนิคเหล่านี้กับชุดข้อมูล CIFAR-10 แสดงให้เห็นการปรับปรุงที่สำคัญในด้านภาพรวมและประสิทธิภาพของแบบจำลอง การฝึกฝนเทคนิคเหล่านี้และทำความเข้าใจหลักการสามารถนำไปสู่โมเดลโครงข่ายประสาทเทียมที่แข็งแกร่งและเชื่อถือได้

คำถามที่พบบ่อย

• เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
• PlatoData.Network Vertical Generative Ai เพิ่มพลังให้กับตัวเอง เข้าถึงได้ที่นี่.
• เพลโตไอสตรีม. Web3 อัจฉริยะ ขยายความรู้ เข้าถึงได้ที่นี่.
• เพลโตESG. คาร์บอน, คลีนเทค, พลังงาน, สิ่งแวดล้อม แสงอาทิตย์, การจัดการของเสีย. เข้าถึงได้ที่นี่.
• เพลโตสุขภาพ เทคโนโลยีชีวภาพและข่าวกรองการทดลองทางคลินิก เข้าถึงได้ที่นี่.
• ที่มา: https://www.analyticsvidhya.com/blog/2024/04/understanding-overfitting-in-convnets/