ในช่วงไม่กี่ปีที่ผ่านมามีการฟื้นตัวในด้านปัญญาประดิษฐ์ มันแพร่กระจายไปทั่วโลกการศึกษาโดยมีผู้เล่นหลัก ๆ เช่น 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 'ถ้าอยู่ด้านบน'

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

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

ฝึก Perceptron

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

ข้อเสียของ Perceptron เดี่ยว

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

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

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

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

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

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

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

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

คริสตัล (ภาษาโปรแกรม)

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

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

การฝึกอบรม Perceptrons

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

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

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

   

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

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

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

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

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

   

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

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

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

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

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

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

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

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

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

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

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

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

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

มาดูอัลกอริธึมการเรียนรู้เชิงลึกเพื่อแก้ไขปัญหาเหล่านี้

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

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

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

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

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

สมมติว่าข้อมูลการฝึกประกอบด้วยภาพสีเทา 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 = สุขภาพแข็งแรง

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

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

กลับไปที่ Machine Learning

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

กระดานเทรนด์คืออะไร

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

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

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

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

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

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

Contrastive Divergence

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

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

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

   

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

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

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

ที่จะเรียนรู้ c++

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

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

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

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

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

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

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

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

มาดูรายละเอียดกันดีกว่า

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

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

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

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

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

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

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

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

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

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

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

Convolutional Networks

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

ภาพโดย DeepLearning.net

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

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

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

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

การนำไปใช้

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

เป้าหมายของฉันในการสร้างไฟล์ ห้องสมุด Deep Learning เป็น (และยังคงเป็น) เพื่อสร้างกรอบการทำงานบนเครือข่ายประสาทที่เป็นไปตามเกณฑ์ต่อไปนี้:

cfos ใส่ใจอะไร

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

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

โครงสร้าง

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

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

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

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

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

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

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

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

การคำนวณ GPU ด้วย Aparapi

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

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

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

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

การฝึกอบรม

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

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

สรุป

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

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

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

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

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

ที่เกี่ยวข้อง: Schooling Flappy Bird: บทช่วยสอนการเรียนรู้แบบเสริมกำลัง