บทช่วยสอนโครงข่ายประสาทเทียมพร้อมตัวอย่าง TensorFlow ANN

โครงข่ายประสาทเทียมคืออะไร?

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

โครงข่ายประสาทเทียม (ANN) ประกอบด้วยวัตถุหลักสี่ประการ:

• เลเยอร์: การเรียนรู้ทั้งหมดเกิดขึ้นในชั้น มี 3 ชั้น 1) Input 2) Hidden และ 3) Output
• คุณสมบัติและฉลาก: ป้อนข้อมูลไปยังเครือข่าย (คุณสมบัติ) และเอาต์พุตจากเครือข่าย (ป้ายกำกับ)
• ฟังก์ชั่นการสูญเสีย: ตัวชี้วัดที่ใช้ในการประเมินประสิทธิภาพของช่วงการเรียนรู้
• เพิ่มประสิทธิภาพ: ปรับปรุงการเรียนรู้ด้วยการอัพเดตความรู้ในเครือข่าย

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

หากดูภาพด้านบนก็จะเข้าใจกลไกที่ซ่อนอยู่

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

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

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

โครงข่ายประสาทเทียม Archiเทคเจอร์

โครงข่ายประสาทเทียม Archiโครงสร้างมีส่วนประกอบดังนี้:

• เลเยอร์
• ฟังก์ชั่นการเปิดใช้งาน
• ฟังก์ชั่นการสูญเสีย
• เพิ่มประสิทธิภาพ

เลเยอร์

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

โครงข่ายประสาทเทียมทั่วไปใช้เวกเตอร์ของอินพุตและสเกลาร์ที่มีป้ายกำกับ การตั้งค่าที่สะดวกสบายที่สุดคือการจำแนกไบนารี่ที่มีเพียงสองคลาส: 0 และ 1

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

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

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

ฟังก์ชั่นการเปิดใช้งาน

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

ฟังก์ชั่นการเปิดใช้งานอื่นๆ ได้แก่:

• เชิงเส้นแบบเป็นชิ้นๆ
• sigmoid
• ตันหยู
• เรลูรั่ว

การตัดสินใจที่สำคัญในการสร้างโครงข่ายประสาทเทียมคือ:

• โครงข่ายประสาทเทียมมีกี่ชั้น
• แต่ละชั้นมีหน่วยที่ซ่อนอยู่กี่หน่วย

เครือข่ายประสาทที่มีชั้นต่างๆ มากมายและหน่วยที่ซ่อนอยู่สามารถเรียนรู้การแสดงข้อมูลที่ซับซ้อนได้ แต่ทำให้การคำนวณของเครือข่ายมีราคาแพงมาก

ฟังก์ชั่นการสูญเสีย

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

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

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

เพิ่มประสิทธิภาพ

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

เครื่องมือเพิ่มประสิทธิภาพทั่วไปคือ:

• Momentum การเพิ่มประสิทธิภาพ
• Nesterov เร่งการไล่ระดับสี
• อดากราด,
• การเพิ่มประสิทธิภาพของอดัม

ข้อจำกัดของโครงข่ายประสาทเทียม

ต่อไปนี้เป็นข้อจำกัดของเครือข่ายประสาท:

ฟิตติ้งมากเกินไป

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

การเรียนรู้ของเครื่องมีข้อแลกเปลี่ยนระหว่างการปรับให้เหมาะสมและลักษณะทั่วไป

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

อย่างไรก็ตาม ลักษณะทั่วไปจะบอกว่าโมเดลมีพฤติกรรมอย่างไรกับข้อมูลที่มองไม่เห็น

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

ขนาดเครือข่าย

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

การปรับน้ำหนักให้สม่ำเสมอ

เทคนิคมาตรฐานในการป้องกันการติดตั้งมากเกินไปคือการเพิ่มข้อจำกัดให้กับน้ำหนักของเครือข่าย ข้อจำกัดบังคับให้ขนาดของเครือข่ายรับค่าเพียงเล็กน้อยเท่านั้น มีการเพิ่มข้อจำกัดในฟังก์ชันการสูญเสียของข้อผิดพลาด การทำให้เป็นมาตรฐานมีสองประเภท:

L1: Lasso: ราคาเป็นสัดส่วนกับค่าสัมประสิทธิ์น้ำหนักสัมประสิทธิ์

L2: สันเขา: ราคาเป็นสัดส่วนกับค่ากำลังสองของค่าสัมประสิทธิ์น้ำหนัก

การออกกลางคัน

การออกกลางคันเป็นเทคนิคที่แปลกแต่มีประโยชน์ เครือข่ายที่มีการออกกลางคันหมายความว่าน้ำหนักบางส่วนจะถูกสุ่มตั้งค่าเป็นศูนย์ ลองนึกภาพคุณมีน้ำหนักเป็นอาร์เรย์ [0.1, 1.7, 0.7, -0.9] หากโครงข่ายประสาทเทียมมีการออกกลางคัน มันจะกลายเป็น [0.1, 0, 0, -0.9] โดยมีการกระจายแบบสุ่ม 0 พารามิเตอร์ที่ควบคุมการออกกลางคันคืออัตราการออกกลางคัน อัตราจะกำหนดจำนวนน้ำหนักที่จะตั้งค่าเป็นศูนย์ การมีอัตราระหว่าง 0.2 ถึง 0.5 เป็นเรื่องปกติ

ตัวอย่างโครงข่ายประสาทเทียมใน TensorFlow

มาดูตัวอย่างการทำงานของเครือข่ายประสาทเทียมในการแก้ปัญหาการจำแนกประเภททั่วไปกัน มีอินพุต 1 ตัวคือ x2 และ xXNUMX โดยมีค่าสุ่ม เอาต์พุตเป็นคลาสไบนารี วัตถุประสงค์คือจำแนกฉลากตามคุณลักษณะ XNUMX ประการ เพื่อดำเนินการนี้ สถาปัตยกรรมเครือข่ายประสาทเทียมจะถูกกำหนดดังต่อไปนี้:

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

เครือข่ายจะปรับน้ำหนักให้เหมาะสมในช่วง 180 ยุคด้วยขนาดแบทช์ 10 ในวิดีโอตัวอย่าง ANN ด้านล่าง คุณจะเห็นว่าน้ำหนักมีวิวัฒนาการไปอย่างไร และเครือข่ายปรับปรุงการแมปการจัดหมวดหมู่อย่างไร

ประการแรก เครือข่ายจะกำหนดค่าสุ่มให้กับน้ำหนักทั้งหมด

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

ภายในเลเยอร์ที่ซ่อนอยู่ที่สอง เส้นต่างๆ จะถูกระบายสีตามสัญลักษณ์ของน้ำหนัก เส้นสีส้มจะกำหนดน้ำหนักลบ และเส้นสีน้ำเงินจะกำหนดน้ำหนักบวก

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

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

แนวคิดนี้สามารถสรุปได้สำหรับเครือข่ายที่มีเลเยอร์และเซลล์ประสาทที่ซ่อนอยู่มากกว่า คุณสามารถเล่นรอบใน ลิงค์.

วิธีฝึกโครงข่ายประสาทเทียมด้วย TensorFlow

ต่อไปนี้คือกระบวนการทีละขั้นตอนเกี่ยวกับวิธีฝึกโครงข่ายประสาทเทียมด้วย TensorFlow ANN โดยใช้ตัวประมาณค่า DNNClassifier ของ API

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

• ขั้นตอนที่ 1: นำเข้าข้อมูล
• ขั้นตอนที่ 2: แปลงข้อมูล
• ขั้นตอนที่ 3: สร้างเทนเซอร์
• ขั้นตอนที่ 4: สร้างแบบจำลอง
• ขั้นตอนที่ 5: ฝึกอบรมและประเมินแบบจำลอง
• ขั้นตอนที่ 6: ปรับปรุงโมเดล

ขั้นตอนที่ 1) นำเข้าข้อมูล

ก่อนอื่น คุณต้องนำเข้าไลบรารีที่จำเป็นก่อน คุณสามารถนำเข้าชุดข้อมูล MNIST ได้โดยใช้ scikit เรียนรู้ดังที่แสดงในตัวอย่าง TensorFlow Neural Network ด้านล่าง

ชุดข้อมูล MNIST เป็นชุดข้อมูลที่นิยมใช้กันทั่วไปในการทดสอบเทคนิคหรืออัลกอริทึมใหม่ๆ ชุดข้อมูลนี้เป็นชุดภาพขนาด 28×28 พิกเซลพร้อมตัวเลขที่เขียนด้วยลายมือตั้งแต่ 0 ถึง 9 ปัจจุบัน ข้อผิดพลาดต่ำสุดในการทดสอบคือ 0.27 เปอร์เซ็นต์ โดยใช้เครือข่ายประสาทเทียมแบบคอนโวลูชั่น 7 เครือข่าย

import numpy as np
import tensorflow as tf
np.random.seed(1337)

คุณสามารถดาวน์โหลด scikit เรียนรู้ได้ชั่วคราวตามที่อยู่นี้ คัดลอกและวางชุดข้อมูลในโฟลเดอร์ที่สะดวก หากต้องการนำเข้าข้อมูลไปยัง python คุณสามารถใช้ fetch_mldata จาก scikit Learn วางเส้นทางของไฟล์ภายใน fetch_mldata เพื่อดึงข้อมูล

from sklearn.datasets import fetch_mldata
mnist = fetch_mldata(' /Users/Thomas/Dropbox/Learning/Upwork/tuto_TF/data/mldata/MNIST original')
print(mnist.data.shape)
print(mnist.target.shape)

หลังจากนั้น คุณนำเข้าข้อมูลและรับรูปร่างของชุดข้อมูลทั้งสองชุด

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )

ขั้นตอนที่ 2) แปลงข้อมูล

ในบทช่วยสอนก่อนหน้านี้ คุณได้เรียนรู้ว่าคุณต้องแปลงข้อมูลเพื่อจำกัดผลกระทบของค่าผิดปกติ ในบทช่วยสอน Neural Networks นี้ คุณจะแปลงข้อมูลโดยใช้ตัวปรับขนาดขั้นต่ำ-สูงสุด สูตรคือ:

(X-min_x)/(max_x - min_x)

Scikit เรียนรู้มีฟังก์ชันสำหรับสิ่งนั้นอยู่แล้ว: MinMaxScaler()

## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))

ขั้นตอนที่ 3) สร้างเทนเซอร์

ตอนนี้คุณคุ้นเคยกับวิธีสร้างเทนเซอร์ใน Tensorflow แล้ว คุณสามารถแปลงชุดรถไฟเป็นคอลัมน์ตัวเลขได้

feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]

ขั้นตอนที่ 4) สร้างแบบจำลอง

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

หากต้องการสร้างโมเดล คุณใช้ตัวประมาณค่า DNNClassifier คุณสามารถเพิ่มจำนวนเลเยอร์ให้กับอาร์กิวเมนต์ Feature_columns ได้ คุณต้องกำหนดจำนวนคลาสเป็น 10 เนื่องจากในชุดการฝึกมีคลาสสิบคลาส คุณคุ้นเคยกับไวยากรณ์ของออบเจ็กต์ตัวประมาณอยู่แล้ว คอลัมน์คุณลักษณะอาร์กิวเมนต์ จำนวนคลาส และ model_dir เหมือนกับในบทช่วยสอนก่อนหน้านี้ทุกประการ อาร์กิวเมนต์ใหม่hidden_unitควบคุมจำนวนเลเยอร์และจำนวนโหนดที่จะเชื่อมต่อกับโครงข่ายประสาทเทียม ในโค้ดด้านล่าง มีเลเยอร์ที่ซ่อนอยู่สองชั้น โดยเลเยอร์แรกเชื่อมต่อ 300 โหนด และเลเยอร์ที่สองมี 100 โหนด

ในการสร้างตัวประมาณค่า ให้ใช้ tf.estimator.DNNClassifier พร้อมด้วยพารามิเตอร์ต่อไปนี้:

• Feature_columns: กำหนดคอลัมน์ที่จะใช้ในเครือข่าย
• Hidden_units: กำหนดจำนวนเซลล์ประสาทที่ซ่อนอยู่
• n_classes: กำหนดจำนวนคลาสที่จะทำนาย
• model_dir: กำหนดเส้นทางของ TensorBoard

estimator = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100], 
    n_classes=10, 
    model_dir = '/train/DNN')

ขั้นตอนที่ 5) ฝึกอบรมและประเมินแบบจำลอง

คุณสามารถใช้วิธี numpy เพื่อฝึกโมเดลและประเมินผลได้

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=50,
    shuffle=False,
    num_epochs=None)
estimator.train(input_fn = train_input,steps=1000) 
eval_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test, 
    shuffle=False,
    batch_size=X_test_scaled.shape[0],
    num_epochs=1)
estimator.evaluate(eval_input,steps=None) 

Output:

{'accuracy': 0.9637143,
 'average_loss': 0.12014342,
 'loss': 1682.0079,
 'global_step': 1000}

สถาปัตยกรรมปัจจุบันนำไปสู่ความแม่นยำในชุดการประเมินที่ 96 เปอร์เซ็นต์

ขั้นตอนที่ 6) ปรับปรุงโมเดล

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

เราจะใช้ตัวเพิ่มประสิทธิภาพ Adam ที่มีอัตราการหลุดออก 0.3, L1 ของ X และ L2 ของ y ในเครือข่ายประสาทเทียม TensorFlow คุณสามารถควบคุมตัวเพิ่มประสิทธิภาพได้โดยใช้ชุดออบเจ็กต์ตามด้วยชื่อของตัวเพิ่มประสิทธิภาพ TensorFlow เป็น API ในตัวสำหรับเครื่องมือเพิ่มประสิทธิภาพ Proximal AdaGrad

หากต้องการเพิ่มการปรับมาตรฐานให้กับเครือข่ายประสาทเทียมเชิงลึก คุณสามารถใช้ tf.train.ProximalAdagradOptimizer พร้อมพารามิเตอร์ต่อไปนี้

• อัตราการเรียนรู้: อัตราการเรียนรู้
• การทำให้เป็นมาตรฐาน L1: l1_regularization_strength
• การทำให้เป็นมาตรฐาน L2: l2_regularization_strength

estimator_imp = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100],
    dropout=0.3, 
    n_classes = 10,
    optimizer=tf.train.ProximalAdagradOptimizer(
      learning_rate=0.01,
      l1_regularization_strength=0.01, 
      l2_regularization_strength=0.01
    ),
    model_dir = '/train/DNN1')
estimator_imp.train(input_fn = train_input,steps=1000) 
estimator_imp.evaluate(eval_input,steps=None) 

Output:

{'accuracy': 0.95057142,
 'average_loss': 0.17318928,
 'loss': 2424.6499,
 'global_step': 2000}

ค่าที่เลือกเพื่อลดโอเวอร์ฟิตติ้งไม่ได้ปรับปรุงความแม่นยำของโมเดล แบบจำลองแรกของคุณมีความแม่นยำ 96% ในขณะที่โมเดลที่มี L2 Regularizer มีความแม่นยำ 95% คุณสามารถลองใช้ค่าต่างๆ และดูว่ามันส่งผลต่อความแม่นยำอย่างไร

สรุป

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้วิธีสร้างโครงข่ายประสาทเทียม โครงข่ายประสาทเทียมต้องการ:

• จำนวนชั้นที่ซ่อนอยู่
• จำนวนโหนดที่เชื่อมต่อโดยสมบูรณ์
• ฟังก์ชั่นการเปิดใช้งาน
• เพิ่มประสิทธิภาพ
• จำนวนชั้นเรียน

ใน TensorFlow ANN คุณสามารถฝึกโครงข่ายประสาทเทียมสำหรับปัญหาการจำแนกประเภทด้วย:

• tf.estimator.DNNClassifier

ตัวประมาณค่าจำเป็นต้องระบุ:

• คุณลักษณะ_คอลัมน์=คุณลักษณะ_คอลัมน์,
• Hidden_units=[300, 100]
• n_คลาส=10
• model_dir

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