ในช่วงไม่กี่ปีที่ผ่านมามีการฟื้นตัวในด้านปัญญาประดิษฐ์ มันแพร่กระจายไปทั่วโลกวิชาการด้วยตัวเลขที่ยอดเยี่ยมเช่น Google , Microsoft และ เฟสบุ๊ค ที่สร้างทีมวิจัยของตนเองได้รับความประทับใจ การเข้าซื้อกิจการ .

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

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

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

บทช่วยสอนที่สามสิบวินาทีเกี่ยวกับการเรียนรู้ของเครื่อง

ในกรณีที่คุณไม่คุ้นเคยให้ดูบทนำนี้ การเรียนรู้ของเครื่อง :

ขั้นตอนทั่วไปมีดังนี้:

1. เรามีอัลกอริทึมที่ให้ตัวอย่างป้ายกำกับจำนวนหนึ่ง ตัวอย่างเช่น 10 ภาพสุนัขที่มีแท็ก 1 ('สุนัข') และภาพอื่น ๆ อีก 10 ภาพที่แท็ก 0 ('ไม่มีสุนัข') - โปรดทราบว่าเราใช้สำหรับโพสต์นี้เป็นหลัก ดูแล ย ไบนารี่ .

2. อัลกอริทึม 'เรียนรู้' เพื่อระบุรูปภาพของสุนัขและเมื่อได้รับการป้อนรูปภาพใหม่คาดว่าจะสร้างฉลากที่ถูกต้อง (1 หากเป็นภาพสุนัขมิฉะนั้นจะเป็น 0)

   
   
   

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

Perceptrons: อัลกอริทึมการเรียนรู้เชิงลึก

หนึ่งในอัลกอริธึมการฝึกอบรมที่ได้รับการดูแลเป็นครั้งแรกคือ perceptron โครงสร้างพื้นฐานของโครงข่ายประสาทเทียม

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

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

ในกรณีนี้ข้อมูลอินพุตแต่ละชิ้นจะแสดงเป็นเวกเตอร์ x = (x_1, x_2) และฟังก์ชันของเราจะมีค่าประมาณ“ ‘0’ ถ้าอยู่ใต้บรรทัด ‘1’ ถ้ามันอยู่เหนือมัน”

ในการแทนค่านี้ทางคณิตศาสตร์ให้ตัวคั่นของเราถูกกำหนดโดยเวกเตอร์ของน้ำหนัก w และอคติออฟเซ็ตแนวตั้ง b ดังนั้นฟังก์ชันของเราจะรวมอินพุตและน้ำหนักเข้ากับฟังก์ชันการถ่ายโอนผลรวมแบบถ่วงน้ำหนัก:

ผลลัพธ์ของฟังก์ชันการถ่ายโอนนี้จะถูกป้อนไปยังฟังก์ชันการเปิดใช้งานเพื่อสร้างฉลาก ในตัวอย่างข้างต้นฟังก์ชันทริกเกอร์ของเราเป็นเกณฑ์การตัด (เช่น 1 หากมีค่ามากกว่าค่าหนึ่ง):

ฝึก Perceptron

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

ข้อเสียของ Simple Perceptron

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

ข่าวกรองลูกค้าหรือ ________ ให้ข้อมูลที่ให้ความกระจ่างแก่ผู้เชี่ยวชาญด้านการตลาด

ในการจัดการกับปัญหานี้เราจะต้องใช้ multilayer perceptron หรือที่เรียกว่า feedforward neural network: ในทางกลับกันเราจะสร้าง perceptrons จำนวนมากเพื่อสร้างกลไกที่มีประสิทธิภาพมากขึ้นสำหรับการเรียนรู้

Feedforward Neural Networks สำหรับการเรียนรู้เชิงลึก

โครงข่ายประสาทเทียมเป็นองค์ประกอบของการรับรู้ที่เชื่อมต่อกันในรูปแบบต่างๆและทำงานด้วยฟังก์ชันการกระตุ้นที่แตกต่างกัน

ในการเริ่มต้นให้ดูที่โครงข่ายประสาทเทียมแบบ feedforward ซึ่งมีคุณสมบัติดังต่อไปนี้:

• หนึ่งอินพุตเอาต์พุตและเลเยอร์หนึ่งหรือหลายเลเยอร์ ซ่อนอยู่ . รูปด้านบนแสดงเครือข่ายที่มีชั้นอินพุต 3 หน่วยชั้นซ่อน 4 หน่วยและชั้นเอาต์พุตที่มี 2 หน่วย (หน่วยคำศัพท์และเซลล์ประสาทสามารถใช้แทนกันได้)
• แต่ละหน่วยเป็นเพอร์เซปตรอนง่ายๆเช่นเดียวกับที่อธิบายไว้ข้างต้น
• หน่วยของชั้นอินพุตทำหน้าที่เป็นอินพุตสำหรับหน่วยของเลเยอร์ที่ซ่อนอยู่ในขณะที่หน่วยของเลเยอร์ที่ซ่อนอยู่เป็นอินพุตสำหรับเลเยอร์เอาต์พุต
• การเชื่อมต่อระหว่างเซลล์ประสาทสองเซลล์มีน้ำหนัก ใน (คล้ายกับน้ำหนักของ Perceptron)
• หน่วยแต่ละชั้น t โดยปกติจะเชื่อมต่อกับแต่ละหน่วยของเลเยอร์ เสื้อด้านหน้า - 1 (แม้ว่าจะสามารถตัดการเชื่อมต่อได้โดยตั้งค่าน้ำหนักเป็น 0)
• ในการประมวลผลข้อมูลอินพุตคุณยึดเวกเตอร์อินพุตเข้ากับชั้นอินพุตโดยตั้งค่าเวกเตอร์เป็น 'เอาต์พุต' สำหรับแต่ละหน่วยอินพุต ในกรณีนี้เครือข่ายสามารถประมวลผลเวกเตอร์อินพุตสามมิติได้ (เนื่องจากหน่วยอินพุต 3 หน่วย) ตัวอย่างเช่นหากเวกเตอร์อินพุตของคุณคือ [7, 1, 2] คุณจะต้องตั้งค่าเอาต์พุตของหน่วยอินพุตด้านบนเป็น 7 หน่วยกลางเป็น 1 และอื่น ๆ ค่าเหล่านี้แพร่กระจายไปข้างหน้าไปยังหน่วยที่ซ่อนอยู่โดยใช้ฟังก์ชันการถ่ายโอนผลรวมแบบถ่วงน้ำหนักสำหรับแต่ละหน่วยที่ซ่อนอยู่ (ด้วยเหตุนี้การแพร่กระจายไปข้างหน้าของคำ) ซึ่งจะคำนวณผลลัพธ์ของมัน (ฟังก์ชันการเปิดใช้งาน)
• เลเยอร์เอาต์พุตจะคำนวณผลลัพธ์ในลักษณะเดียวกับเลเยอร์ที่ซ่อนอยู่ เอาต์พุตเลเยอร์เอาต์พุตคือเอาต์พุตจากเครือข่าย

นอกเหนือจาก Linearity

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

บริษัท c ให้การคุ้มครองทางกฎหมายแก่เจ้าของมากกว่าองค์กร

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

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

การฝึกอบรม Perceptrons

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

1. มีการนำเสนอตัวอย่างการฝึกอบรมและเผยแพร่ไปข้างหน้าผ่านเครือข่าย

2. มีการคำนวณข้อผิดพลาดของเอาต์พุตโดยปกติจะเป็นข้อผิดพลาดกำลังสองของค่าเฉลี่ยราก:

   

   ที่ไหน t คือค่าเป้าหมายและ ย เป็นผลลัพธ์ที่แท้จริงของเครือข่าย นอกจากนี้ยังยอมรับการคำนวณข้อผิดพลาดอื่น ๆ แต่ MSE เป็นตัวเลือกที่ดี

3. ข้อผิดพลาดของเครือข่ายจะลดลงโดยใช้วิธีการที่เรียกว่า เชื้อสายไล่ระดับสุ่ม .

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

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

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

   

ที่ไหน คือ คือข้อผิดพลาดของเอาต์พุตและ w_i คือน้ำหนักของอินพุต ผม ไปยังเซลล์ประสาท

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

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

ชั้นที่ซ่อนอยู่

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

เลเยอร์ที่ซ่อนอยู่คือที่ที่เครือข่ายจัดเก็บการแสดงนามธรรมภายในของข้อมูลการฝึกอบรม

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

ตัวอย่างเครือข่าย

คุณสามารถดูเครือข่ายแบบธรรมดา (ชั้น 4-2-3) ของ neural feedforward ที่จำแนกชุดข้อมูล IRIS ใช้งานใน Java ที่นี่ ผ่านวิธีการ testMLPSigmoidBP . ชุดข้อมูลประกอบด้วยพืชไอริสสามชั้นที่มีลักษณะเช่นความยาวกลีบเลี้ยงความยาวกลีบดอกเป็นต้น 50 ตัวอย่างต่อชั้นเรียนให้กับเครือข่าย ลักษณะเฉพาะขึ้นอยู่กับหน่วยอินพุตในขณะที่หน่วยเอาต์พุตแต่ละชุดสอดคล้องกับคลาสเดียวในชุดข้อมูล: '1/0/0' บ่งชี้ว่าพืชเป็นคลาส Setosa '0/1/0' หมายถึง Versicolor และ ' 0/0/1 'หมายถึง Virginica ข้อผิดพลาดในการจำแนกประเภทคือ 2/150 (นั่นคือไม่สามารถจำแนก 2 ตัวอย่างจาก 150 ตัวอย่างได้อย่างถูกต้อง)

ปัญหาเกี่ยวกับเครือข่ายขนาดใหญ่

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

อย่างไรก็ตามการเพิ่มจำนวนเลเยอร์ที่ซ่อนอยู่ทำให้เกิดปัญหาที่ทราบสองประการ:

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

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

ลองดูอัลกอริธึมการเรียนรู้เชิงลึกเพื่อตอบคำถามเหล่านี้

โปรแกรมเข้ารหัสอัตโนมัติ

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

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

corp to corp เทียบกับเครื่องคิดเลข w2

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

การบีบอัดอินพุต: รูปภาพระดับสีเทา

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

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

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

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

โรคไข้หวัด

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

นี่คือวิธีที่ชุดข้อมูลแบ่งย่อย:

• เอนทิตีป้อนข้อมูลไบนารีมีหกรายการ
• สามประการแรกเป็นอาการของโรค ตัวอย่างเช่น, 1 0 0 0 0 0 แสดงว่าผู้ป่วยรายนี้มีอุณหภูมิสูงในขณะที่ 0 1 0 0 0 0 บ่งบอกถึงอาการไอ 1 1 0 0 0 0 บ่งบอกถึงอาการไอ ย อุณหภูมิสูง ฯลฯ
• ลักษณะสามประการสุดท้ายคืออาการ 'เกินเคาน์เตอร์'; เมื่อผู้ป่วยมีอาการเหล่านี้แสดงว่ามีโอกาสน้อยที่จะป่วย ตัวอย่างเช่น, 0 0 0 1 0 0 บ่งชี้ว่าผู้ป่วยรายนี้มีอาการไข้หวัดใหญ่ เป็นไปได้ที่จะมีการผสมผสานของคุณสมบัติสองชุด: 0 1 0 1 0 0 บ่งชี้ผู้ป่วยที่ได้รับการฉีดวัคซีนด้วยอาการไอเป็นต้น

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

• 111000, 101000, 110000, 011000, 011100 = ป่วย
• 000111, 001110, 000101, 000011, 000110 = สุขภาพแข็งแรง

เรากำลังจะฝึกตัวเข้ารหัสอัตโนมัติ (โดยการแพร่กระจายกลับ) โดยมีหน่วยอินพุตหกตัวและหน่วยเอาต์พุตหกตัว แต่ เพียงสองหน่วยที่ซ่อนอยู่ .

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

กลับไปที่ Machine Learning

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

เราพยายามเรียนรู้ข้อมูลด้วยวิธีการที่ง่ายกว่านี้โดยให้ความสำคัญกับการนำเสนอที่ง่ายกว่านี้

เครื่อง Boltzmann ที่ถูก จำกัด

ขั้นตอนต่อไปคือการดูที่ไฟล์ Boltzmann ถูก จำกัด (MBR) , ก โครงข่ายประสาทเทียมที่สามารถเรียนรู้การแจกแจงความน่าจะเป็นเหนือชุดอินพุตของมันเอง

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

มาตรฐาน MBR มีหน่วยไบนารีและหน่วยที่มองเห็นได้ซ่อนอยู่นั่นคือการเปิดใช้งานหน่วยคือ 0 หรือ 1 ภายใต้ a การแจกแจงเบอร์นูลลี แต่ก็มีตัวแปรอื่น ๆ ด้วย ไม่ใช่เชิงเส้น .

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

ความแตกต่างที่ตัดกัน

อัลกอริธึมไดเวอร์เจนซ์คอนทราสต์แบบขั้นตอนเดียว (CD-1) ทำงานดังนี้:

1. เฟสบวก :
   • ตัวอย่างอินพุต v ติดอยู่กับชั้นอินพุต
   • v มันแพร่กระจายไปยังเลเยอร์ที่ซ่อนอยู่ในลักษณะเดียวกับเครือข่าย feedforward ผลลัพธ์ของการเปิดใช้งานเลเยอร์ที่ซ่อนอยู่คือ ซ .
2. เฟสเชิงลบ :
   • การแพร่กระจาย ซ กลับไปที่เลเยอร์ที่มองเห็นพร้อมผลลัพธ์ v ’ (การเชื่อมต่อระหว่างเลเยอร์ที่มองเห็นและที่ซ่อนอยู่จะไม่ถูกกำหนดทิศทางดังนั้นจึงอนุญาตให้เคลื่อนที่ได้ทั้งสองทิศทาง)
   • ขยายพันธุ์ใหม่ v ’ กลับไปที่เลเยอร์ที่ซ่อนอยู่พร้อมกับผลลัพธ์ของทริกเกอร์ h ’ .

3. อัปเดตน้ำหนัก :

   

   ที่ไหน ถึง คืออัตราการเรียนรู้และ v , v ’ , ซ , h ’ , ย ใน พวกมันคือเวกเตอร์

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

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

กลับไปที่ไข้หวัดใหญ่

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

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

คุณสามารถดูตัวอย่างนี้ในการดำเนินการได้ในวิธีการ testContrastiveDivergence .

เครือข่ายระดับลึก

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

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

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

ลองมาดูใกล้ ๆ

ตัวเข้ารหัสอัตโนมัติแบบเรียงซ้อน

ตามชื่อที่แสดงถึงเครือข่ายนี้ประกอบด้วยตัวเข้ารหัสอัตโนมัติแบบเรียงซ้อนกันหลายตัว

ภาษาโปรแกรมลินุกซ์เขียนด้วยภาษาอะไร

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

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

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

เครือข่ายความเชื่อที่ลึกซึ้ง

เช่นเดียวกับโปรแกรมเข้ารหัสอัตโนมัติเรายังสามารถซ้อนเครื่อง Boltzmann เพื่อสร้างคลาสที่เรียกว่า เครือข่ายความเชื่อลึก (DBN) .

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

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

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

( บันทึก: สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการสร้างและการฝึกอบรมตัวเข้ารหัสอัตโนมัติแบบเรียงซ้อนหรือเครือข่ายความเชื่อที่ลึกซึ้งโปรดไปที่โค้ดตัวอย่าง ที่นี่ . )

Convolutional Networks

ในฐานะสถาปัตยกรรมการเรียนรู้เชิงลึกขั้นสุดท้ายเราจะดูที่ Convolutional Networks ซึ่งเป็นเครือข่าย feedforward ที่น่าสนใจและพิเศษซึ่งได้รับการปรับให้เข้ากับการจดจำภาพได้เป็นอย่างดี

ภาพโดย DeepLearning.net

ก่อนที่จะตรวจสอบโครงสร้างที่แท้จริงของเครือข่าย Convolutional เราจะกำหนด a กรอง รูปภาพหรือพื้นที่สี่เหลี่ยมจัตุรัสที่มีน้ำหนักที่เกี่ยวข้อง มีการใช้ฟิลเตอร์กับรูปภาพอินพุตทั้งหมดและคุณมักจะใช้ฟิลเตอร์หลายตัว ตัวอย่างเช่นคุณสามารถใช้ฟิลเตอร์ 6x6 สี่ตัวกับรูปภาพอินพุตที่กำหนด จากนั้นพิกเซลเอาต์พุตที่มีพิกัด 1,1 คือผลรวมถ่วงน้ำหนักของสี่เหลี่ยมพิกเซลอินพุต 6x6 โดยมีมุมซ้ายบนเป็น 1.1 และน้ำหนักตัวกรอง (ซึ่งก็คือสี่เหลี่ยม 6x6 เช่นกัน) พิกเซลเอาต์พุต 2.1 เป็นผลลัพธ์ของช่องสัญญาณเข้าโดยมีมุมซ้ายบนเป็น 2.1 เป็นต้น

จากการตรวจสอบนี้เครือข่ายเหล่านี้ถูกกำหนดโดยคุณสมบัติต่อไปนี้:

llc คอร์ปอเรชั่น vs s คอร์ปอเรชั่น

• เลเยอร์ Convolutional ใช้ชุดของ ตัวกรอง ที่ทางเข้า. ตัวอย่างเช่นเลเยอร์ Convolution แรกในรูปภาพอาจมีฟิลเตอร์ 6x6 สี่ตัว เรียกผลลัพธ์ของตัวกรองที่ใช้กับรูปภาพ แผนที่คุณลักษณะ (FM) และจำนวนฟังก์ชันแมปเท่ากับจำนวนตัวกรอง หากเลเยอร์ก่อนหน้านี้เป็นแบบ Convolutional ตัวกรองจะถูกนำไปใช้กับ FM ทั้งหมดที่มีน้ำหนักต่างกันดังนั้น FM อินพุตแต่ละตัวจะเชื่อมต่อกับ FM เอาท์พุทแต่ละตัว สัญชาตญาณที่อยู่เบื้องหลังน้ำหนักที่ใช้ร่วมกันในภาพคือคุณสมบัติจะถูกตรวจพบโดยไม่คำนึงถึงตำแหน่งของพวกเขาในขณะที่ตัวกรองหลายหลากช่วยให้แต่ละตัวตรวจจับชุดคุณสมบัติที่แตกต่างกัน
• ชั้นการสุ่มตัวอย่าง ลดขนาดของประตู ตัวอย่างเช่นหากอินพุตประกอบด้วยภาพขนาด 32x32 และเลเยอร์มีขอบเขตการสุ่มตัวอย่าง 2x2 ค่าเอาต์พุตจะเป็นภาพขนาด 16x16 ซึ่งหมายความว่า 4 พิกเซล (สี่เหลี่ยม 2x2 แต่ละภาพ) จากภาพอินพุตจะรวมกันเป็นภาพเดียว พิกเซลเอาต์พุต มีหลายวิธีในการย่อยตัวอย่าง แต่วิธีที่นิยมมากที่สุดคือ การรวมสูงสุด , การรวมเฉลี่ย , ย สุ่มร่วมกัน .
• เลเยอร์การสุ่มตัวอย่างสุดท้าย (หรือ convolutional) มักเกี่ยวข้องกับเลเยอร์ที่เชื่อมต่อกันอย่างเต็มที่หนึ่งชั้นขึ้นไปชั้นสุดท้ายแสดงถึงข้อมูลเป้าหมาย
• การฝึกอบรม ทำได้โดยใช้การเผยแพร่ย้อนกลับที่ปรับเปลี่ยนซึ่งคำนึงถึงเลเยอร์การสุ่มตัวอย่างและอัปเดตน้ำหนักตัวกรอง Convolutional ตามค่าทั้งหมดที่ใช้ตัวกรอง

สามารถดูตัวอย่างเครือข่าย Convolutional ที่ผ่านการฝึกอบรม (เผยแพร่ย้อนหลัง) ได้ในชุดข้อมูล MNIST (ภาพสีเทาของตัวอักษรที่เขียนด้วยลายมือ) ที่นี่ โดยเฉพาะในวิธีการ testLeNet * (ฉันจะแนะนำ testLeNetTiny2 เนื่องจากมีอัตราความผิดพลาดต่ำประมาณ 2% ในช่วงเวลาสั้น ๆ ) นอกจากนี้ยังมีการแสดงผล JavaScript ที่ดีของเครือข่ายที่คล้ายกัน ที่นี่ .

การนำไปใช้

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

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

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

เพื่อให้เป็นไปตามข้อกำหนดเหล่านี้ฉันจึงใช้แนวทางแบบแบ่งชั้น (หรือแบบแยกส่วน) ในการออกแบบซอฟต์แวร์

โครงสร้าง

เริ่มต้นด้วยพื้นฐาน:

• NeuralNetworkImpl เป็นคลาสพื้นฐานสำหรับทุกรุ่นของ เครือข่าย เซลล์ประสาท.
• แต่ละเครือข่ายประกอบด้วยชุดของเลเยอร์
• แต่ละชั้นมีรายการ การเชื่อมต่อ โดยที่การเชื่อมต่อเป็นความสัมพันธ์ระหว่างสองชั้นดังนั้นเครือข่ายจึงเป็นกราฟ acyclic ที่กำหนดทิศทาง

โครงสร้างนี้มีความคล่องตัวเพียงพอที่จะใช้กับเครือข่าย feedforward แบบคลาสสิกเช่นเดียวกับสำหรับ MBR และสถาปัตยกรรมที่ซับซ้อนมากขึ้นเช่น ImageNet .

นอกจากนี้ยังอนุญาตให้เลเยอร์เป็นส่วนหนึ่งของเครือข่ายมากกว่าหนึ่งเครือข่าย ตัวอย่างเช่นเลเยอร์ในไฟล์ เครือข่ายความเชื่อที่ลึกซึ้ง พวกเขายังเป็นเลเยอร์ใน MBR ที่สอดคล้องกัน

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

การเผยแพร่ข้อมูล

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

1. กำหนดลำดับของเลเยอร์ ตัวอย่างเช่นเพื่อให้ได้ผลลัพธ์ของ perceptron แบบหลายชั้นข้อมูลจะถูก 'ตรึง' ไว้ที่ชั้นอินพุต (ดังนั้นนี่คือชั้นแรกที่จะคำนวณ) และแพร่กระจายไปยังเลเยอร์เอาต์พุต ในการอัปเดตน้ำหนักระหว่างการแพร่กระจายย้อนกลับข้อผิดพลาดเอาต์พุตจะต้องถูกเผยแพร่ผ่านแต่ละเลเยอร์ตามลำดับความกว้างโดยเริ่มจากเลเยอร์เอาต์พุต สิ่งนี้ทำได้โดยใช้การใช้งานที่แตกต่างกันของ LayerOrderStrategy ซึ่งใช้ประโยชน์จากโครงสร้างกราฟิกของเครือข่ายโดยใช้วิธีกราฟเส้นทางที่แตกต่างกัน ตัวอย่างบางส่วน ได้แก่ กลยุทธ์ความกว้าง และ ตำแหน่งของเลเยอร์เฉพาะ . ลำดับถูกกำหนดโดยการเชื่อมต่อระหว่างเลเยอร์ดังนั้นกลยุทธ์จึงส่งคืนรายการการเชื่อมต่อตามลำดับ
2. คำนวณค่าทริกเกอร์ แต่ละชั้นมีไฟล์ เครื่องคำนวณการเชื่อมต่อ ที่เกี่ยวข้องซึ่งรับรายการการเชื่อมต่อ (จากขั้นตอนก่อนหน้า) และค่าอินพุต (จากเลเยอร์อื่น ๆ ) และคำนวณการเปิดใช้งานที่เป็นผลลัพธ์ ตัวอย่างเช่นในเครือข่ายฟีดฟอร์เวิร์ด sigmoidal แบบธรรมดาเครื่องคำนวณการเชื่อมต่อเลเยอร์ที่ซ่อนอยู่จะรับค่าของชั้นอินพุตและไบแอส (อคติ) (ซึ่งตามลำดับข้อมูลอินพุตและชุดของ 1 วินาที ) และน้ำหนักระหว่างหน่วย (ในกรณีของเลเยอร์ที่เชื่อมต่อกันอย่างสมบูรณ์น้ำหนักจะถูกเก็บไว้ในการเชื่อมต่อ เชื่อมต่ออย่างเต็มที่ เป็น เมทริกซ์ ) คำนวณผลรวมถ่วงน้ำหนักและป้อนผลลัพธ์ไปยังฟังก์ชัน sigmoid เครื่องคำนวณการเชื่อมต่อใช้การถ่ายโอนที่หลากหลาย (เช่นผลรวมถ่วงน้ำหนัก Convolutional) และฟังก์ชันการเปิดใช้งาน (เช่นโลจิสติกส์และ Tanh สำหรับ Perceptron หลายชั้นไบนารีสำหรับ RMB) ส่วนใหญ่สามารถทำงานบน GPU โดยใช้ Aparapi และสามารถใช้กับการฝึกอบรมชุดย่อยได้

GPU Computing กับ Aparapi

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

Aparapi กำหนดข้อ จำกัด ที่สำคัญบางประการเกี่ยวกับเครื่องคำนวณการเชื่อมต่อ:

• อนุญาตให้ใช้อาร์เรย์หนึ่งมิติ (และตัวแปร) ของชนิดข้อมูลดั้งเดิมเท่านั้น
• เฉพาะสมาชิกของคลาส Aparapi เท่านั้น เคอร์เนล ได้รับอนุญาตให้เรียกจากรหัสปฏิบัติการของ GPU

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

การฝึกอบรม

โมดูลการฝึกอบรม ใช้อัลกอริธึมการฝึกอบรมต่างๆ สร้างขึ้นจากสองโมดูลก่อนหน้านี้ ตัวอย่างเช่น, BackPropagationTrainer (โค้ชทั้งหมดใช้ไฟล์ เทรนเนอร์ ของคลาสฐาน) ใช้เครื่องคำนวณชั้นฟีดฟอร์เวิร์ดสำหรับเฟสฟีดไปร์ดและเครื่องคำนวณเลเยอร์ความกว้างพิเศษเพื่อเผยแพร่ข้อผิดพลาดและอัปเดตน้ำหนัก

งานล่าสุดของฉันรองรับ Java 8 และการปรับปรุงอื่น ๆ ซึ่งมีอยู่ในสาขานี้และจะรวมเข้ากับไฟล์ ครู .

ข้อสรุป

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

แนวคิดเบื้องหลังโครงข่ายประสาทเทียมมีมานานแล้ว แต่วันนี้คุณไม่สามารถก้าวเข้าสู่ชุมชนแมชชีนเลิร์นนิงโดยไม่ได้รับฟังเกี่ยวกับเว็บในระดับลึกหรือความคิดเห็นเกี่ยวกับการเรียนรู้เชิงลึก แฟชั่นไม่ควรสับสนกับเหตุผล แต่ด้วยความก้าวหน้าในการประมวลผล GPGPU และความก้าวหน้าที่น่าประทับใจของนักวิจัยเช่น Geoffrey Hinton, Yoshua Bengio, Yann LeCun และ Andrew Ng สนามแสดงให้เห็นถึงคำมั่นสัญญาที่ยิ่งใหญ่ ไม่มีเวลาไหนที่ดีไปกว่าการทำความคุ้นเคยและมีส่วนร่วมเช่นวันนี้

ภาคผนวก: ทรัพยากร

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

• DeepLearning.net - พอร์ทัลสำหรับทุกสิ่งที่เกี่ยวข้องกับการเรียนรู้เชิงลึก มีบ้าง บทเรียน , ไลบรารีซอฟต์แวร์ และดีมาก อ่านรายการ .
• แอคทีฟ ชุมชน Google+ .
• สองหลักสูตรที่ดีมาก: การเรียนรู้ของเครื่อง ย โครงข่ายประสาทเทียมสำหรับการเรียนรู้ของเครื่อง ทั้งสองอย่างมีให้ใน Coursera
• กวดวิชาโครงข่ายประสาทเทียมของสแตนฟอร์ด .