สำหรับการเรียนรู้อย่างลึกซึ้งที่ได้รับความนิยมในขณะนี้มีความจำเป็นที่จะต้องรักษาจิตวิญญาณของการเรียนรู้ - โปรแกรมเมอร์โดยเฉพาะอย่างยิ่งสถาปนิกจะต้องกังวลเกี่ยวกับเทคโนโลยีหลักและอัลกอริทึมที่สำคัญเสมอและเมื่อจำเป็นคุณต้องเขียนและเชี่ยวชาญ อย่าสนใจว่าจะใช้เมื่อใด - ไม่ว่าจะเป็นปัญหาทางการเมืองหรือว่าจะเขียนว่าเป็นปัญหาทางเทคนิคเช่นเดียวกับทหารไม่สนใจว่าจะต่อสู้หรือไม่ แต่เกี่ยวกับวิธีการชนะ
วิธีการเขียนโปรแกรมเรียนรู้การเรียนรู้ของเครื่องจักร
สำหรับโปรแกรมเมอร์การเรียนรู้ของเครื่องมีเกณฑ์ที่แน่นอน (เกณฑ์นี้เป็นความสามารถในการแข่งขันหลัก) ฉันเชื่อว่าหลายคนจะมีอาการปวดหัวสำหรับเอกสารภาษาอังกฤษที่เต็มไปด้วยสูตรทางคณิตศาสตร์เมื่อเรียนรู้การเรียนรู้ของเครื่องและอาจยอมแพ้ แต่ในความเป็นจริงโปรแกรมการใช้งานอัลกอริทึมการเรียนรู้ของเครื่องไม่ยากที่จะเขียน ต่อไปนี้เป็นอัลกอริทึมเครือข่ายประสาทแบบหลายชั้นย้อนกลับ (BP) ที่ใช้โดยรหัส 70 บรรทัดนั่นคือการเรียนรู้อย่างลึกซึ้ง ในความเป็นจริงมันไม่ได้เป็นเพียงเครือข่ายประสาท แต่อัลกอริธึมการเรียนรู้ของเครื่องส่วนใหญ่เช่นการถดถอยโลจิสติกต้นไม้การตัดสินใจ C45/ID3, ป่าสุ่ม, เบย์, เบย์, การกรองความร่วมมือ, คอมพิวเตอร์กราฟ, KMEANS, Pagerank ฯลฯ สามารถนำไปใช้ในโปรแกรมสแตนด์อะโลน 100 แถว)
ความยากลำบากที่แท้จริงของการเรียนรู้ของเครื่องจักรคือสาเหตุที่คำนวณเช่นนี้หลักการทางคณิตศาสตร์ที่อยู่เบื้องหลังมันคืออะไรและวิธีการอนุมานสูตร ข้อมูลส่วนใหญ่บนอินเทอร์เน็ตแนะนำส่วนนี้ของความรู้เชิงทฤษฎี แต่ไม่ค่อยบอกคุณว่ากระบวนการคำนวณและการใช้งานโปรแกรมของอัลกอริทึมเป็นอย่างไร สำหรับโปรแกรมเมอร์สิ่งที่คุณต้องทำคือแอพพลิเคชั่นทางวิศวกรรมเท่านั้นและไม่พิสูจน์วิธีการคำนวณทางคณิตศาสตร์ใหม่ ในความเป็นจริงวิศวกรการเรียนรู้ของเครื่องส่วนใหญ่ใช้แพ็คเกจโอเพนซอร์สหรือซอฟต์แวร์เครื่องมือที่เขียนโดยผู้อื่นเพื่อป้อนข้อมูลและปรับค่าสัมประสิทธิ์การคำนวณเพื่อฝึกอบรมผลลัพธ์และไม่ค่อยใช้กระบวนการอัลกอริทึมด้วยตนเอง อย่างไรก็ตามมันยังเป็นสิ่งสำคัญมากที่จะควบคุมกระบวนการคำนวณของแต่ละอัลกอริทึมเพื่อให้คุณสามารถเข้าใจสิ่งที่เปลี่ยนแปลงอัลกอริทึมได้สร้างข้อมูลและสิ่งที่ทำให้อัลกอริทึมมีผลต่อการบรรลุเป้าหมาย
บทความนี้มุ่งเน้นไปที่การใช้งานระบบเดียวของเครือข่ายประสาทย้อนกลับ เกี่ยวกับการทำให้เป็นแบบขนานหลายแบบของเครือข่ายประสาท Fourinone ให้กรอบการคำนวณแบบขนานที่ยืดหยุ่นและสมบูรณ์แบบ เราเพียงแค่ต้องเข้าใจการใช้งานโปรแกรมแบบสแตนด์อโลนเพื่อตั้งครรภ์และออกแบบโซลูชันการกระจายแบบขนานแบบกระจาย หากเราไม่เข้าใจกระบวนการคำนวณอัลกอริทึมความคิดทั้งหมดจะไม่สามารถขยายได้ นอกจากนี้ยังมีเครือข่ายประสาทแบบ convolutional ซึ่งส่วนใหญ่เป็นแนวคิดการลดมิติที่ใช้สำหรับการประมวลผลภาพซึ่งไม่ได้อยู่ในขอบเขตของบทความนี้
คำอธิบายกระบวนการเครือข่ายประสาท:
ก่อนอื่นสิ่งสำคัญคือต้องชัดเจนว่าเครือข่ายประสาททำงานทำนาย ฉันเชื่อว่าคุณจำวิธีกำลังสองน้อยที่สุดที่คุณเรียนรู้ในโรงเรียนมัธยม เราสามารถใช้สิ่งนี้เพื่อสร้างการเปรียบเทียบที่เข้มงวดน้อยกว่า แต่ใช้งานง่ายกว่า:
ก่อนอื่นเราต้องการรับเครื่องหมายของชุดข้อมูลและชุดข้อมูล (ในวิธีการกำลังสองน้อยที่สุดเรายังได้รับชุดค่าของ x และ y)
อัลกอริทึมเหมาะกับพารามิเตอร์ฟังก์ชันที่สามารถแสดงชุดข้อมูลนี้ตามชุดข้อมูลนี้และเครื่องหมายที่สอดคล้องกัน (นั่นคือสูตรที่คำนวณ A และ B ในวิธีการกำลังสองน้อยที่สุด แต่สูตรนี้ไม่สามารถรับได้โดยตรงในเครือข่ายประสาท
เราได้รับฟังก์ชั่นที่ติดตั้ง (นั่นคือเส้นที่ติดตั้ง y^= ax+b ในวิธีการกำลังสองน้อยที่สุด)
ถัดไปหลังจากนำข้อมูลใหม่ค่าที่คาดการณ์ไว้ y^สามารถสร้างได้ (ในวิธีการกำลังสองน้อยที่สุดมันคือการนำ y^= ax+b เพื่อรับ y^ที่คาดการณ์ไว้และเป็นอัลกอริทึมเครือข่ายประสาท แต่ฟังก์ชั่นที่ได้รับนั้นซับซ้อนกว่าวิธีการสี่เหลี่ยมน้อยที่สุด)
กระบวนการคำนวณของเครือข่ายประสาท
โครงสร้างของเครือข่ายประสาทจะแสดงในรูปด้านล่าง ด้านซ้ายสุดคือเลเยอร์อินพุตด้านขวาสุดคือเลเยอร์เอาต์พุตและตรงกลางเป็นเลเยอร์ที่ซ่อนอยู่หลายชั้น แต่ละโหนดประสาทของเลเยอร์ที่ซ่อนอยู่และเลเยอร์เอาต์พุตจะถูกสะสมโดยการคูณโหนดเลเยอร์ก่อนหน้าด้วยน้ำหนัก วงกลมที่ทำเครื่องหมายไว้ "+1" เป็นคำสกัดกั้น b สำหรับแต่ละโหนดนอกเลเยอร์อินพุต: y = w0*x0+w1*x1+…+wn*xn+b เราสามารถรู้ได้ว่าเครือข่ายประสาทเท่ากับโครงสร้างการถดถอยโลจิสติกหลายชั้น
กระบวนการคำนวณอัลกอริทึม: เลเยอร์อินพุตเริ่มต้นคำนวณจากซ้ายไปขวาและไปข้างหน้าเลเยอร์โดยเลเยอร์จนกระทั่งเลเยอร์เอาต์พุตสร้างผลลัพธ์ หากมีความแตกต่างระหว่างค่าผลลัพธ์และค่าเป้าหมายให้คำนวณจากขวาไปซ้ายคำนวณข้อผิดพลาดของแต่ละโหนดโดยเลเยอร์และปรับน้ำหนักทั้งหมดของแต่ละโหนด หลังจากไปถึงเลเยอร์อินพุตในสิ่งที่ตรงกันข้ามให้คำนวณอีกครั้งไปข้างหน้าและทำซ้ำขั้นตอนข้างต้นจนกว่าพารามิเตอร์น้ำหนักทั้งหมดมาบรรจบกันเป็นค่าที่สมเหตุสมผล เนื่องจากโปรแกรมคอมพิวเตอร์แก้ปัญหาพารามิเตอร์สมการและวิธีการทางคณิตศาสตร์จึงแตกต่างกันพวกเขามักจะเลือกพารามิเตอร์แบบสุ่มก่อนจากนั้นปรับพารามิเตอร์อย่างต่อเนื่องเพื่อลดข้อผิดพลาดจนกว่าค่าที่ถูกต้องจะเข้าหาการเรียนรู้ของเครื่องส่วนใหญ่เป็นการฝึกอบรมซ้ำ ๆ อย่างต่อเนื่อง ลองมาดูการใช้งานกระบวนการนี้อย่างละเอียดยิ่งขึ้นจากโปรแกรม
การใช้งานโปรแกรมอัลกอริทึมของเครือข่ายประสาท
การใช้งานโปรแกรมอัลกอริทึมของเครือข่ายประสาทถูกแบ่งออกเป็นสามกระบวนการ: การเริ่มต้นผลการคำนวณไปข้างหน้าและการปรับเปลี่ยนน้ำหนักย้อนกลับ
1. กระบวนการเริ่มต้น
เนื่องจากเป็นเครือข่ายประสาทแบบ N-Layer เราจึงใช้เลเยอร์อาร์เรย์สองมิติเพื่อบันทึกค่าโหนด มิติแรกคือจำนวนเลเยอร์มิติที่สองคือตำแหน่งโหนดของเลเยอร์และค่าของอาร์เรย์คือค่าโหนด ในทำนองเดียวกันเลเยอร์ค่าความผิดพลาดของโหนดก็ถูกบันทึกในลักษณะเดียวกัน ใช้อาร์เรย์สามมิติ Layer_weight เพื่อบันทึกน้ำหนักของแต่ละโหนด มิติแรกคือจำนวนเลเยอร์มิติที่สองคือตำแหน่งโหนดของเลเยอร์มิติที่สามคือตำแหน่งของโหนดเลเยอร์ล่างค่าของอาร์เรย์คือค่าน้ำหนักของโหนดถึงชั้นล่างและค่าเริ่มต้นคือจำนวนสุ่มระหว่าง 0-1 เพื่อเพิ่มประสิทธิภาพความเร็วในการลู่เข้าใช้วิธีการปรับน้ำหนักโมเมนตัมที่นี่ จำเป็นต้องบันทึกจำนวนการปรับน้ำหนักครั้งสุดท้ายและใช้อาร์เรย์สามมิติ layer_weight_delta เพื่อบันทึก การประมวลผลคำสกัดกั้น: โปรแกรมกำหนดค่าของการสกัดกั้นเป็น 1 เพื่อที่จะต้องคำนวณน้ำหนักเท่านั้น
2. คำนวณผลลัพธ์ไปข้างหน้า
ฟังก์ชัน S 1/(1+math.exp (-z)) ใช้เพื่อรวมค่าของแต่ละโหนดกับระหว่าง 0-1 จากนั้นคำนวณชั้นโดยเลเยอร์จนกระทั่งเลเยอร์เอาต์พุต สำหรับเลเยอร์เอาต์พุตไม่จำเป็นต้องใช้ฟังก์ชัน S เราถือว่าผลลัพธ์ผลลัพธ์เป็นค่าความน่าจะเป็นระหว่าง 0 ถึง 1 ดังนั้นฟังก์ชัน S จึงใช้ซึ่งก็เอื้อต่อความสม่ำเสมอของโปรแกรม
3. ปรับเปลี่ยนน้ำหนักย้อนกลับ
วิธีการคำนวณข้อผิดพลาดในเครือข่ายประสาทโดยทั่วไปใช้ฟังก์ชันข้อผิดพลาดแบบสแควร์ e ดังต่อไปนี้:
นั่นคือกำลังสองของข้อผิดพลาดของคำพูดหลายคำและค่าเป้าหมายที่สอดคล้องกันจะถูกสะสมและหารด้วย 2 ในความเป็นจริงนี่คือฟังก์ชั่นข้อผิดพลาดของการถดถอยโลจิสติก สำหรับสาเหตุที่ฟังก์ชั่นนี้ใช้ในการคำนวณข้อผิดพลาดความเป็นเหตุเป็นผลทางคณิตศาสตร์คืออะไรและได้รับอย่างไรฉันขอแนะนำให้โปรแกรมเมอร์ไม่ต้องการเป็นนักคณิตศาสตร์ดังนั้นอย่าเข้าไปในเชิงลึก สิ่งที่เราต้องทำตอนนี้คือวิธีการใช้ค่าขั้นต่ำของข้อผิดพลาดของฟังก์ชันนี้ e และจำเป็นต้องอนุพันธ์ หากมีพื้นฐานบางอย่างของคณิตศาสตร์อนุพันธ์คุณสามารถลองอนุมานวิธีการรับสูตรต่อไปนี้จากน้ำหนักอนุพันธ์ของฟังก์ชั่น E:
ไม่สำคัญว่าเราจะอนุมานได้หรือไม่ เราแค่ต้องใช้สูตรผลลัพธ์ ในโปรแกรมของเราเราใช้ Layererr เพื่อบันทึกข้อผิดพลาดที่ย่อเล็กสุดหลังจากได้รับน้ำหนักของ E จากนั้นปรับน้ำหนักตามข้อผิดพลาดที่ย่อเล็กสุด
โปรดทราบว่าวิธีการโมเมนตัมถูกนำมาใช้ที่นี่เพื่อพิจารณาประสบการณ์ของการปรับก่อนหน้านี้เพื่อหลีกเลี่ยงการตกอยู่ในค่าต่ำสุดในท้องถิ่น K ด้านล่างแสดงถึงจำนวนการวนซ้ำ MOBP เป็นคำโมเมนตัมและอัตราคือขั้นตอนการเรียนรู้:
ΔW (k+1) = mobp*Δw (k)+อัตรา*เลเยอร์*เลเยอร์*
นอกจากนี้ยังมีสูตรมากมายที่ใช้ด้านล่างและความแตกต่างของผลไม่ใหญ่เกินไป:
ΔW (k+1) = mobp*Δw (k)+(1-mobp) อัตรา*เลเยอร์*เลเยอร์*
เพื่อปรับปรุงประสิทธิภาพโปรดทราบว่าการใช้งานโปรแกรมคือการคำนวณข้อผิดพลาดและปรับน้ำหนักในขณะที่ ขั้นแรกให้ตำแหน่งตำแหน่งในเลเยอร์ที่สองถึงสุดท้าย (นั่นคือเลเยอร์ที่ซ่อนอยู่สุดท้าย) จากนั้นปรับเลเยอร์น้ำหนักในเลเยอร์ย้อนกลับ ปรับน้ำหนักของเลเยอร์ L ตามข้อผิดพลาดที่คำนวณโดยเลเยอร์ L+1 และคำนวณข้อผิดพลาดของเลเยอร์ L และคำนวณน้ำหนักในครั้งต่อไปในครั้งต่อไปที่มันจะคำนวณน้ำหนักจนกระทั่งสิ้นสุดชั้นแรก (เลเยอร์อินพุต)
สรุป
ในระหว่างกระบวนการคำนวณทั้งหมดค่าของโหนดจะเปลี่ยนแปลงทุกครั้งที่มีการคำนวณและไม่จำเป็นต้องบันทึก พารามิเตอร์น้ำหนักและพารามิเตอร์ข้อผิดพลาดจำเป็นต้องได้รับการบันทึกและจำเป็นต้องให้การสนับสนุนสำหรับการทำซ้ำครั้งต่อไป ดังนั้นหากเราตั้งครรภ์โซลูชันการคำนวณแบบคู่ขนานหลายเครื่องกระจายเราสามารถเข้าใจได้ว่าทำไมจึงมีแนวคิดของพารามิเตอร์เซิร์ฟเวอร์ในเฟรมเวิร์กอื่น ๆ
การใช้งานโปรแกรมที่สมบูรณ์ของเครือข่ายประสาทหลายชั้น
โปรแกรมการใช้งานต่อไปนี้ bpdeep.java สามารถใช้โดยตรงและมันก็ง่ายที่จะปรับเปลี่ยนไปใช้กับการใช้ภาษาอื่น ๆ เช่น C, C#, Python ฯลฯ เนื่องจากเป็นคำสั่งพื้นฐานทั้งหมดที่ใช้และไม่มีไลบรารี Java อื่น ๆ (ยกเว้นฟังก์ชั่นสุ่ม)
นำเข้า java.util.random; คลาสสาธารณะ bpdeep {public double [] [] layer; // neural network nodes public double [] [] layererr; // neural network node ข้อผิดพลาด public double [] [] [] layer_weight; อัตราสองครั้งสาธารณะ; // ค่าสัมประสิทธิ์การเรียนรู้สาธารณะ bpdeep (int [] layernum, อัตราสองครั้ง, double mobp) {this.mobp = mobp; this.rate = อัตรา; layer = ใหม่ double [layernum.length] []; layererr = ใหม่ double [layernum.length] []; layer_weight = ใหม่ double [layernum.length] [] []; layer_weight_delta = new double [layernum.length] [] []; สุ่มสุ่ม = ใหม่สุ่ม (); สำหรับ (int l = 0; l <layernum.length; l ++) {เลเยอร์ [l] = ใหม่ double [layernum [l]]; layererr [l] = ใหม่สองครั้ง [layernum [l]]; if (l+1 <layernum.length) {layer_weight [l] = ใหม่ double [layernum [l] +1] [layernum [l+1]]; layer_weight_delta [l] = ใหม่ double [layernum [l] +1] [layernum [l+1]]; สำหรับ (int j = 0; j <layernum [l] +1; j ++) สำหรับ (int i = 0; i <layernum [l+1]; i ++) layer_weight [l] [j] [i] = random l = 1; l <layer.length; l ++) {สำหรับ (int j = 0; j <layer [l] .length; j ++) {double z = layer_weight [l-1] [layer [l-1] .length] [j]; สำหรับ (int i = 0; i <layer [l-1] .length; i ++) {เลเยอร์ [l-1] [i] = l == 1? ใน [i]: เลเยอร์ [l-1] [i]; z+= layer_weight [l-1] [i] [j]*เลเยอร์ [l-1] [i]; } เลเยอร์ [l] [j] = 1/(1+math.exp (-z)); }} กลับเลเยอร์ [layer.length-1]; } // คำนวณเลเยอร์ข้อผิดพลาดย้อนกลับโดยเลเยอร์และปรับเปลี่ยนโมฆะสาธารณะที่มีน้ำหนักโมฆะ updateWeight (double [] tar) {int l = layer.length-1; สำหรับ (int j = 0; j <layererr [l] .length; j ++) layererr [l] [j] = เลเยอร์ [l] [j]*(1-layer [l] [j])*(tar [j] -layer [l] [j]); ในขณะที่ (l-> 0) {สำหรับ (int j = 0; j <layererr [l] .length; j ++) {double z = 0.0; สำหรับ (int i = 0; i <layererr [l+1] .length; i ++) {z = z+l> 0? layererr [l+1] [i]*layer_weight [l] [j] [i]: 0; layer_weight_delta [l] [j] [i] = mobp*layer_weight_delta [l] [j] [i]+อัตรา*layererr [l+1] [i]*layer [l] [j]; // การปรับเลเยอร์ layer [l] [j] [j] if (j == layererr [l] .length-1) {layer_weight_delta [l] [j+1] [i] = mobp*layer_weight_delta [l] [j+1] [i]+อัตรา*layererr [l+1] [i]; layer_weight [l] [j+1] [i]+= layer_weight_delta [l] [j+1] [i]; // การปรับน้ำหนักการสกัดกั้น}} layererr [l] [j] = z*layer [l] [j]*(1-layer [l] [j]; Computeout (ใน); UpdateWeight (tar); -ตัวอย่างของการใช้เครือข่ายประสาท
สุดท้ายเรามาหาตัวอย่างง่ายๆเพื่อดูเอฟเฟกต์เวทมนตร์ของเครือข่ายประสาท เพื่ออำนวยความสะดวกในการสังเกตการกระจายข้อมูลเราเลือกข้อมูลพิกัดสองมิติ มี 4 ข้อมูลด้านล่าง บล็อกแสดงถึงประเภทของข้อมูลคือ 1 และสามเหลี่ยมแสดงถึงประเภทของข้อมูลคือ 0 คุณจะเห็นว่าข้อมูลที่เป็นของประเภทบล็อกคือ (1, 2) และ (2, 1) และข้อมูลที่เป็นของประเภทสามเหลี่ยมคือ (1, 1), (2, 2) ตอนนี้ปัญหาคือเราต้องแบ่งข้อมูล 4 ข้อมูลออกเป็น 1 และ 0 บนเครื่องบินและใช้สิ่งนี้เพื่อทำนายประเภทของข้อมูลใหม่
เราสามารถใช้อัลกอริทึมการถดถอยโลจิสติกเพื่อแก้ปัญหาการจำแนกประเภทด้านบน แต่การถดถอยโลจิสติกได้รับเส้นตรงเชิงเส้นเป็นเส้นแบ่ง คุณจะเห็นได้ว่าไม่ว่าเส้นสีแดงจะถูกวางตัวอย่างอย่างไรตัวอย่างจะถูกแบ่งออกเป็นประเภทต่าง ๆ อย่างผิด ๆ ดังนั้นสำหรับข้อมูลข้างต้นเพียงเส้นตรงเพียงเส้นเดียวไม่สามารถแบ่งการจำแนกประเภทได้อย่างถูกต้อง หากเราใช้อัลกอริทึมเครือข่ายประสาทเราจะได้รับผลการจำแนกประเภทของตัวเลขด้านล่างซึ่งเทียบเท่ากับการค้นหาการรวมกันของเส้นตรงหลายเส้นเพื่อแบ่งพื้นที่ซึ่งมีความแม่นยำสูงกว่า
นี่คือซอร์สโค้ดของโปรแกรมทดสอบนี้ bpdeeptest.java:
นำเข้า java.util.Arrays; คลาสสาธารณะ BPDEEPTEST {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// เริ่มต้นการกำหนดค่าพื้นฐานของเครือข่ายประสาท // พารามิเตอร์แรกคืออาร์เรย์จำนวนเต็มซึ่งแสดงถึงจำนวนเลเยอร์ของเครือข่ายประสาทและจำนวนโหนดต่อชั้น ตัวอย่างเช่น {3, 10, 10, 10, 10, 2} หมายความว่าเลเยอร์อินพุตคือ 3 โหนดชั้นเอาต์พุตคือ 2 โหนดและมี 4 ชั้นที่ซ่อนอยู่ตรงกลางและ 10 โหนดต่อเลเยอร์ // พารามิเตอร์ที่สองคือขนาดขั้นตอนการเรียนรู้ // ตั้งค่าข้อมูลตัวอย่างที่สอดคล้องกับข้อมูลพิกัดสองมิติด้านบน 4 double [] [] data = ใหม่ double [] [] {{1,2}, {2,2}, {1,1}, {2,1}}; // ตั้งค่าข้อมูลเป้าหมายซึ่งสอดคล้องกับการจำแนกประเภทของ 4 ข้อมูลพิกัดสองเท่า [] [] target = ใหม่ double [] [] {{1,0}, {0,1}, {0,1}, {1,0}}; // การฝึกอบรมซ้ำ 5,000 ครั้งสำหรับ (int n = 0; n <5000; n ++) สำหรับ (int i = 0; i <data.length; i ++) bp.train (data [i], เป้าหมาย [i]); // ตรวจสอบข้อมูลตัวอย่างตามผลการฝึกอบรมสำหรับ (int j = 0; j <data.length; j ++) {double [] result = bp.computeout (data [j]); System.out.println (array.toString (data [j])+":"+array.toString (ผลลัพธ์)); } // ทำนายการจำแนกข้อมูลใหม่ตามผลการฝึกอบรมสองเท่า [] x = ใหม่สองเท่า [] {3,1}; double [] result = bp.computeout (x); System.out.println (array.toString (x)+":"+array.toString (ผลลัพธ์)); - สรุป
โปรแกรมทดสอบข้างต้นแสดงให้เห็นว่าเครือข่ายประสาทมีผลการจำแนกประเภทเวทมนตร์ ในความเป็นจริงเครือข่ายประสาทมีข้อได้เปรียบบางประการ แต่พวกเขาไม่ใช่อัลกอริทึมสากลที่อยู่ใกล้กับสมองของมนุษย์ หลายครั้งที่มันอาจทำให้เราผิดหวัง นอกจากนี้เรายังต้องใช้ข้อมูลจำนวนมากจากสถานการณ์ต่าง ๆ เพื่อสังเกตผลกระทบของมัน เราสามารถเปลี่ยนเลเยอร์ที่ซ่อนอยู่ 1 ชั้นเป็น N-layers และปรับจำนวนโหนดการวนซ้ำขนาดขั้นตอนการเรียนรู้และค่าสัมประสิทธิ์โมเมนตัมต่อเลเยอร์เพื่อให้ได้ผลลัพธ์ที่ดีที่สุด อย่างไรก็ตามในหลายกรณีผลกระทบของเลเยอร์ที่ซ่อนอยู่ N-Layer ไม่ได้รับการปรับปรุงอย่างมีนัยสำคัญกว่าเลเยอร์ 1 แทนการคำนวณนั้นซับซ้อนและใช้เวลานานกว่า ความเข้าใจของเราเกี่ยวกับเครือข่ายประสาทต้องใช้การฝึกฝนและประสบการณ์มากขึ้น
ข้างต้นเป็นเนื้อหาทั้งหมดที่ใช้ร่วมกันในบทความนี้เกี่ยวกับการใช้อัลกอริทึมเครือข่ายประสาทลึกที่มีรหัส Java 70 บรรทัด ฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน หากมีข้อบกพร่องใด ๆ โปรดฝากข้อความไว้เพื่อชี้ให้เห็น