Python Deep Learning - คู่มือฉบับย่อ
การเรียนรู้แบบมีโครงสร้างเชิงลึกหรือการเรียนรู้ตามลำดับชั้นหรือการเรียนรู้เชิงลึกในระยะสั้นเป็นส่วนหนึ่งของกลุ่มวิธีการเรียนรู้ของเครื่องซึ่งเป็นส่วนย่อยของสาขาปัญญาประดิษฐ์ที่กว้างขึ้น
การเรียนรู้เชิงลึกเป็นคลาสของอัลกอริทึมการเรียนรู้ของเครื่องที่ใช้หน่วยประมวลผลแบบไม่เชิงเส้นหลายชั้นสำหรับการแยกและการแปลงคุณลักษณะ แต่ละเลเยอร์ที่ต่อเนื่องกันใช้เอาต์พุตจากเลเยอร์ก่อนหน้าเป็นอินพุต
เครือข่ายประสาทเทียมลึกเครือข่ายความเชื่อลึกและเครือข่ายประสาทที่เกิดซ้ำได้ถูกนำไปใช้กับสาขาต่างๆเช่นการมองเห็นของคอมพิวเตอร์การรู้จำเสียงการประมวลผลภาษาธรรมชาติการจดจำเสียงการกรองเครือข่ายสังคมการแปลด้วยเครื่องและข้อมูลทางชีวสารสนเทศซึ่งให้ผลลัพธ์ที่เทียบเท่าและในบางกรณี ดีกว่าที่ผู้เชี่ยวชาญของมนุษย์มี
อัลกอริทึมและเครือข่ายการเรียนรู้เชิงลึก -
ขึ้นอยู่กับการเรียนรู้โดยไม่ได้รับการดูแลของคุณสมบัติหลายระดับหรือการนำเสนอข้อมูล คุณลักษณะระดับสูงขึ้นมาจากคุณลักษณะระดับล่างเพื่อสร้างการแสดงตามลำดับชั้น
ใช้การไล่ระดับสีบางรูปแบบสำหรับการฝึกอบรม
ในบทนี้เราจะเรียนรู้เกี่ยวกับสภาพแวดล้อมที่ตั้งค่าไว้สำหรับ Python Deep Learning เราต้องติดตั้งซอฟต์แวร์ต่อไปนี้เพื่อสร้างอัลกอริทึมการเรียนรู้เชิงลึก
- Python 2.7+
- Scipy กับ Numpy
- Matplotlib
- Theano
- Keras
- TensorFlow
ขอแนะนำอย่างยิ่งให้ติดตั้ง Python, NumPy, SciPy และ Matplotlib ผ่านการแจกจ่าย Anaconda มันมาพร้อมกับแพ็คเกจเหล่านั้นทั้งหมด
เราจำเป็นต้องตรวจสอบให้แน่ใจว่าซอฟต์แวร์ประเภทต่างๆได้รับการติดตั้งอย่างถูกต้อง
ให้เราไปที่โปรแกรมบรรทัดคำสั่งของเราและพิมพ์คำสั่งต่อไปนี้ -
$ python
Python 3.6.3 |Anaconda custom (32-bit)| (default, Oct 13 2017, 14:21:34)
[GCC 7.2.0] on linux
ต่อไปเราสามารถนำเข้าไลบรารีที่ต้องการและพิมพ์เวอร์ชัน -
import numpy
print numpy.__version__
เอาต์พุต
1.14.2
การติดตั้ง Theano, TensorFlow และ Keras
ก่อนที่เราจะเริ่มการติดตั้งแพ็คเกจ - Theano, TensorFlow และ Keras เราจำเป็นต้องยืนยันว่า pipติดตั้งแล้ว ระบบจัดการแพ็คเกจใน Anaconda เรียกว่า pip
เพื่อยืนยันการติดตั้ง pip ให้พิมพ์คำสั่งต่อไปนี้ในบรรทัดคำสั่ง -
$ pip
เมื่อยืนยันการติดตั้ง pip แล้วเราสามารถติดตั้ง TensorFlow และ Keras ได้โดยดำเนินการคำสั่งต่อไปนี้ -
$pip install theano $pip install tensorflow
$pip install keras
ยืนยันการติดตั้ง Theano โดยดำเนินการตามบรรทัดรหัสต่อไปนี้ -
$python –c “import theano: print (theano.__version__)”
เอาต์พุต
1.0.1
ยืนยันการติดตั้ง Tensorflow โดยดำเนินการตามบรรทัดของโค้ดต่อไปนี้ -
$python –c “import tensorflow: print tensorflow.__version__”
เอาต์พุต
1.7.0
ยืนยันการติดตั้ง Keras โดยดำเนินการตามบรรทัดของรหัสต่อไปนี้ -
$python –c “import keras: print keras.__version__”
Using TensorFlow backend
เอาต์พุต
2.1.5
Artificial Intelligence (AI) คือรหัสอัลกอริทึมหรือเทคนิคใด ๆ ที่ทำให้คอมพิวเตอร์สามารถเลียนแบบพฤติกรรมหรือสติปัญญาของมนุษย์ได้ Machine Learning (ML) เป็นชุดย่อยของ AI ที่ใช้วิธีการทางสถิติเพื่อให้เครื่องจักรเรียนรู้และปรับปรุงด้วยประสบการณ์ Deep Learning เป็นส่วนย่อยของ Machine Learning ซึ่งทำให้การคำนวณของเครือข่ายประสาทเทียมหลายชั้นเป็นไปได้ Machine Learning ถูกมองว่าเป็นการเรียนรู้แบบตื้น ๆ ในขณะที่ Deep Learning ถูกมองว่าเป็นการเรียนรู้แบบลำดับชั้นโดยมีนามธรรม
แมชชีนเลิร์นนิงเกี่ยวข้องกับแนวคิดที่หลากหลาย แนวคิดดังต่อไปนี้ -
- supervised
- unsupervised
- การเรียนรู้แบบเสริมกำลัง
- การถดถอยเชิงเส้น
- ฟังก์ชันต้นทุน
- overfitting
- under-fitting
- ไฮเปอร์พารามิเตอร์ ฯลฯ
ในการเรียนรู้ภายใต้การดูแลเราเรียนรู้ที่จะทำนายค่าจากข้อมูลที่มีป้ายกำกับ เทคนิค ML อย่างหนึ่งที่ช่วยในที่นี้คือการจัดประเภทโดยที่ค่าเป้าหมายเป็นค่าที่ไม่ต่อเนื่อง ตัวอย่างเช่นแมวและสุนัข อีกเทคนิคหนึ่งในการเรียนรู้ของเครื่องที่สามารถช่วยได้คือการถดถอย การถดถอยทำงานกับค่าเป้าหมาย ค่าเป้าหมายคือค่าต่อเนื่อง ตัวอย่างเช่นสามารถวิเคราะห์ข้อมูลตลาดหุ้นโดยใช้ Regression
ในการเรียนรู้ที่ไม่ได้รับการดูแลเราจะทำการอนุมานจากข้อมูลอินพุตที่ไม่มีป้ายกำกับหรือมีโครงสร้าง หากเรามีเวชระเบียนนับล้านรายการและต้องทำความเข้าใจให้ได้ค้นหาโครงสร้างพื้นฐานค่าผิดปกติหรือตรวจจับความผิดปกติเราใช้เทคนิคการจัดกลุ่มข้อมูลเพื่อแบ่งข้อมูลออกเป็นกลุ่มกว้าง ๆ
ชุดข้อมูลแบ่งออกเป็นชุดฝึกชุดทดสอบชุดตรวจสอบความถูกต้องและอื่น ๆ
ความก้าวหน้าในปี 2555 ทำให้แนวคิดของ Deep Learning มีความโดดเด่น อัลกอริทึมจำแนกภาพ 1 ล้านภาพออกเป็น 1,000 หมวดหมู่ได้สำเร็จโดยใช้ GPU 2 ตัวและเทคโนโลยีล่าสุดเช่น Big Data
เกี่ยวข้องกับการเรียนรู้เชิงลึกและการเรียนรู้ของเครื่องแบบดั้งเดิม
ความท้าทายที่สำคัญอย่างหนึ่งที่พบในโมเดลแมชชีนเลิร์นนิงแบบเดิมคือกระบวนการที่เรียกว่าการแยกคุณลักษณะ โปรแกรมเมอร์จะต้องมีความเฉพาะเจาะจงและบอกคุณสมบัติที่ต้องระวังให้คอมพิวเตอร์ทราบ คุณสมบัติเหล่านี้จะช่วยในการตัดสินใจ
การป้อนข้อมูลดิบลงในอัลกอริทึมไม่ค่อยได้ผลดังนั้นการแยกคุณลักษณะจึงเป็นส่วนสำคัญของเวิร์กโฟลว์การเรียนรู้ของเครื่องแบบเดิม
สิ่งนี้ทำให้เกิดความรับผิดชอบอย่างมากต่อโปรแกรมเมอร์และประสิทธิภาพของอัลกอริทึมขึ้นอยู่กับความคิดสร้างสรรค์ของโปรแกรมเมอร์ สำหรับปัญหาที่ซับซ้อนเช่นการจดจำวัตถุหรือการจดจำลายมือนี่เป็นปัญหาใหญ่
การเรียนรู้เชิงลึกพร้อมความสามารถในการเรียนรู้การแสดงหลายชั้นเป็นหนึ่งในวิธีการไม่กี่วิธีที่ช่วยเราในการแยกคุณลักษณะอัตโนมัติ ชั้นล่างสามารถสันนิษฐานได้ว่ากำลังดำเนินการแยกคุณลักษณะอัตโนมัติโดยต้องการคำแนะนำเพียงเล็กน้อยหรือไม่มีเลยจากโปรแกรมเมอร์
โครงข่ายประสาทเทียม (Artificial Neural Network) หรือโครงข่ายประสาทเทียมในระยะสั้นไม่ใช่แนวคิดใหม่ มีมานานประมาณ 80 ปี
จนกระทั่งปี 2011 Deep Neural Networks ได้รับความนิยมจากการใช้เทคนิคใหม่ ๆ ความพร้อมใช้งานของชุดข้อมูลขนาดใหญ่และคอมพิวเตอร์ที่ทรงพลัง
โครงข่ายประสาทเทียมเลียนแบบเซลล์ประสาทซึ่งมีเดนไดรต์นิวเคลียสแอกซอนและเทอร์มินัลแอกซอน
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/terminal_axon.jpg)
สำหรับเครือข่ายเราต้องการเซลล์ประสาทสองเซลล์ เซลล์ประสาทเหล่านี้ถ่ายโอนข้อมูลผ่านไซแนปส์ระหว่างเดนไดรต์ของหนึ่งและเทอร์มินัลแอกซอนของอีกขั้วหนึ่ง
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/neurons_transfer_information.jpg)
แบบจำลองที่น่าจะเป็นของเซลล์ประสาทเทียมมีลักษณะดังนี้ -
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/probable_model.jpg)
โครงข่ายประสาทจะมีลักษณะดังที่แสดงด้านล่าง -
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/neural_network.jpg)
วงกลมเป็นเซลล์ประสาทหรือโหนดโดยมีหน้าที่เกี่ยวกับข้อมูลและเส้น / ขอบที่เชื่อมต่อกันคือน้ำหนัก / ข้อมูลที่ส่งผ่านไป
แต่ละคอลัมน์เป็นเลเยอร์ ชั้นแรกของข้อมูลของคุณคือชั้นอินพุต จากนั้นเลเยอร์ทั้งหมดระหว่างเลเยอร์อินพุตและเลเยอร์เอาต์พุตคือเลเยอร์ที่ซ่อนอยู่
หากคุณมีเลเยอร์ที่ซ่อนอยู่หนึ่งหรือสองสามชั้นแสดงว่าคุณมีโครงข่ายประสาทเทียมแบบตื้น หากคุณมีเลเยอร์ที่ซ่อนอยู่จำนวนมากแสดงว่าคุณมีโครงข่ายประสาทเทียมที่ลึก
ในแบบจำลองนี้คุณมีข้อมูลอินพุตคุณถ่วงน้ำหนักและส่งผ่านฟังก์ชันในเซลล์ประสาทที่เรียกว่าฟังก์ชันขีด จำกัด หรือฟังก์ชันกระตุ้น
โดยทั่วไปแล้วจะเป็นผลรวมของค่าทั้งหมดหลังจากเปรียบเทียบกับค่าหนึ่งแล้ว หากคุณส่งสัญญาณผลลัพธ์คือ (1) ดับหรือไม่มีสิ่งใดถูกยิงออกมาจากนั้น (0) จากนั้นจะถูกถ่วงน้ำหนักและส่งต่อไปยังเซลล์ประสาทถัดไปและฟังก์ชันประเภทเดียวกันจะถูกเรียกใช้
เราสามารถมีฟังก์ชัน sigmoid (s-shape) เป็นฟังก์ชันกระตุ้น
สำหรับน้ำหนักนั้นเป็นเพียงการสุ่มเพื่อเริ่มต้นและจะไม่ซ้ำกันต่อการป้อนข้อมูลในโหนด / เซลล์ประสาท
ใน "ฟีดไปข้างหน้า" ทั่วไปซึ่งเป็นเครือข่ายประสาทเทียมประเภทพื้นฐานที่สุดคุณมีข้อมูลของคุณส่งตรงผ่านเครือข่ายที่คุณสร้างขึ้นและเปรียบเทียบผลลัพธ์กับสิ่งที่คุณหวังว่าผลลัพธ์จะใช้ข้อมูลตัวอย่างของคุณ
จากตรงนี้คุณต้องปรับน้ำหนักเพื่อช่วยให้คุณได้ผลลัพธ์ที่ตรงกับผลลัพธ์ที่คุณต้องการ
การส่งข้อมูลโดยตรงผ่านเครือข่ายประสาทเรียกว่า a feed forward neural network.
ข้อมูลของเราเปลี่ยนจากอินพุตไปยังเลเยอร์ตามลำดับจากนั้นไปยังเอาต์พุต
เมื่อเราถอยหลังและเริ่มปรับน้ำหนักเพื่อลดการสูญเสีย / ต้นทุนให้น้อยที่สุดสิ่งนี้เรียกว่า back propagation.
นี่คือ optimization problem. ด้วยโครงข่ายประสาทเทียมในทางปฏิบัติจริงเราต้องจัดการกับตัวแปรหลายแสนตัวหรือหลายล้านตัวขึ้นไป
วิธีแก้ปัญหาแรกคือการใช้การไล่ระดับสีแบบสุ่มเป็นวิธีการเพิ่มประสิทธิภาพ ตอนนี้มีตัวเลือกเช่น AdaGrad, Adam Optimizer และอื่น ๆ ไม่ว่าจะด้วยวิธีใดนี่คือการคำนวณขนาดใหญ่ นั่นคือเหตุผลที่ Neural Networks ส่วนใหญ่ถูกทิ้งไว้บนหิ้งมานานกว่าครึ่งศตวรรษ เมื่อไม่นานมานี้เรายังมีพลังและสถาปัตยกรรมในเครื่องของเราเพื่อพิจารณาดำเนินการเหล่านี้และชุดข้อมูลที่มีขนาดเหมาะสมเพื่อให้เข้ากันได้
สำหรับงานการจัดหมวดหมู่อย่างง่ายเครือข่ายประสาทเทียมมีประสิทธิภาพใกล้เคียงกับอัลกอริทึมทั่วไปอื่น ๆ เช่น K Nearest Neighbours ยูทิลิตี้ที่แท้จริงของเครือข่ายประสาทเทียมเกิดขึ้นได้เมื่อเรามีข้อมูลขนาดใหญ่ขึ้นและคำถามที่ซับซ้อนมากขึ้นซึ่งทั้งสองอย่างนี้มีประสิทธิภาพดีกว่าโมเดลการเรียนรู้ของเครื่องอื่น ๆ
Deep Neural Network (DNN) คือ ANN ที่มีเลเยอร์ซ่อนอยู่หลายชั้นระหว่างชั้นอินพุตและเอาต์พุต เช่นเดียวกับ ANN ที่ตื้น DNN สามารถจำลองความสัมพันธ์ที่ไม่ใช่เชิงเส้นที่ซับซ้อนได้
จุดประสงค์หลักของเครือข่ายประสาทเทียมคือการรับชุดของอินพุตทำการคำนวณที่ซับซ้อนอย่างต่อเนื่องและให้ผลลัพธ์เพื่อแก้ปัญหาในโลกแห่งความจริงเช่นการจำแนกประเภท เรา จำกัด ตัวเองในการป้อนโครงข่ายประสาทเทียม
เรามีอินพุตเอาต์พุตและโฟลว์ของข้อมูลตามลำดับในเครือข่ายระดับลึก
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/deep_network.jpg)
โครงข่ายประสาทเทียมใช้กันอย่างแพร่หลายในปัญหาการเรียนรู้ภายใต้การดูแลและการเสริมสร้าง เครือข่ายเหล่านี้ขึ้นอยู่กับชุดของเลเยอร์ที่เชื่อมต่อกัน
ในการเรียนรู้เชิงลึกจำนวนของเลเยอร์ที่ซ่อนอยู่ซึ่งส่วนใหญ่ไม่ใช่เชิงเส้นอาจมีขนาดใหญ่ พูดได้ประมาณ 1,000 ชั้น
รุ่น DL ให้ผลลัพธ์ที่ดีกว่าเครือข่าย ML ปกติมาก
ส่วนใหญ่เราใช้วิธีการไล่ระดับสีเพื่อเพิ่มประสิทธิภาพเครือข่ายและลดฟังก์ชันการสูญเสียให้น้อยที่สุด
เราสามารถใช้ไฟล์ Imagenetซึ่งเป็นที่เก็บภาพดิจิทัลหลายล้านภาพเพื่อจำแนกชุดข้อมูลออกเป็นหมวดหมู่เช่นแมวและสุนัข DL nets ถูกนำมาใช้มากขึ้นสำหรับภาพไดนามิกนอกเหนือจากภาพนิ่งและสำหรับการวิเคราะห์อนุกรมเวลาและข้อความ
การฝึกชุดข้อมูลเป็นส่วนสำคัญของโมเดลการเรียนรู้เชิงลึก นอกจากนี้ Backpropagation ยังเป็นอัลกอริทึมหลักในการฝึกโมเดล DL
DL เกี่ยวข้องกับการฝึกเครือข่ายประสาทขนาดใหญ่ที่มีการแปลงอินพุตเอาต์พุตที่ซับซ้อน
ตัวอย่างหนึ่งของ DL คือการแมปรูปภาพกับชื่อบุคคลในรูปภาพเช่นเดียวกับที่ทำบนโซเชียลเน็ตเวิร์กและการอธิบายรูปภาพด้วยวลีเป็นแอปพลิเคชั่นล่าสุดของ DL
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/dl_mapping.jpg)
เครือข่ายประสาทเทียมคือฟังก์ชันที่มีอินพุตเช่น x1, x2, x3 …ที่ถูกแปลงเป็นเอาต์พุตเช่น z1, z2, z3 และอื่น ๆ ในสองเครือข่าย (เครือข่ายตื้น) หรือการดำเนินการขั้นกลางหลายอย่างที่เรียกว่าเลเยอร์ (เครือข่ายแบบลึก)
น้ำหนักและอคติเปลี่ยนจากเลเยอร์เป็นเลเยอร์ 'w' และ 'v' คือน้ำหนักหรือซินแนปส์ของเลเยอร์ของเครือข่ายประสาทเทียม
กรณีการใช้งานที่ดีที่สุดของการเรียนรู้เชิงลึกคือปัญหาการเรียนรู้ภายใต้การดูแลที่นี่เรามีอินพุตข้อมูลจำนวนมากพร้อมชุดเอาต์พุตที่ต้องการ
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/backpropagation_algorithm.jpg)
ที่นี่เราใช้อัลกอริธึมการขยายพันธุ์ย้อนกลับเพื่อรับคำทำนายผลลัพธ์ที่ถูกต้อง
ชุดข้อมูลพื้นฐานที่สุดของการเรียนรู้เชิงลึกคือ MNIST ซึ่งเป็นชุดข้อมูลของตัวเลขที่เขียนด้วยลายมือ
เราสามารถฝึก Convolutional Neural Network ด้วย Keras เพื่อจำแนกภาพของตัวเลขที่เขียนด้วยลายมือจากชุดข้อมูลนี้
การยิงหรือการกระตุ้นของลักษณนามเครือข่ายประสาททำให้เกิดคะแนน ตัวอย่างเช่นในการจัดประเภทผู้ป่วยว่าป่วยและมีสุขภาพดีเราจะพิจารณาพารามิเตอร์ต่างๆเช่นความสูงน้ำหนักและอุณหภูมิของร่างกายความดันโลหิตเป็นต้น
คะแนนสูงหมายถึงผู้ป่วยไม่สบายและคะแนนต่ำหมายความว่าเขามีสุขภาพดี
แต่ละโหนดในเอาต์พุตและเลเยอร์ที่ซ่อนอยู่จะมีตัวแยกประเภทของตัวเอง เลเยอร์อินพุตรับอินพุตและส่งต่อคะแนนไปยังเลเยอร์ที่ซ่อนถัดไปเพื่อเปิดใช้งานต่อไปและจะดำเนินต่อไปจนกว่าจะถึงเอาต์พุต
ความคืบหน้าจากอินพุตไปยังเอาต์พุตจากซ้ายไปขวาในทิศทางไปข้างหน้านี้เรียกว่า forward propagation.
เส้นทางการกำหนดเครดิต (CAP) ในโครงข่ายประสาทเทียมคือชุดของการเปลี่ยนแปลงที่เริ่มต้นจากอินพุตไปยังเอาต์พุต CAPs อธิบายการเชื่อมต่อเชิงสาเหตุที่เป็นไปได้อย่างละเอียดระหว่างอินพุตและเอาต์พุต
ความลึกของ CAP สำหรับโครงข่ายประสาทเทียมฟีดไปข้างหน้าหรือความลึกของ CAP คือจำนวนเลเยอร์ที่ซ่อนอยู่บวกหนึ่งเมื่อรวมเลเยอร์เอาต์พุต สำหรับเครือข่ายประสาทที่เกิดซ้ำซึ่งสัญญาณอาจแพร่กระจายผ่านเลเยอร์หลาย ๆ ครั้งความลึกของ CAP อาจไร้ขีด จำกัด
อวนลึกและอวนตื้น
ไม่มีเกณฑ์ความลึกที่ชัดเจนที่แบ่งการเรียนรู้ระดับตื้นจากการเรียนรู้เชิงลึก แต่ส่วนใหญ่ตกลงกันว่าสำหรับการเรียนรู้เชิงลึกซึ่งมีเลเยอร์ที่ไม่ใช่เชิงเส้นหลายชั้น CAP จะต้องมากกว่าสอง
โหนดพื้นฐานในตาข่ายประสาทคือการรับรู้ที่เลียนแบบเซลล์ประสาทในโครงข่ายประสาททางชีววิทยา จากนั้นเรามี Perception หรือ MLP หลายชั้น อินพุตแต่ละชุดถูกปรับเปลี่ยนโดยชุดของน้ำหนักและอคติ แต่ละขอบมีน้ำหนักที่ไม่ซ้ำกันและแต่ละโหนดมีอคติที่ไม่ซ้ำกัน
การทำนาย accuracy ของตาข่ายประสาทขึ้นอยู่กับมัน weights and biases.
กระบวนการปรับปรุงความถูกต้องของโครงข่ายประสาทเรียกว่า training. ผลลัพธ์จาก forward prop net ถูกเปรียบเทียบกับค่าที่ทราบว่าถูกต้อง
cost function or the loss function คือความแตกต่างระหว่างเอาต์พุตที่สร้างขึ้นและเอาต์พุตจริง
จุดสำคัญของการฝึกอบรมคือการทำให้ค่าใช้จ่ายในการฝึกอบรมน้อยที่สุดเท่าที่จะเป็นไปได้จากตัวอย่างการฝึกอบรมหลายล้านตัวอย่างในการทำเช่นนี้เครือข่ายจะปรับน้ำหนักและอคติจนกว่าการคาดการณ์จะตรงกับผลลัพธ์ที่ถูกต้อง
เมื่อได้รับการฝึกฝนอย่างดีแล้วตาข่ายประสาทจะมีศักยภาพในการทำนายที่แม่นยำทุกครั้ง
เมื่อรูปแบบมีความซับซ้อนและคุณต้องการให้คอมพิวเตอร์ของคุณจดจำได้คุณต้องไปหาเครือข่ายประสาทเทียมในสถานการณ์รูปแบบที่ซับซ้อนเช่นนี้เครือข่ายประสาทเทียมมีประสิทธิภาพดีกว่าอัลกอริทึมอื่น ๆ ที่แข่งขันกัน
ตอนนี้มี GPU ที่สามารถฝึกได้เร็วขึ้นกว่าเดิม เครือข่ายประสาทเทียมระดับลึกกำลังปฏิวัติวงการ AI อยู่แล้ว
คอมพิวเตอร์ได้พิสูจน์แล้วว่าสามารถทำการคำนวณซ้ำ ๆ ได้ดีและทำตามคำแนะนำโดยละเอียด แต่ยังไม่ค่อยดีนักในการจดจำรูปแบบที่ซับซ้อน
หากมีปัญหาในการจดจำรูปแบบที่เรียบง่ายเครื่องเวกเตอร์สนับสนุน (svm) หรือลักษณนามการถดถอยโลจิสติกสามารถทำงานได้ดี แต่เนื่องจากความซับซ้อนของรูปแบบเพิ่มขึ้นจึงไม่มีวิธีใดนอกจากไปที่โครงข่ายประสาทเทียมแบบลึก
ดังนั้นสำหรับรูปแบบที่ซับซ้อนเช่นใบหน้ามนุษย์โครงข่ายประสาทเทียมแบบตื้นจึงล้มเหลวและไม่มีทางเลือกอื่นนอกจากไปหาโครงข่ายประสาทเทียมที่มีเลเยอร์มากกว่า อวนลึกสามารถทำงานได้โดยแบ่งรูปแบบที่ซับซ้อนออกเป็นรูปแบบที่ง่ายกว่า ตัวอย่างเช่นใบหน้าของมนุษย์ adeep net จะใช้ขอบในการตรวจจับส่วนต่างๆเช่นริมฝีปากจมูกตาหูและอื่น ๆ แล้วรวมเข้าด้วยกันอีกครั้งเพื่อสร้างใบหน้าของมนุษย์
ความแม่นยำของการทำนายที่ถูกต้องกลายเป็นความแม่นยำมากจนเมื่อเร็ว ๆ นี้ในการแข่งขัน Google Pattern Recognition Challenge ตาข่ายลึกเอาชนะมนุษย์ได้
แนวคิดเกี่ยวกับเว็บของการรับรู้แบบหลายชั้นนี้มีมาระยะหนึ่งแล้ว ในบริเวณนี้ตาข่ายลึกเลียนแบบสมองของมนุษย์ แต่ข้อเสียอย่างหนึ่งก็คือพวกเขาใช้เวลาในการฝึกอบรมนานซึ่งเป็นข้อ จำกัด ของฮาร์ดแวร์
อย่างไรก็ตาม GPU ประสิทธิภาพสูงเมื่อเร็ว ๆ นี้สามารถฝึกอวนลึกดังกล่าวได้ภายในหนึ่งสัปดาห์ ในขณะที่ cpus อย่างรวดเร็วอาจใช้เวลาหลายสัปดาห์หรืออาจเป็นเดือนในการทำเช่นเดียวกัน
การเลือก Deep Net
วิธีการเลือกตาข่ายลึก? เราต้องตัดสินใจว่าเรากำลังสร้างลักษณนามหรือไม่หรือกำลังพยายามค้นหารูปแบบในข้อมูลและจะใช้การเรียนรู้ที่ไม่มีผู้ดูแล ในการแยกรูปแบบจากชุดข้อมูลที่ไม่มีป้ายกำกับเราใช้เครื่อง Boltzman ที่ถูก จำกัด หรือตัวเข้ารหัสอัตโนมัติ
พิจารณาประเด็นต่อไปนี้ในขณะที่เลือกตาข่ายลึก -
สำหรับการประมวลผลข้อความการวิเคราะห์ความรู้สึกการแยกวิเคราะห์และการจดจำชื่อเอนทิตีเราใช้เครือข่ายเทนเซอร์ประสาทแบบสุทธิหรือแบบวนซ้ำหรือ RNTN
สำหรับรูปแบบภาษาใด ๆ ที่ดำเนินการในระดับอักขระเราใช้เน็ตที่เกิดซ้ำ
สำหรับการจดจำภาพเราใช้ DBN เครือข่ายความเชื่อลึกหรือเครือข่ายการแปลงสัญญาณ
สำหรับการรับรู้วัตถุเราใช้ RNTN หรือเครือข่าย Convolutional
สำหรับการรู้จำเสียงเราใช้เน็ตที่เกิดซ้ำ
โดยทั่วไปเครือข่ายความเชื่อเชิงลึกและการรับรู้หลายชั้นที่มีหน่วยเชิงเส้นแก้ไขหรือ RELU เป็นตัวเลือกที่ดีสำหรับการจำแนกประเภท
สำหรับการวิเคราะห์อนุกรมเวลาขอแนะนำให้ใช้สุทธิที่เกิดซ้ำเสมอ
ตาข่ายประสาทมีมานานกว่า 50 ปีแล้ว แต่ตอนนี้พวกเขามีชื่อเสียงมากขึ้น เหตุผลก็คือพวกเขาฝึกยาก เมื่อเราพยายามฝึกพวกเขาด้วยวิธีการที่เรียกว่าการแพร่กระจายกลับเราพบปัญหาที่เรียกว่าการไล่ระดับสีที่หายไปหรือการระเบิดเมื่อเป็นเช่นนั้นการฝึกอบรมจะใช้เวลานานขึ้นและความแม่นยำจะต้องใช้เบาะหลัง เมื่อฝึกชุดข้อมูลเราจะคำนวณฟังก์ชันต้นทุนอยู่ตลอดเวลาซึ่งเป็นความแตกต่างระหว่างผลลัพธ์ที่คาดการณ์และผลลัพธ์จริงจากชุดข้อมูลการฝึกที่มีป้ายกำกับฟังก์ชันต้นทุนจะถูกย่อให้เล็กที่สุดโดยการปรับค่าน้ำหนักและค่าอคติจนกระทั่งได้ค่าต่ำสุด จะได้รับ ขั้นตอนการฝึกใช้การไล่ระดับสีซึ่งเป็นอัตราที่ต้นทุนจะเปลี่ยนแปลงไปตามการเปลี่ยนแปลงของน้ำหนักหรือค่าอคติ
Boltzman Networks หรือ Autoencoders ที่ถูก จำกัด - RBN
ในปี 2549 ประสบความสำเร็จในการแก้ไขปัญหาการไล่ระดับสีที่หายไป Geoff Hinton คิดค้นกลยุทธ์ใหม่ที่นำไปสู่การพัฒนาRestricted Boltzman Machine - RBMตาข่ายสองชั้นตื้น
ชั้นแรกคือ visible ชั้นและชั้นที่สองคือ hiddenชั้น. แต่ละโหนดในเลเยอร์ที่มองเห็นจะเชื่อมต่อกับทุกโหนดในเลเยอร์ที่ซ่อนอยู่ เครือข่ายเรียกว่า จำกัด เนื่องจากไม่อนุญาตให้ใช้สองเลเยอร์ภายในเลเยอร์เดียวกันในการแชร์การเชื่อมต่อ
ตัวเข้ารหัสอัตโนมัติคือเครือข่ายที่เข้ารหัสข้อมูลอินพุตเป็นเวกเตอร์ สร้างการแสดงข้อมูลดิบที่ซ่อนหรือบีบอัด เวกเตอร์มีประโยชน์ในการลดขนาด เวกเตอร์บีบอัดข้อมูลดิบให้เป็นมิติข้อมูลที่จำเป็นจำนวนน้อยลง ตัวเข้ารหัสอัตโนมัติจับคู่กับตัวถอดรหัสซึ่งช่วยให้สามารถสร้างข้อมูลอินพุตขึ้นใหม่ตามการแสดงที่ซ่อนอยู่
RBM เทียบเท่าทางคณิตศาสตร์ของตัวแปลสองทาง Forward pass รับอินพุตและแปลเป็นชุดตัวเลขที่เข้ารหัสอินพุต ในขณะเดียวกันการส่งย้อนกลับจะนำชุดของตัวเลขนี้และแปลกลับเป็นอินพุตที่สร้างขึ้นใหม่ ตาข่ายที่ได้รับการฝึกฝนมาเป็นอย่างดีทำหน้าที่ค้ำยันด้วยความแม่นยำระดับสูง
ในทั้งสองขั้นตอนน้ำหนักและอคติมีบทบาทสำคัญ พวกเขาช่วย RBM ในการถอดรหัสความสัมพันธ์ระหว่างอินพุตและในการตัดสินใจว่าอินพุตใดที่จำเป็นในการตรวจจับรูปแบบ ผ่านการเดินหน้าและถอยหลัง RBM ได้รับการฝึกฝนให้สร้างอินพุตใหม่ด้วยน้ำหนักและอคติที่แตกต่างกันจนกว่าอินพุตและโครงสร้างจะใกล้เคียงกันมากที่สุด ลักษณะที่น่าสนใจของ RBM คือข้อมูลไม่จำเป็นต้องมีป้ายกำกับ สิ่งนี้มีความสำคัญมากสำหรับชุดข้อมูลในโลกแห่งความเป็นจริงเช่นภาพถ่ายวิดีโอเสียงและข้อมูลเซ็นเซอร์ซึ่งทั้งหมดนี้มักจะไม่มีป้ายกำกับ แทนที่จะติดฉลากข้อมูลด้วยตนเองโดยมนุษย์ RBM จะจัดเรียงข้อมูลโดยอัตโนมัติ โดยการปรับน้ำหนักและอคติอย่างเหมาะสม RBM สามารถดึงคุณสมบัติที่สำคัญและสร้างข้อมูลเข้าใหม่ได้ RBM เป็นส่วนหนึ่งของตระกูลตาข่ายประสาทแยกคุณลักษณะซึ่งออกแบบมาเพื่อจดจำรูปแบบโดยธรรมชาติในข้อมูล สิ่งเหล่านี้เรียกว่าตัวเข้ารหัสอัตโนมัติเนื่องจากต้องเข้ารหัสโครงสร้างของตัวเอง
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/rbm_structure.jpg)
Deep Belief Networks - DBNs
เครือข่ายความเชื่อลึก (DBN) เกิดขึ้นจากการรวม RBM และแนะนำวิธีการฝึกอบรมที่ชาญฉลาด เรามีโมเดลใหม่ที่สามารถแก้ปัญหาการไล่ระดับสีที่หายไปได้ในที่สุด Geoff Hinton ได้คิดค้น RBMs และ Deep Belief Nets เพื่อเป็นทางเลือกในการเผยแพร่กลับ
DBN มีโครงสร้างคล้ายกับ MLP (Multi-layer perceptron) แต่แตกต่างกันมากเมื่อพูดถึงการฝึกอบรม เป็นการฝึกอบรมที่ช่วยให้ DBN มีประสิทธิภาพเหนือกว่าคู่หูระดับตื้นของพวกเขา
DBN สามารถมองเห็นเป็นสแต็กของ RBMs โดยที่เลเยอร์ที่ซ่อนอยู่ของ RBM หนึ่งเลเยอร์คือเลเยอร์ที่มองเห็นได้ของ RBM ที่อยู่ด้านบน RBM แรกได้รับการฝึกฝนให้สร้างอินพุตใหม่ให้ถูกต้องที่สุด
เลเยอร์ที่ซ่อนอยู่ของ RBM แรกถูกนำมาเป็นเลเยอร์ที่มองเห็นได้ของ RBM ที่สองและ RBM ที่สองได้รับการฝึกฝนโดยใช้เอาต์พุตจาก RBM แรก กระบวนการนี้จะวนซ้ำจนกว่าทุกเลเยอร์ในเครือข่ายจะได้รับการฝึกฝน
ใน DBN RBM แต่ละตัวจะเรียนรู้อินพุตทั้งหมด DBN ทำงานได้ทั่วโลกโดยการปรับแต่งอินพุตทั้งหมดอย่างต่อเนื่องในขณะที่โมเดลดีขึ้นอย่างช้าๆเช่นเลนส์กล้องที่โฟกัสภาพอย่างช้าๆ สแต็กของ RBM มีประสิทธิภาพดีกว่า RBM เดียวเนื่องจาก MLP ของ Perceptron หลายชั้นมีประสิทธิภาพดีกว่า Perceptron ตัวเดียว
ในขั้นตอนนี้ RBM ได้ตรวจพบรูปแบบโดยธรรมชาติในข้อมูล แต่ไม่มีชื่อหรือป้ายกำกับใด ๆ เพื่อสิ้นสุดการฝึก DBN เราต้องแนะนำป้ายกำกับให้กับรูปแบบและปรับแต่งเน็ตด้วยการเรียนรู้ภายใต้การดูแล
เราต้องการชุดตัวอย่างที่มีป้ายกำกับขนาดเล็กมากเพื่อให้สามารถเชื่อมโยงคุณลักษณะและรูปแบบกับชื่อได้ ชุดข้อมูลขนาดเล็กนี้ใช้สำหรับการฝึกอบรม ข้อมูลที่ติดป้ายกำกับชุดนี้อาจมีขนาดเล็กมากเมื่อเทียบกับชุดข้อมูลเดิม
น้ำหนักและอคติมีการเปลี่ยนแปลงเล็กน้อยส่งผลให้การรับรู้รูปแบบของตาข่ายเปลี่ยนไปเล็กน้อยและมักจะเพิ่มขึ้นเล็กน้อยในความแม่นยำทั้งหมด
การฝึกอบรมสามารถเสร็จสิ้นได้ในระยะเวลาที่เหมาะสมโดยใช้ GPU ซึ่งให้ผลลัพธ์ที่แม่นยำมากเมื่อเทียบกับมุ้งตื้นและเราเห็นวิธีแก้ปัญหาการไล่ระดับสีด้วย
Generative Adversarial Networks - GAN
Generative adversarial network คืออวนประสาทที่ลึกซึ่งประกอบไปด้วยสองอวนโดยติดกับอีกอันหนึ่งจึงเรียกว่า "adversarial"
GAN ได้รับการแนะนำในบทความที่เผยแพร่โดยนักวิจัยจากมหาวิทยาลัยมอนทรีออลในปี 2014 Yann LeCun ผู้เชี่ยวชาญด้าน AI ของ Facebook กล่าวถึง GAN ซึ่งเรียกว่าการฝึกอบรมฝ่ายตรงข้าม "แนวคิดที่น่าสนใจที่สุดในช่วง 10 ปีที่ผ่านมาใน ML"
ศักยภาพของ GAN นั้นใหญ่มากเนื่องจากการสแกนเครือข่ายเรียนรู้ที่จะเลียนแบบการกระจายข้อมูลใด ๆ GAN สามารถสอนให้สร้างโลกคู่ขนานที่คล้ายกับของเราในโดเมนใดก็ได้ไม่ว่าจะเป็นรูปภาพเพลงคำพูดร้อยแก้ว พวกเขาเป็นศิลปินหุ่นยนต์ในทางหนึ่งและผลลัพธ์ของพวกเขาค่อนข้างน่าประทับใจ
ใน GAN เครือข่ายประสาทเทียมเครือข่ายหนึ่งที่เรียกว่าเครื่องกำเนิดไฟฟ้าจะสร้างอินสแตนซ์ข้อมูลใหม่ในขณะที่อีกตัวเลือกปฏิบัติจะประเมินค่าเหล่านี้เพื่อความถูกต้อง
สมมติว่าเรากำลังพยายามสร้างตัวเลขที่เขียนด้วยมือเช่นเดียวกับที่พบในชุดข้อมูล MNIST ซึ่งนำมาจากโลกแห่งความเป็นจริง การทำงานของตัวเลือกเมื่อแสดงอินสแตนซ์จากชุดข้อมูล MNIST ที่แท้จริงคือการยอมรับว่าเป็นของจริง
พิจารณาขั้นตอนต่อไปนี้ของ GAN -
เครือข่ายเครื่องกำเนิดไฟฟ้ารับอินพุตในรูปแบบของตัวเลขสุ่มและส่งคืนรูปภาพ
รูปภาพที่สร้างขึ้นนี้ได้รับเป็นอินพุตไปยังเครือข่ายดิสทิเนเตอร์พร้อมกับสตรีมของรูปภาพที่ถ่ายจากชุดข้อมูลจริง
ตัวเลือกใช้ทั้งภาพจริงและของปลอมและแสดงผลความน่าจะเป็นตัวเลขระหว่าง 0 ถึง 1 โดย 1 แทนการคาดคะเนความถูกต้องและ 0 แทนของปลอม
ดังนั้นคุณจึงมีการตอบรับสองครั้ง -
ผู้เลือกปฏิบัติอยู่ในลูปข้อเสนอแนะกับความจริงพื้นฐานของภาพซึ่งเราทราบดี
เครื่องกำเนิดไฟฟ้าอยู่ในลูปข้อเสนอแนะกับตัวเลือก
เครือข่ายประสาทที่เกิดซ้ำ - RNNs
RNNเครือข่ายประสาทเทียมที่ข้อมูลสามารถไหลไปในทิศทางใดก็ได้ เครือข่ายเหล่านี้ใช้สำหรับแอปพลิเคชันเช่นการสร้างแบบจำลองภาษาหรือการประมวลผลภาษาธรรมชาติ (NLP)
แนวคิดพื้นฐานที่อยู่ภายใต้ RNN คือการใช้ข้อมูลตามลำดับ ในโครงข่ายประสาทเทียมปกติจะถือว่าอินพุตและเอาต์พุตทั้งหมดเป็นอิสระจากกัน หากเราต้องการทำนายคำถัดไปในประโยคเราต้องรู้ว่าคำใดมาก่อนคำนั้น
RNN ถูกเรียกว่าเกิดซ้ำเนื่องจากทำซ้ำงานเดียวกันสำหรับทุกองค์ประกอบของลำดับโดยเอาต์พุตจะขึ้นอยู่กับการคำนวณก่อนหน้านี้ ดังนั้น RNN จึงสามารถกล่าวได้ว่ามี "หน่วยความจำ" ที่รวบรวมข้อมูลเกี่ยวกับสิ่งที่คำนวณไว้ก่อนหน้านี้ ตามทฤษฎีแล้ว RNN สามารถใช้ข้อมูลในลำดับที่ยาวมาก แต่ในความเป็นจริงสามารถย้อนกลับไปดูได้เพียงไม่กี่ขั้นตอนเท่านั้น
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/recurrent_neural_networks.jpg)
เครือข่ายหน่วยความจำระยะสั้นยาว (LSTMs) เป็น RNN ที่ใช้บ่อยที่สุด
ร่วมกับ Convolutional Neural Networks ได้ใช้ RNN เป็นส่วนหนึ่งของแบบจำลองเพื่อสร้างคำอธิบายสำหรับรูปภาพที่ไม่มีป้ายกำกับ มันน่าทึ่งมากที่มันใช้งานได้ดี
Convolutional Deep Neural Networks - CNNs
หากเราเพิ่มจำนวนเลเยอร์ในโครงข่ายประสาทเทียมให้ลึกขึ้นจะเป็นการเพิ่มความซับซ้อนของเครือข่ายและทำให้เราสามารถจำลองฟังก์ชันที่ซับซ้อนมากขึ้นได้ อย่างไรก็ตามจำนวนน้ำหนักและอคติจะเพิ่มขึ้นอย่างทวีคูณ ตามความเป็นจริงการเรียนรู้ปัญหาที่ยากเช่นนี้อาจเป็นไปไม่ได้สำหรับโครงข่ายประสาทเทียมปกติ สิ่งนี้นำไปสู่การแก้ปัญหาคือโครงข่ายประสาทเทียม
CNN ถูกใช้อย่างกว้างขวางในการมองเห็นของคอมพิวเตอร์ ยังถูกนำไปใช้ในการสร้างแบบจำลองอะคูสติกสำหรับการรู้จำเสียงอัตโนมัติ
แนวคิดเบื้องหลังโครงข่ายประสาทเทียมคือแนวคิดของ "ฟิลเตอร์เคลื่อนที่" ซึ่งส่งผ่านภาพ ตัวกรองการเคลื่อนไหวหรือการแปลงนี้ใช้กับพื้นที่ใกล้เคียงของโหนดซึ่งตัวอย่างเช่นอาจเป็นพิกเซลโดยที่ตัวกรองใช้คือ 0.5 x ค่าโหนด -
นักวิจัยชื่อ Yann LeCun เป็นผู้บุกเบิกโครงข่ายประสาทเทียมแบบ Convolutional Facebook เป็นซอฟต์แวร์จดจำใบหน้าใช้มุ้งเหล่านี้ CNN เป็นทางออกสำหรับโครงการวิชันซิสเต็ม เครือข่าย Convolutional Network มีหลายชั้น ในความท้าทายของ Imagenet เครื่องจักรสามารถเอาชนะมนุษย์ที่จดจำวัตถุได้ในปี 2558
โดยสรุป Convolutional Neural Networks (CNNs) เป็นเครือข่ายประสาทเทียมหลายชั้น บางครั้งเลเยอร์อาจมากถึง 17 หรือมากกว่าและถือว่าข้อมูลที่ป้อนเป็นรูปภาพ
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/convolutional_neural_networks.jpg)
CNN ลดจำนวนพารามิเตอร์ที่ต้องปรับแต่งลงอย่างมาก ดังนั้น CNN จึงจัดการกับภาพดิบที่มีมิติสูงได้อย่างมีประสิทธิภาพ
ในบทนี้เราจะมาดูพื้นฐานของ Python Deep Learning
โมเดล / อัลกอริทึมการเรียนรู้เชิงลึก
ตอนนี้ให้เราเรียนรู้เกี่ยวกับโมเดล / อัลกอริทึมการเรียนรู้เชิงลึกต่างๆ
โมเดลยอดนิยมบางส่วนภายในการเรียนรู้เชิงลึกมีดังนี้ -
- โครงข่ายประสาทเทียม
- เครือข่ายประสาทที่กำเริบ
- เครือข่ายความเชื่อที่ลึกซึ้ง
- เครือข่ายฝ่ายตรงข้ามโดยกำเนิด
- ตัวเข้ารหัสอัตโนมัติและอื่น ๆ
อินพุตและเอาต์พุตแสดงเป็นเวกเตอร์หรือเทนเซอร์ ตัวอย่างเช่นโครงข่ายประสาทเทียมอาจมีอินพุตที่แสดงค่า RGB ของพิกเซลแต่ละรายการเป็นเวกเตอร์
ชั้นของเซลล์ประสาทที่อยู่ระหว่างชั้นอินพุตและชั้นเอาต์พุตเรียกว่าชั้นที่ซ่อนอยู่ นี่คือจุดที่งานส่วนใหญ่เกิดขึ้นเมื่อตาข่ายประสาทพยายามแก้ปัญหา การดูเลเยอร์ที่ซ่อนอยู่อย่างละเอียดยิ่งขึ้นสามารถเปิดเผยคุณสมบัติต่างๆที่เครือข่ายได้เรียนรู้ในการดึงข้อมูลออกมา
โครงสร้างต่างๆของเครือข่ายประสาทเกิดขึ้นโดยการเลือกเซลล์ประสาทที่จะเชื่อมต่อกับเซลล์ประสาทอื่นในชั้นถัดไป
Pseudocode สำหรับคำนวณเอาต์พุต
ต่อไปนี้คือ pseudocode สำหรับคำนวณเอาต์พุตของ Forward-propagating Neural Network -
- # node []: = อาร์เรย์ของโหนดที่เรียงลำดับโทโลจิคัล
- # ขอบจาก a ถึง b หมายถึง a อยู่ทางซ้ายของ b
- # หาก Neural Network มีอินพุต R และเอาต์พุต S
- # จากนั้นโหนด R แรกคือโหนดอินพุตและโหนด S สุดท้ายคือโหนดเอาต์พุต
- # ขาเข้า [x]: = โหนดที่เชื่อมต่อกับโหนด x
- # weight [x]: = น้ำหนักของขอบขาเข้าถึง x
สำหรับแต่ละเซลล์ประสาท x จากซ้ายไปขวา -
- ถ้า x <= R: อย่าทำอะไรเลย # เป็นโหนดอินพุต
- อินพุต [x] = [เอาต์พุต [i] สำหรับ i ในขาเข้า [x]]
- weighted_sum = dot_product (น้ำหนัก [x], อินพุต [x])
- เอาต์พุต [x] = Activation_function (weighted_sum)
ตอนนี้เราจะเรียนรู้วิธีฝึกโครงข่ายประสาทเทียม นอกจากนี้เรายังจะได้เรียนรู้อัลกอริทึมการเผยแพร่ย้อนกลับและการส่งย้อนกลับใน Python Deep Learning
เราต้องหาค่าที่เหมาะสมที่สุดของน้ำหนักของโครงข่ายประสาทเทียมเพื่อให้ได้ผลลัพธ์ที่ต้องการ ในการฝึกโครงข่ายประสาทเราใช้วิธีการไล่ระดับสีซ้ำ ๆ เราเริ่มต้นด้วยการเริ่มต้นน้ำหนักแบบสุ่ม หลังจากการเริ่มต้นแบบสุ่มเราทำการคาดคะเนข้อมูลบางส่วนด้วยกระบวนการส่งต่อไปข้างหน้าคำนวณฟังก์ชันต้นทุนที่สอดคล้องกัน C และอัปเดตน้ำหนักแต่ละตัวด้วยจำนวนที่เป็นสัดส่วนกับ dC / dw กล่าวคืออนุพันธ์ของฟังก์ชันต้นทุนเขียน น้ำหนัก. ค่าคงที่ตามสัดส่วนเรียกว่าอัตราการเรียนรู้
สามารถคำนวณการไล่ระดับสีได้อย่างมีประสิทธิภาพโดยใช้อัลกอริธึมการแพร่กระจายย้อนกลับ ข้อสังเกตที่สำคัญของการขยายพันธุ์ย้อนกลับหรือ backward prop คือเนื่องจากกฎลูกโซ่ของความแตกต่างการไล่ระดับสีที่เซลล์ประสาทแต่ละเซลล์ในเครือข่ายประสาทสามารถคำนวณได้โดยใช้การไล่ระดับสีที่เซลล์ประสาทซึ่งมีขอบขาออกไป ดังนั้นเราจึงคำนวณการไล่ระดับสีไปข้างหลังกล่าวคือก่อนอื่นให้คำนวณการไล่ระดับของเลเยอร์เอาต์พุตจากนั้นเลเยอร์ที่ซ่อนอยู่ด้านบนสุดตามด้วยเลเยอร์ที่ซ่อนอยู่ก่อนหน้าและอื่น ๆ สิ้นสุดที่เลเยอร์อินพุต
อัลกอริธึมการขยายพันธุ์ย้อนกลับถูกนำไปใช้โดยส่วนใหญ่ใช้แนวคิดของกราฟการคำนวณซึ่งเซลล์ประสาทแต่ละเซลล์จะขยายไปยังโหนดจำนวนมากในกราฟการคำนวณและดำเนินการทางคณิตศาสตร์อย่างง่ายเช่นการบวกการคูณ กราฟการคำนวณไม่มีน้ำหนักที่ขอบ น้ำหนักทั้งหมดจะถูกกำหนดให้กับโหนดดังนั้นน้ำหนักจึงกลายเป็นโหนดของตัวเอง จากนั้นอัลกอริทึมการแพร่กระจายย้อนกลับจะถูกเรียกใช้บนกราฟการคำนวณ เมื่อการคำนวณเสร็จสมบูรณ์จำเป็นต้องมีการไล่ระดับของโหนดน้ำหนักเท่านั้นสำหรับการอัปเดต ส่วนที่เหลือของการไล่ระดับสีสามารถละทิ้งได้
เทคนิคการเพิ่มประสิทธิภาพการไล่ระดับสี
ฟังก์ชันการเพิ่มประสิทธิภาพที่ใช้กันทั่วไปอย่างหนึ่งซึ่งจะปรับน้ำหนักตามข้อผิดพลาดที่เกิดขึ้นเรียกว่า "การลดระดับการไล่ระดับสี"
Gradient เป็นอีกชื่อหนึ่งสำหรับความชันและความชันบนกราฟ xy แสดงให้เห็นว่าตัวแปรสองตัวมีความสัมพันธ์กันอย่างไร: การเพิ่มขึ้นจากการวิ่งการเปลี่ยนแปลงระยะทางในช่วงเวลาที่เปลี่ยนแปลงเป็นต้นในกรณีนี้ความชันคือ อัตราส่วนระหว่างข้อผิดพลาดของเครือข่ายและน้ำหนักเดียว กล่าวคือข้อผิดพลาดจะเปลี่ยนไปอย่างไรเมื่อน้ำหนักแตกต่างกัน
เพื่อให้แม่นยำยิ่งขึ้นเราต้องการหาน้ำหนักที่ทำให้เกิดข้อผิดพลาดน้อยที่สุด เราต้องการหาน้ำหนักที่แสดงถึงสัญญาณที่มีอยู่ในข้อมูลอินพุตได้อย่างถูกต้องและแปลเป็นการจำแนกประเภทที่ถูกต้อง
ในขณะที่เครือข่ายประสาทเทียมเรียนรู้มันจะค่อยๆปรับน้ำหนักจำนวนมากอย่างช้าๆเพื่อให้สามารถจับคู่สัญญาณกับความหมายได้อย่างถูกต้อง อัตราส่วนระหว่างข้อผิดพลาดของเครือข่ายและน้ำหนักแต่ละตัวเป็นอนุพันธ์ dE / dw ที่คำนวณขอบเขตที่น้ำหนักที่เปลี่ยนแปลงเล็กน้อยทำให้เกิดการเปลี่ยนแปลงเล็กน้อยในข้อผิดพลาด
น้ำหนักแต่ละตัวเป็นเพียงปัจจัยหนึ่งในเครือข่ายระดับลึกที่เกี่ยวข้องกับการเปลี่ยนแปลงมากมาย สัญญาณของน้ำหนักจะส่งผ่านการกระตุ้นและผลรวมในหลาย ๆ ชั้นดังนั้นเราจึงใช้กฎลูกโซ่ของแคลคูลัสในการทำงานย้อนกลับผ่านการเปิดใช้งานเครือข่ายและเอาต์พุตสิ่งนี้นำเราไปสู่น้ำหนักที่เป็นปัญหาและความสัมพันธ์กับข้อผิดพลาดโดยรวม
กำหนดให้สองตัวแปรข้อผิดพลาดและน้ำหนักถูกสื่อกลางด้วยตัวแปรที่สาม activationซึ่งน้ำหนักจะถูกส่งผ่าน เราสามารถคำนวณได้ว่าการเปลี่ยนแปลงของน้ำหนักมีผลต่อการเปลี่ยนแปลงข้อผิดพลาดอย่างไรโดยการคำนวณก่อนว่าการเปลี่ยนแปลงในการเปิดใช้งานมีผลต่อการเปลี่ยนแปลงข้อผิดพลาดอย่างไรและการเปลี่ยนแปลงของน้ำหนักมีผลต่อการเปลี่ยนแปลงการเปิดใช้งานอย่างไร
แนวคิดพื้นฐานในการเรียนรู้เชิงลึกไม่มีอะไรมากไปกว่านั้นคือการปรับน้ำหนักของโมเดลเพื่อตอบสนองต่อข้อผิดพลาดที่เกิดขึ้นจนกว่าคุณจะไม่สามารถลดข้อผิดพลาดได้อีกต่อไป
ตาข่ายลึกจะค่อยๆฝึกอย่างช้าๆหากค่าการไล่ระดับสีน้อยและเร็วหากค่าสูง ความไม่ถูกต้องใด ๆ ในการฝึกอบรมนำไปสู่ผลลัพธ์ที่ไม่ถูกต้อง ขั้นตอนการฝึกอวนจากเอาต์พุตกลับไปยังอินพุตเรียกว่าการแพร่กระจายกลับหรือ back prop เราทราบดีว่าการเผยแพร่ไปข้างหน้าเริ่มต้นด้วยอินพุตและทำงานไปข้างหน้า เสาหลังทำย้อนกลับ / ตรงข้ามคำนวณการไล่ระดับสีจากขวาไปซ้าย
ทุกครั้งที่เราคำนวณการไล่ระดับสีเราจะใช้การไล่ระดับสีก่อนหน้าทั้งหมดจนถึงจุดนั้น
ให้เราเริ่มต้นที่โหนดในเลเยอร์เอาต์พุต ขอบใช้การไล่ระดับสีที่โหนดนั้น เมื่อเรากลับเข้าไปในเลเยอร์ที่ซ่อนอยู่มันจะซับซ้อนมากขึ้น ผลคูณของตัวเลขสองตัวระหว่าง 0 ถึง 1 ทำให้คุณมีจำนวนน้อยลง ค่าการไล่ระดับสีจะเล็กลงเรื่อย ๆ และผลที่ตามมา back prop ต้องใช้เวลามากในการฝึกฝนและความแม่นยำก็ต้องทนทุกข์ทรมาน
ความท้าทายในอัลกอริทึมการเรียนรู้เชิงลึก
มีความท้าทายบางอย่างสำหรับทั้งโครงข่ายประสาทเทียมแบบตื้นและโครงข่ายประสาทเทียมแบบลึกเช่นการใส่อุปกรณ์มากเกินไปและเวลาในการคำนวณ DNN ได้รับผลกระทบจากการใส่มากเกินไปเนื่องจากการใช้เลเยอร์ที่เป็นนามธรรมที่เพิ่มเข้ามาซึ่งทำให้สามารถสร้างแบบจำลองการอ้างอิงที่หายากในข้อมูลการฝึกอบรม
Regularizationวิธีการต่างๆเช่นการออกกลางคันการหยุดก่อนกำหนดการเพิ่มข้อมูลการถ่ายโอนการเรียนรู้ถูกนำไปใช้ในระหว่างการฝึกอบรมเพื่อต่อสู้กับการฟิตติ้งมากเกินไป ยกเลิกการทำให้เป็นมาตรฐานโดยสุ่มละเว้นหน่วยจากเลเยอร์ที่ซ่อนอยู่ในระหว่างการฝึกอบรมซึ่งช่วยในการหลีกเลี่ยงการพึ่งพาที่หายาก DNN จะคำนึงถึงพารามิเตอร์การฝึกอบรมหลายประการเช่นขนาดเช่นจำนวนชั้นและจำนวนหน่วยต่อชั้นอัตราการเรียนรู้และน้ำหนักเริ่มต้น การค้นหาพารามิเตอร์ที่เหมาะสมไม่สามารถใช้ได้จริงเสมอไปเนื่องจากต้นทุนด้านเวลาและทรัพยากรในการคำนวณสูง การแฮ็กหลายอย่างเช่น batching สามารถเร่งความเร็วในการคำนวณ พลังการประมวลผลขนาดใหญ่ของ GPU ช่วยให้กระบวนการฝึกอบรมเป็นอย่างมากเนื่องจากการคำนวณเมทริกซ์และเวกเตอร์ที่จำเป็นนั้นได้รับการดำเนินการอย่างดีบน GPU
ออกกลางคัน
การออกกลางคันเป็นเทคนิคการทำให้เป็นมาตรฐานยอดนิยมสำหรับเครือข่ายประสาทเทียม โครงข่ายประสาทส่วนลึกมีแนวโน้มที่จะติดตั้งมากเกินไป
ตอนนี้ให้เราดูว่าการออกกลางคันคืออะไรและทำงานอย่างไร
ในคำพูดของ Geoffrey Hinton หนึ่งในผู้บุกเบิก Deep Learning 'ถ้าคุณมีตาข่ายประสาทที่ลึกและไม่พอดีมากเกินไปคุณน่าจะใช้อันที่ใหญ่กว่าและใช้การออกกลางคัน'
การออกกลางคันเป็นเทคนิคที่ในระหว่างการวนซ้ำของการไล่ระดับสีแต่ละครั้งเราจะทิ้งชุดของโหนดที่เลือกแบบสุ่ม ซึ่งหมายความว่าเราไม่สนใจโหนดบางโหนดแบบสุ่มราวกับว่าไม่มีอยู่จริง
เซลล์ประสาทแต่ละเซลล์จะถูกเก็บไว้ด้วยความน่าจะเป็นของ q และลดลงแบบสุ่มโดยมีความน่าจะเป็น 1-q ค่า q อาจแตกต่างกันสำหรับแต่ละเลเยอร์ในโครงข่ายประสาทเทียม ค่า 0.5 สำหรับเลเยอร์ที่ซ่อนอยู่และ 0 สำหรับเลเยอร์อินพุตทำงานได้ดีกับงานหลากหลายประเภท
ในระหว่างการประเมินและการทำนายจะไม่มีการใช้การออกกลางคัน ผลลัพธ์ของเซลล์ประสาทแต่ละเซลล์จะคูณด้วย q เพื่อให้อินพุตไปยังชั้นถัดไปมีค่าที่คาดหวังไว้เท่ากัน
แนวคิดเบื้องหลังการออกกลางคันมีดังต่อไปนี้ - ในเครือข่ายประสาทที่ไม่มีการทำให้เป็นระเบียบกลางคันเซลล์ประสาทจะพัฒนาการพึ่งพาซึ่งกันและกันซึ่งนำไปสู่การติดตั้งมากเกินไป
เคล็ดลับการติดตั้ง
การออกกลางคันถูกนำไปใช้ในไลบรารีเช่น TensorFlow และ Pytorch โดยรักษาเอาต์พุตของเซลล์ประสาทที่สุ่มเลือกเป็น 0 นั่นคือแม้ว่าเซลล์ประสาทจะมีอยู่ แต่เอาต์พุตของมันจะถูกเขียนทับเป็น 0
การหยุดก่อนกำหนด
เราฝึกโครงข่ายประสาทโดยใช้อัลกอริทึมซ้ำที่เรียกว่าการไล่ระดับสี
แนวคิดที่อยู่เบื้องหลังการหยุดก่อนกำหนดนั้นใช้งานง่าย เราหยุดการฝึกอบรมเมื่อข้อผิดพลาดเริ่มเพิ่มขึ้น โดยข้อผิดพลาดเราหมายถึงข้อผิดพลาดที่วัดจากข้อมูลการตรวจสอบความถูกต้องซึ่งเป็นส่วนหนึ่งของข้อมูลการฝึกอบรมที่ใช้สำหรับการปรับค่าไฮเปอร์พารามิเตอร์ ในกรณีนี้ไฮเปอร์พารามิเตอร์คือเกณฑ์การหยุด
การเพิ่มข้อมูล
กระบวนการที่เราเพิ่มควอนตัมของข้อมูลที่เรามีหรือเพิ่มโดยใช้ข้อมูลที่มีอยู่และใช้การแปลงบางอย่างกับมัน การเปลี่ยนแปลงที่แน่นอนที่ใช้ขึ้นอยู่กับงานที่เราตั้งใจจะบรรลุ ยิ่งไปกว่านั้นการเปลี่ยนแปลงที่ช่วยให้ตาข่ายประสาทขึ้นอยู่กับสถาปัตยกรรมของมัน
ตัวอย่างเช่นในงานด้านการมองเห็นของคอมพิวเตอร์หลายอย่างเช่นการจัดประเภทวัตถุเทคนิคการเพิ่มข้อมูลที่มีประสิทธิภาพคือการเพิ่มจุดข้อมูลใหม่ที่มีการครอบตัดหรือแปลข้อมูลต้นฉบับ
เมื่อคอมพิวเตอร์ยอมรับรูปภาพเป็นอินพุตจะใช้อาร์เรย์ของค่าพิกเซล สมมติว่าภาพทั้งหมดถูกเลื่อนไปทางซ้าย 15 พิกเซล เราใช้การเปลี่ยนแปลงที่แตกต่างกันจำนวนมากในทิศทางที่แตกต่างกันส่งผลให้มีชุดข้อมูลที่เพิ่มขึ้นหลายเท่าของขนาดของชุดข้อมูลเดิม
ถ่ายทอดการเรียนรู้
กระบวนการในการทำแบบจำลองก่อนการฝึกอบรมและ "ปรับแต่ง" แบบจำลองด้วยชุดข้อมูลของเราเองเรียกว่าการเรียนรู้แบบถ่ายโอน มีหลายวิธีในการดำเนินการดังต่อไปนี้:
เราฝึกโมเดลก่อนการฝึกอบรมบนชุดข้อมูลขนาดใหญ่ จากนั้นเราลบเลเยอร์สุดท้ายของเครือข่ายและแทนที่ด้วยเลเยอร์ใหม่ด้วยน้ำหนักแบบสุ่ม
จากนั้นเราตรึงน้ำหนักของเลเยอร์อื่น ๆ ทั้งหมดและฝึกเครือข่ายตามปกติ การแช่แข็งเลเยอร์ในที่นี้ไม่ได้เปลี่ยนน้ำหนักระหว่างการไล่ระดับสีหรือการเพิ่มประสิทธิภาพ
แนวคิดเบื้องหลังนี้คือโมเดลที่ได้รับการฝึกฝนมาแล้วจะทำหน้าที่เป็นตัวแยกคุณลักษณะและจะมีการฝึกเฉพาะเลเยอร์สุดท้ายในงานปัจจุบัน
Backpropagation ถูกนำไปใช้ในกรอบการเรียนรู้เชิงลึกเช่น Tensorflow, Torch, Theano เป็นต้นโดยใช้กราฟเชิงคำนวณ ที่สำคัญยิ่งไปกว่านั้นการทำความเข้าใจเกี่ยวกับการแพร่กระจายย้อนกลับบนกราฟการคำนวณจะรวมอัลกอริทึมที่แตกต่างกันและรูปแบบต่างๆเช่น backprop ผ่านเวลาและ backprop ที่มีน้ำหนักร่วมกัน เมื่อทุกอย่างถูกแปลงเป็นกราฟการคำนวณแล้วก็ยังคงเป็นอัลกอริทึมเดิม - เพียงแค่กลับการเผยแพร่บนกราฟการคำนวณ
Computational Graph คืออะไร
กราฟการคำนวณถูกกำหนดให้เป็นกราฟกำกับโดยที่โหนดสอดคล้องกับการดำเนินการทางคณิตศาสตร์ กราฟเชิงคำนวณเป็นวิธีการแสดงและประเมินนิพจน์ทางคณิตศาสตร์
ตัวอย่างเช่นนี่คือสมการทางคณิตศาสตร์อย่างง่าย -
$$p = x+y$$
เราสามารถวาดกราฟการคำนวณของสมการข้างต้นได้ดังนี้
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/computational_graph_equation1.jpg)
กราฟการคำนวณข้างต้นมีโหนดเพิ่มเติม (โหนดที่มีเครื่องหมาย "+") ที่มีตัวแปรอินพุตสองตัว x และ y และหนึ่งเอาต์พุต q
ให้เราใช้ตัวอย่างอื่นที่ซับซ้อนกว่าเล็กน้อย เรามีสมการดังต่อไปนี้
$$g = \left (x+y \right ) \ast z $$
สมการข้างต้นแสดงด้วยกราฟการคำนวณต่อไปนี้
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/computational_graph_equation2.jpg)
กราฟเชิงคำนวณและ Backpropagation
กราฟเชิงคำนวณและ backpropagation ทั้งสองเป็นแนวคิดหลักที่สำคัญในการเรียนรู้เชิงลึกสำหรับการฝึกอบรมเครือข่ายประสาทเทียม
ส่งต่อ
การส่งต่อเป็นขั้นตอนในการประเมินค่าของนิพจน์ทางคณิตศาสตร์ที่แสดงโดยกราฟเชิงคำนวณ การส่งต่อหมายความว่าเรากำลังส่งค่าจากตัวแปรในทิศทางไปข้างหน้าจากทางซ้าย (อินพุต) ไปทางขวาที่เอาต์พุตอยู่
ให้เราพิจารณาตัวอย่างโดยการให้คุณค่ากับปัจจัยการผลิตทั้งหมด สมมติว่าค่าต่อไปนี้ถูกกำหนดให้กับอินพุตทั้งหมด
$$x=1, y=3, z=−3$$
ด้วยการให้ค่าเหล่านี้กับอินพุตเราสามารถทำการส่งต่อและรับค่าต่อไปนี้สำหรับเอาต์พุตบนแต่ละโหนด
ขั้นแรกเราใช้ค่าของ x = 1 และ y = 3 เพื่อให้ได้ p = 4
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/forward_pass.jpg)
จากนั้นเราใช้ p = 4 และ z = -3 เพื่อรับ g = -12 จากซ้ายไปขวาไปข้างหน้า
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/forward_pass_equation.jpg)
วัตถุประสงค์ของ Backward Pass
ในการส่งย้อนกลับความตั้งใจของเราคือการคำนวณการไล่ระดับสีสำหรับแต่ละอินพุตที่เกี่ยวข้องกับผลลัพธ์สุดท้าย การไล่ระดับสีเหล่านี้จำเป็นสำหรับการฝึกโครงข่ายประสาทโดยใช้การไล่ระดับสี
ตัวอย่างเช่นเราต้องการการไล่ระดับสีต่อไปนี้
การไล่ระดับสีที่ต้องการ
$$\frac{\partial x}{\partial f}, \frac{\partial y}{\partial f}, \frac{\partial z}{\partial f}$$
ย้อนกลับ (backpropagation)
เราเริ่มต้นการย้อนกลับโดยการหาอนุพันธ์ของผลลัพธ์สุดท้ายที่เกี่ยวข้องกับผลลัพธ์สุดท้าย (ตัวมันเอง!) ดังนั้นมันจะส่งผลให้ได้มาซึ่งเอกลักษณ์และมูลค่าเท่ากับหนึ่ง
$$\frac{\partial g}{\partial g} = 1$$
กราฟการคำนวณของเรามีลักษณะดังที่แสดงด้านล่าง -
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/backward_pass.jpg)
ต่อไปเราจะทำการย้อนกลับผ่านการดำเนินการ "*" เราจะคำนวณการไล่ระดับที่ p และ z เนื่องจาก g = p * z เรารู้ว่า -
$$\frac{\partial g}{\partial z} = p$$
$$\frac{\partial g}{\partial p} = z$$
เรารู้ค่า z และ p จากฟอร์เวิร์ดพาสแล้ว ดังนั้นเราจึงได้รับ -
$$\frac{\partial g}{\partial z} = p = 4$$
และ
$$\frac{\partial g}{\partial p} = z = -3$$
เราต้องการคำนวณการไล่ระดับสีที่ x และ y -
$$\frac{\partial g}{\partial x}, \frac{\partial g}{\partial y}$$
อย่างไรก็ตามเราต้องการทำสิ่งนี้อย่างมีประสิทธิภาพ (แม้ว่า x และ g จะอยู่ห่างกันเพียงสองฮ็อปในกราฟนี้ แต่ลองนึกภาพพวกมันอยู่ไกลจากกันจริงๆ) ในการคำนวณค่าเหล่านี้อย่างมีประสิทธิภาพเราจะใช้กฎลูกโซ่ของความแตกต่าง จากกฎลูกโซ่เรามี -
$$\frac{\partial g}{\partial x}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial x}$$
$$\frac{\partial g}{\partial y}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial y}$$
แต่เรารู้แล้วว่า dg / dp = -3, dp / dx และ dp / dy นั้นง่ายเนื่องจาก p ขึ้นอยู่กับ x และ y โดยตรง เรามี -
$$p=x+y\Rightarrow \frac{\partial x}{\partial p} = 1, \frac{\partial y}{\partial p} = 1$$
ดังนั้นเราจึงได้รับ -
$$\frac{\partial g} {\partial f} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial x} = \left ( -3 \right ).1 = -3$$
นอกจากนี้สำหรับอินพุต y -
$$\frac{\partial g} {\partial y} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial y} = \left ( -3 \right ).1 = -3$$
เหตุผลหลักในการทำสิ่งนี้ย้อนหลังคือเมื่อเราต้องคำนวณการไล่ระดับสีที่ x เราใช้เฉพาะค่าที่คำนวณแล้วและ dq / dx (อนุพันธ์ของโหนดเอาต์พุตเทียบกับอินพุตของโหนดเดียวกัน) เราใช้ข้อมูลในท้องถิ่นเพื่อคำนวณมูลค่าทั่วโลก
ขั้นตอนในการฝึกโครงข่ายประสาทเทียม
ทำตามขั้นตอนเหล่านี้เพื่อฝึกโครงข่ายประสาทเทียม -
สำหรับจุดข้อมูล x ในชุดข้อมูลเราจะส่งต่อโดยใช้ x เป็นอินพุตและคำนวณต้นทุน c เป็นเอาต์พุต
เราทำแบบย้อนกลับโดยเริ่มต้นที่ c และคำนวณการไล่ระดับสำหรับโหนดทั้งหมดในกราฟ ซึ่งรวมถึงโหนดที่แสดงถึงน้ำหนักของโครงข่ายประสาทเทียม
จากนั้นเราจะอัปเดตน้ำหนักโดยทำ W = W - อัตราการเรียนรู้ * การไล่ระดับสี
เราทำซ้ำขั้นตอนนี้จนกว่าจะเป็นไปตามเกณฑ์การหยุด
การเรียนรู้เชิงลึกให้ผลลัพธ์ที่ดีสำหรับแอปพลิเคชันบางอย่างเช่นการมองเห็นด้วยคอมพิวเตอร์การแปลภาษาคำบรรยายภาพการถอดเสียงอณูชีววิทยาการรู้จำเสียงการประมวลผลภาษาธรรมชาติรถยนต์ที่ขับเคลื่อนด้วยตัวเองการตรวจหาเนื้องอกในสมองการแปลคำพูดแบบเรียลไทม์เพลง องค์ประกอบการเล่นเกมอัตโนมัติและอื่น ๆ
การเรียนรู้เชิงลึกเป็นก้าวกระโดดที่ยิ่งใหญ่ครั้งต่อไปหลังจากการเรียนรู้ของเครื่องด้วยการใช้งานขั้นสูง ปัจจุบันกำลังมุ่งหน้าไปสู่การเป็นมาตรฐานอุตสาหกรรมโดยนำสัญญาที่แข็งแกร่งในการเป็นผู้เปลี่ยนเกมเมื่อต้องจัดการกับข้อมูลดิบที่ไม่มีโครงสร้าง
ปัจจุบันการเรียนรู้เชิงลึกเป็นหนึ่งในผู้ให้บริการโซลูชั่นที่ดีที่สุดสำหรับปัญหาต่างๆในโลกแห่งความเป็นจริง นักพัฒนากำลังสร้างโปรแกรม AI ที่แทนที่จะใช้กฎที่กำหนดไว้ก่อนหน้านี้เรียนรู้จากตัวอย่างเพื่อแก้ปัญหางานที่ซับซ้อน ด้วยการใช้การเรียนรู้เชิงลึกโดยนักวิทยาศาสตร์ข้อมูลจำนวนมากเครือข่ายประสาทเทียมที่ลึกขึ้นจะให้ผลลัพธ์ที่แม่นยำยิ่งขึ้น
แนวคิดคือการพัฒนาโครงข่ายประสาทเทียมโดยการเพิ่มจำนวนชั้นการฝึกอบรมสำหรับแต่ละเครือข่าย เครื่องเรียนรู้เพิ่มเติมเกี่ยวกับข้อมูลจนกว่าจะมีความแม่นยำมากที่สุด นักพัฒนาสามารถใช้เทคนิคการเรียนรู้เชิงลึกเพื่อใช้งานแมชชีนเลิร์นนิงที่ซับซ้อนและฝึกอบรมเครือข่าย AI ให้มีการรับรู้การรับรู้ในระดับสูง
การเรียนรู้เชิงลึกพบความนิยมในการมองเห็นคอมพิวเตอร์ หนึ่งในงานที่บรรลุผลคือการจัดประเภทภาพโดยที่ภาพที่ป้อนจะถูกจัดประเภทเป็นแมวสุนัข ฯลฯ หรือเป็นชั้นเรียนหรือป้ายกำกับที่อธิบายภาพได้ดีที่สุด เราในฐานะมนุษย์เรียนรู้วิธีทำงานนี้ตั้งแต่เนิ่นๆในชีวิตของเราและมีทักษะในการจดจำรูปแบบเหล่านี้ได้อย่างรวดเร็วโดยสรุปจากความรู้เดิมและปรับตัวให้เข้ากับสภาพแวดล้อมภาพที่แตกต่างกัน
ในบทนี้เราจะเชื่อมโยงการเรียนรู้เชิงลึกกับไลบรารีและเฟรมเวิร์กต่างๆ
การเรียนรู้เชิงลึกและ Theano
หากเราต้องการเริ่มเขียนโค้ดเครือข่ายประสาทเทียมแบบลึกจะเป็นการดีกว่าที่เราจะมีความคิดว่าเฟรมเวิร์กต่างๆเช่น Theano, TensorFlow, Keras, PyTorch และอื่น ๆ ทำงานอย่างไร
Theano เป็นห้องสมุด python ซึ่งมีชุดฟังก์ชันสำหรับสร้างอวนลึกที่ฝึกบนเครื่องของเราได้อย่างรวดเร็ว
Theano ได้รับการพัฒนาที่มหาวิทยาลัย Montreal ประเทศแคนาดาภายใต้การนำของ Yoshua Bengio ผู้บุกเบิกเครือข่าย
Theano ช่วยให้เรากำหนดและประเมินนิพจน์ทางคณิตศาสตร์ด้วยเวกเตอร์และเมทริกซ์ซึ่งเป็นอาร์เรย์สี่เหลี่ยมของตัวเลข
ในทางเทคนิคทั้งอวนประสาทและข้อมูลอินพุตสามารถแสดงเป็นเมทริกซ์และการดำเนินการสุทธิมาตรฐานทั้งหมดสามารถกำหนดใหม่เป็นการดำเนินการเมทริกซ์ได้ นี่เป็นสิ่งสำคัญเนื่องจากคอมพิวเตอร์สามารถดำเนินการเมทริกซ์ได้เร็วมาก
เราสามารถประมวลผลค่าเมทริกซ์หลายค่าควบคู่กันได้และถ้าเราสร้างโครงข่ายประสาทด้วยโครงสร้างพื้นฐานนี้เราสามารถใช้เครื่องเดียวกับ GPU เพื่อฝึกอวนขนาดใหญ่ในช่วงเวลาที่เหมาะสม
อย่างไรก็ตามหากเราใช้ Theano เราต้องสร้างตาข่ายลึกขึ้นจากพื้น ไลบรารีไม่ได้จัดเตรียมฟังก์ชันการทำงานที่สมบูรณ์สำหรับการสร้าง deep net ประเภทเฉพาะ
แต่เราต้องเขียนโค้ดทุกแง่มุมของตาข่ายลึกเช่นแบบจำลองเลเยอร์การเปิดใช้งานวิธีการฝึกอบรมและวิธีการพิเศษใด ๆ เพื่อหยุดการติดตั้งมากเกินไป
อย่างไรก็ตามข่าวดีก็คือ Theano ช่วยให้การสร้างการใช้งานของเราเหนือฟังก์ชัน vectorized ซึ่งทำให้เราได้รับโซลูชันที่เหมาะสมที่สุด
มีห้องสมุดอื่น ๆ อีกมากมายที่ขยายการทำงานของ Theano TensorFlow และ Keras สามารถใช้กับ Theano เป็นแบ็กเอนด์ได้
การเรียนรู้เชิงลึกด้วย TensorFlow
Googles TensorFlow คือไลบรารี python ห้องสมุดนี้เป็นตัวเลือกที่ยอดเยี่ยมสำหรับการสร้างแอปพลิเคชันการเรียนรู้เชิงลึกในเชิงพาณิชย์
TensorFlow ขยายออกมาจากห้องสมุด DistBelief V2 ซึ่งเป็นส่วนหนึ่งของ Google Brain Project ไลบรารีนี้มีวัตถุประสงค์เพื่อขยายความสามารถในการพกพาของแมชชีนเลิร์นนิงเพื่อให้โมเดลการวิจัยสามารถนำไปใช้กับแอปพลิเคชันระดับเชิงพาณิชย์
เช่นเดียวกับไลบรารี Theano TensorFlow จะขึ้นอยู่กับกราฟการคำนวณที่โหนดแสดงถึงข้อมูลถาวรหรือการดำเนินการทางคณิตศาสตร์และขอบแสดงถึงการไหลของข้อมูลระหว่างโหนดซึ่งเป็นอาร์เรย์หรือเทนเซอร์หลายมิติ ดังนั้นชื่อ TensorFlow
เอาต์พุตจากการดำเนินการหรือชุดของการดำเนินการจะถูกป้อนเป็นอินพุตในรายการถัดไป
แม้ว่า TensorFlow ได้รับการออกแบบมาสำหรับเครือข่ายประสาทเทียม แต่ก็ทำงานได้ดีกับอวนอื่นที่สามารถจำลองการคำนวณเป็นกราฟการไหลของข้อมูลได้
TensorFlow ยังใช้คุณสมบัติหลายอย่างจาก Theano เช่นการกำจัดนิพจน์ทั่วไปและย่อยการแยกความแตกต่างอัตโนมัติตัวแปรที่ใช้ร่วมกันและสัญลักษณ์
สามารถสร้างอวนลึกประเภทต่างๆได้โดยใช้ TensorFlow เช่นอวนแบบ Convolutional, โปรแกรมเข้ารหัสอัตโนมัติ, RNTN, RNN, RBM, DBM / MLP เป็นต้น
อย่างไรก็ตามไม่มีการสนับสนุนสำหรับการกำหนดค่าพารามิเตอร์ไฮเปอร์ใน TensorFlow สำหรับฟังก์ชันนี้เราสามารถใช้ Keras
การเรียนรู้เชิงลึกและ Keras
Keras เป็นไลบรารี Python ที่ใช้งานง่ายอันทรงพลังสำหรับการพัฒนาและประเมินโมเดลการเรียนรู้เชิงลึก
มันมีการออกแบบที่เรียบง่ายที่ช่วยให้เราสร้างตาข่ายทีละชั้น ฝึกมันและเรียกใช้
มันรวมไลบรารีการคำนวณเชิงตัวเลขที่มีประสิทธิภาพ Theano และ TensorFlow และช่วยให้เราสามารถกำหนดและฝึกโมเดลเครือข่ายประสาทเทียมในโค้ดสั้น ๆ ไม่กี่บรรทัด
เป็น API เครือข่ายประสาทเทียมระดับสูงช่วยให้ใช้ประโยชน์จากการเรียนรู้เชิงลึกและปัญญาประดิษฐ์ได้อย่างกว้างขวาง มันทำงานบนไลบรารีระดับล่างจำนวนมากรวมถึง TensorFlow, Theano และอื่น ๆ รหัส Keras เป็นแบบพกพา เราสามารถใช้เครือข่ายประสาทเทียมใน Keras โดยใช้ Theano หรือ TensorFlow ได้เมื่อสิ้นสุดการทำงานโดยไม่มีการเปลี่ยนแปลงใด ๆ ในโค้ด
ในการนำ Deep learning ไปใช้งานนี้วัตถุประสงค์ของเราคือการคาดการณ์การขัดสีของลูกค้าหรือการเปลี่ยนข้อมูลของธนาคารบางแห่งซึ่งลูกค้ามีแนวโน้มที่จะออกจากบริการของธนาคารนี้ ชุดข้อมูลที่ใช้มีขนาดค่อนข้างเล็กและมี 10,000 แถว 14 คอลัมน์ เรากำลังใช้การแจกจ่าย Anaconda และเฟรมเวิร์กเช่น Theano, TensorFlow และ Keras Keras ถูกสร้างขึ้นบน Tensorflow และ Theano ซึ่งทำหน้าที่เป็นแบ็กเอนด์
# Artificial Neural Network
# Installing Theano
pip install --upgrade theano
# Installing Tensorflow
pip install –upgrade tensorflow
# Installing Keras
pip install --upgrade keras
ขั้นตอนที่ 1: การประมวลผลข้อมูลล่วงหน้า
In[]:
# Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Importing the database
dataset = pd.read_csv('Churn_Modelling.csv')
ขั้นตอนที่ 2
เราสร้างเมทริกซ์ของคุณลักษณะของชุดข้อมูลและตัวแปรเป้าหมายซึ่งก็คือคอลัมน์ 14 ที่มีข้อความว่า“ ออกแล้ว”
ข้อมูลเบื้องต้นมีดังที่แสดงด้านล่าง -
In[]:
X = dataset.iloc[:, 3:13].values
Y = dataset.iloc[:, 13].values
X
เอาต์พุต
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/step_output.jpg)
ขั้นตอนที่ 3
Y
เอาต์พุต
array([1, 0, 1, ..., 1, 1, 0], dtype = int64)
ขั้นตอนที่ 4
เราทำให้การวิเคราะห์ง่ายขึ้นโดยการเข้ารหัสตัวแปรสตริง เรากำลังใช้ฟังก์ชัน ScikitLearn 'LabelEncoder' เพื่อเข้ารหัสป้ายกำกับต่างๆในคอลัมน์โดยอัตโนมัติโดยมีค่าระหว่าง 0 ถึง n_classes-1
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X_1 = LabelEncoder()
X[:,1] = labelencoder_X_1.fit_transform(X[:,1])
labelencoder_X_2 = LabelEncoder()
X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2])
X
เอาต์พุต
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/step4_output.jpg)
ในผลลัพธ์ข้างต้นชื่อประเทศจะถูกแทนที่ด้วย 0, 1 และ 2; ในขณะที่ชายและหญิงถูกแทนที่ด้วย 0 และ 1
ขั้นตอนที่ 5
Labelling Encoded Data
เราใช้เหมือนกัน ScikitLearn ไลบรารีและฟังก์ชันอื่นที่เรียกว่า OneHotEncoder เพียงแค่ส่งหมายเลขคอลัมน์เพื่อสร้างตัวแปรจำลอง
onehotencoder = OneHotEncoder(categorical features = [1])
X = onehotencoder.fit_transform(X).toarray()
X = X[:, 1:]
X
ตอนนี้ 2 คอลัมน์แรกแสดงถึงประเทศและคอลัมน์ที่ 4 แสดงถึงเพศ
เอาต์พุต
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/step5_output.jpg)
เราแบ่งข้อมูลของเราออกเป็นส่วนการฝึกอบรมและการทดสอบเสมอ เราฝึกโมเดลของเราเกี่ยวกับข้อมูลการฝึกอบรมจากนั้นเราจะตรวจสอบความถูกต้องของแบบจำลองเกี่ยวกับข้อมูลการทดสอบซึ่งช่วยในการประเมินประสิทธิภาพของแบบจำลอง
ขั้นตอนที่ 6
เรากำลังใช้ ScikitLearn train_test_splitฟังก์ชั่นแยกข้อมูลของเราออกเป็นชุดฝึกและชุดทดสอบ เราให้อัตราส่วนการแยกรถไฟต่อการทดสอบเป็น 80:20
#Splitting the dataset into the Training set and the Test Set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)
ตัวแปรบางตัวมีค่าเป็นพันในขณะที่ตัวแปรบางตัวมีค่าเป็นหลักหมื่น เราปรับขนาดข้อมูลเพื่อให้เป็นตัวแทนมากขึ้น
ขั้นตอนที่ 7
ในรหัสนี้เรากำลังปรับและเปลี่ยนข้อมูลการฝึกอบรมโดยใช้ StandardScalerฟังก์ชัน เราปรับมาตราส่วนของเราให้เป็นมาตรฐานเพื่อให้เราใช้วิธีการติดตั้งแบบเดียวกันในการแปลง / ปรับขนาดข้อมูลการทดสอบ
# Feature Scaling
fromsklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
เอาต์พุต
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/step7_output.jpg)
ขณะนี้ข้อมูลได้รับการปรับขนาดอย่างเหมาะสมแล้ว ในที่สุดเราก็ดำเนินการกับข้อมูลก่อนการประมวลผล ตอนนี้เราจะเริ่มต้นด้วยโมเดลของเรา
ขั้นตอนที่ 8
เรานำเข้าโมดูลที่จำเป็นที่นี่ เราต้องการโมดูลลำดับสำหรับการเริ่มต้นเครือข่ายประสาทเทียมและโมดูลหนาแน่นเพื่อเพิ่มเลเยอร์ที่ซ่อนอยู่
# Importing the Keras libraries and packages
import keras
from keras.models import Sequential
from keras.layers import Dense
ขั้นตอนที่ 9
เราจะตั้งชื่อรุ่นว่า Classifier เนื่องจากจุดมุ่งหมายของเราคือการจัดประเภทการปั่นของลูกค้า จากนั้นเราใช้โมดูลลำดับสำหรับการเริ่มต้น
#Initializing Neural Network
classifier = Sequential()
ขั้นตอนที่ 10
เราเพิ่มเลเยอร์ที่ซ่อนไว้ทีละชั้นโดยใช้ฟังก์ชันหนาแน่น ในโค้ดด้านล่างนี้เราจะเห็นอาร์กิวเมนต์มากมาย
พารามิเตอร์แรกของเราคือ output_dim. เป็นจำนวนโหนดที่เราเพิ่มในเลเยอร์นี้initคือการเริ่มต้นของ Stochastic Gradient Decent ใน Neural Network เรากำหนดน้ำหนักให้กับแต่ละโหนด ในการเริ่มต้นน้ำหนักควรอยู่ใกล้ศูนย์และเราสุ่มเริ่มต้นน้ำหนักโดยใช้ฟังก์ชันเครื่องแบบ input_dimจำเป็นต้องใช้พารามิเตอร์สำหรับเลเยอร์แรกเท่านั้นเนื่องจากโมเดลไม่ทราบจำนวนตัวแปรอินพุตของเรา จำนวนตัวแปรอินพุตทั้งหมดคือ 11 ในชั้นที่สองโมเดลจะรู้จำนวนตัวแปรอินพุตจากเลเยอร์แรกที่ซ่อนอยู่โดยอัตโนมัติ
ดำเนินการบรรทัดโค้ดต่อไปนี้เพื่อเพิ่มเลเยอร์อินพุตและเลเยอร์แรกที่ซ่อนอยู่ -
classifier.add(Dense(units = 6, kernel_initializer = 'uniform',
activation = 'relu', input_dim = 11))
ดำเนินการตามบรรทัดของโค้ดต่อไปนี้เพื่อเพิ่มเลเยอร์ที่ซ่อนอยู่ที่สอง -
classifier.add(Dense(units = 6, kernel_initializer = 'uniform',
activation = 'relu'))
ดำเนินการตามบรรทัดของโค้ดต่อไปนี้เพื่อเพิ่มเลเยอร์เอาต์พุต -
classifier.add(Dense(units = 1, kernel_initializer = 'uniform',
activation = 'sigmoid'))
ขั้นตอนที่ 11
Compiling the ANN
เราได้เพิ่มหลายชั้นในตัวจำแนกของเราจนถึงขณะนี้ ตอนนี้เราจะรวบรวมโดยใช้ไฟล์compileวิธี. อาร์กิวเมนต์ที่เพิ่มเข้ามาในการควบคุมการคอมไพล์ขั้นสุดท้ายทำให้เครือข่ายประสาทสมบูรณ์ดังนั้นเราต้องระมัดระวังในขั้นตอนนี้
นี่คือคำอธิบายสั้น ๆ เกี่ยวกับข้อโต้แย้ง
อาร์กิวเมนต์แรกคือ Optimizerนี่คืออัลกอริทึมที่ใช้เพื่อค้นหาชุดน้ำหนักที่เหมาะสมที่สุด อัลกอริทึมนี้เรียกว่าStochastic Gradient Descent (SGD). เรากำลังใช้หนึ่งในหลายประเภทที่เรียกว่า 'Adam Optimizer' SGD ขึ้นอยู่กับการสูญเสียดังนั้นพารามิเตอร์ที่สองของเราคือการสูญเสีย หากตัวแปรตามของเราเป็นไบนารีเราจะใช้ฟังก์ชันการสูญเสียลอการิทึมที่เรียกว่า‘binary_crossentropy’และถ้าตัวแปรตามของเรามีเอาต์พุตมากกว่าสองประเภทเราก็จะใช้ ‘categorical_crossentropy’. เราต้องการปรับปรุงประสิทธิภาพของโครงข่ายประสาทเทียมของเราตามaccuracyดังนั้นเราจึงเพิ่ม metrics เป็นความถูกต้อง
# Compiling Neural Network
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
ขั้นตอนที่ 12
ต้องมีการเรียกใช้รหัสจำนวนหนึ่งในขั้นตอนนี้
ติดตั้ง ANN เข้ากับชุดฝึก
ตอนนี้เราฝึกโมเดลของเราเกี่ยวกับข้อมูลการฝึกอบรม เราใช้ไฟล์fitวิธีการที่เหมาะสมกับรูปแบบของเรา นอกจากนี้เรายังปรับน้ำหนักให้เหมาะสมเพื่อปรับปรุงประสิทธิภาพของโมเดล สำหรับสิ่งนี้เราต้องอัปเดตน้ำหนักBatch size คือจำนวนการสังเกตหลังจากที่เราอัปเดตน้ำหนัก Epochคือจำนวนการทำซ้ำทั้งหมด ค่าของขนาดแบทช์และยุคถูกเลือกโดยวิธีการลองผิดลองถูก
classifier.fit(X_train, y_train, batch_size = 10, epochs = 50)
การคาดการณ์และการประเมินแบบจำลอง
# Predicting the Test set results
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)
คาดการณ์ข้อสังเกตใหม่เดียว
# Predicting a single new observation
"""Our goal is to predict if the customer with the following data will leave the bank:
Geography: Spain
Credit Score: 500
Gender: Female
Age: 40
Tenure: 3
Balance: 50000
Number of Products: 2
Has Credit Card: Yes
Is Active Member: Yes
ขั้นตอนที่ 13
Predicting the test set result
ผลการทำนายจะทำให้คุณมีความเป็นไปได้ที่ลูกค้าจะออกจาก บริษัท เราจะแปลงความน่าจะเป็นนั้นเป็นเลขฐานสอง 0 และ 1
# Predicting the Test set results
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)
new_prediction = classifier.predict(sc.transform
(np.array([[0.0, 0, 500, 1, 40, 3, 50000, 2, 1, 1, 40000]])))
new_prediction = (new_prediction > 0.5)
ขั้นตอนที่ 14
นี่เป็นขั้นตอนสุดท้ายที่เราประเมินประสิทธิภาพแบบจำลองของเรา เรามีผลลัพธ์ดั้งเดิมอยู่แล้วดังนั้นเราจึงสามารถสร้างเมทริกซ์ความสับสนเพื่อตรวจสอบความถูกต้องของแบบจำลองของเรา
Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
print (cm)
เอาต์พุต
loss: 0.3384 acc: 0.8605
[ [1541 54]
[230 175] ]
จากเมทริกซ์ความสับสนความแม่นยำของแบบจำลองของเราสามารถคำนวณได้ดังนี้ -
Accuracy = 1541+175/2000=0.858
We achieved 85.8% accuracy, สิ่งไหนดี.
อัลกอริทึมการเผยแพร่ไปข้างหน้า
ในส่วนนี้เราจะเรียนรู้วิธีการเขียนโค้ดเพื่อทำการขยายพันธุ์ไปข้างหน้า (การคาดคะเน) สำหรับโครงข่ายประสาทเทียมอย่างง่าย -
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/forward_propagation_algorithm.jpg)
จุดข้อมูลแต่ละจุดคือลูกค้า ข้อมูลแรกคือจำนวนบัญชีที่พวกเขามีและข้อมูลที่สองคือจำนวนเด็กที่พวกเขามี แบบจำลองจะทำนายจำนวนธุรกรรมที่ผู้ใช้ทำในปีถัดไป
ข้อมูลอินพุตถูกโหลดไว้ล่วงหน้าเป็นข้อมูลอินพุตและน้ำหนักจะอยู่ในพจนานุกรมที่เรียกว่าน้ำหนัก อาร์เรย์ของน้ำหนักสำหรับโหนดแรกในเลเยอร์ที่ซ่อนอยู่ในน้ำหนัก ['node_0'] และสำหรับโหนดที่สองในเลเยอร์ที่ซ่อนอยู่ในน้ำหนัก ['node_1'] ตามลำดับ
น้ำหนักที่ป้อนเข้าไปในโหนดเอาต์พุตมีให้เลือกเป็นน้ำหนัก
ฟังก์ชันการเปิดใช้งานเชิงเส้นที่แก้ไขแล้ว
"ฟังก์ชันการเปิดใช้งาน" คือฟังก์ชันที่ทำงานในแต่ละโหนด มันแปลงอินพุตของโหนดเป็นเอาต์พุตบางส่วน
ฟังก์ชันการเปิดใช้งานเชิงเส้นที่แก้ไขแล้ว (เรียกว่าReLU ) ใช้กันอย่างแพร่หลายในเครือข่ายที่มีประสิทธิภาพสูงมาก ฟังก์ชั่นนี้รับตัวเลขเดียวเป็นอินพุตส่งกลับ 0 หากอินพุตเป็นลบและอินพุตเป็นเอาต์พุตหากอินพุตเป็นบวก
นี่คือตัวอย่างบางส่วน -
- relu (4) = 4
- relu (-2) = 0
เรากรอกนิยามของฟังก์ชัน relu () −
- เราใช้ฟังก์ชัน max () เพื่อคำนวณค่าของผลลัพธ์ของ relu ()
- เราใช้ฟังก์ชัน relu () กับ node_0_input เพื่อคำนวณ node_0_output
- เราใช้ฟังก์ชัน relu () กับ node_1_input เพื่อคำนวณ node_1_output
import numpy as np
input_data = np.array([-1, 2])
weights = {
'node_0': np.array([3, 3]),
'node_1': np.array([1, 5]),
'output': np.array([2, -1])
}
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = np.tanh(node_0_input)
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = np.tanh(node_1_input)
hidden_layer_output = np.array(node_0_output, node_1_output)
output =(hidden_layer_output * weights['output']).sum()
print(output)
def relu(input):
'''Define your relu activation function here'''
# Calculate the value for the output of the relu function: output
output = max(input,0)
# Return the value just calculated
return(output)
# Calculate node 0 value: node_0_output
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = relu(node_0_input)
# Calculate node 1 value: node_1_output
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = relu(node_1_input)
# Put node values into array: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])
# Calculate model output (do not apply relu)
odel_output = (hidden_layer_outputs * weights['output']).sum()
print(model_output)# Print model output
เอาต์พุต
0.9950547536867305
-3
การนำเครือข่ายไปใช้กับการสังเกตการณ์ / แถวข้อมูลจำนวนมาก
ในส่วนนี้เราจะเรียนรู้วิธีการกำหนดฟังก์ชันที่เรียกว่า Predict_with_network () ฟังก์ชั่นนี้จะสร้างการคาดการณ์สำหรับการสังเกตข้อมูลหลายรายการโดยนำมาจากเครือข่ายด้านบนที่นำมาเป็น input_data กำลังใช้น้ำหนักที่ระบุในเครือข่ายด้านบน นอกจากนี้ยังมีการใช้นิยามฟังก์ชัน relu ()
ให้เรากำหนดฟังก์ชันที่เรียกว่า Predict_with_network () ที่ยอมรับสองอาร์กิวเมนต์ - input_data_row และ weights - และส่งคืนการคาดการณ์จากเครือข่ายเป็นผลลัพธ์
เราคำนวณค่าอินพุตและเอาต์พุตสำหรับแต่ละโหนดโดยจัดเก็บเป็น: node_0_input, node_0_output, node_1_input และ node_1_output
ในการคำนวณค่าอินพุตของโหนดเราจะคูณอาร์เรย์ที่เกี่ยวข้องเข้าด้วยกันและคำนวณผลรวม
ในการคำนวณค่าเอาต์พุตของโหนดเราใช้ฟังก์ชัน relu () กับค่าอินพุตของโหนด เราใช้ 'for loop' เพื่อวนซ้ำใน input_data -
นอกจากนี้เรายังใช้ Predict_with_network () เพื่อสร้างการคาดคะเนสำหรับแต่ละแถวของ input_data - input_data_row เรายังผนวกการคาดการณ์แต่ละรายการเข้ากับผลลัพธ์
# Define predict_with_network()
def predict_with_network(input_data_row, weights):
# Calculate node 0 value
node_0_input = (input_data_row * weights['node_0']).sum()
node_0_output = relu(node_0_input)
# Calculate node 1 value
node_1_input = (input_data_row * weights['node_1']).sum()
node_1_output = relu(node_1_input)
# Put node values into array: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])
# Calculate model output
input_to_final_layer = (hidden_layer_outputs*weights['output']).sum()
model_output = relu(input_to_final_layer)
# Return model output
return(model_output)
# Create empty list to store prediction results
results = []
for input_data_row in input_data:
# Append prediction to results
results.append(predict_with_network(input_data_row, weights))
print(results)# Print results
เอาต์พุต
[0, 12]
ที่นี่เราได้ใช้ฟังก์ชัน relu โดยที่ relu (26) = 26 และ relu (-13) = 0 เป็นต้น
โครงข่ายประสาทเทียมหลายชั้นลึก
ที่นี่เรากำลังเขียนโค้ดเพื่อทำการขยายไปข้างหน้าสำหรับโครงข่ายประสาทเทียมที่มีเลเยอร์ซ่อนอยู่สองชั้น แต่ละเลเยอร์ที่ซ่อนอยู่มีสองโหนด ข้อมูลอินพุตถูกโหลดไว้ล่วงหน้าเป็นinput_data. โหนดในเลเยอร์ที่ซ่อนแรกเรียกว่า node_0_0 และ node_0_1
น้ำหนักของพวกเขาถูกโหลดไว้ล่วงหน้าเป็นน้ำหนัก ['node_0_0'] และน้ำหนัก ['node_0_1'] ตามลำดับ
เรียกโหนดในเลเยอร์ที่ซ่อนอยู่ที่สอง node_1_0 and node_1_1. น้ำหนักของพวกเขาถูกโหลดไว้ล่วงหน้าเป็นweights['node_1_0'] และ weights['node_1_1'] ตามลำดับ
จากนั้นเราสร้างเอาต์พุตแบบจำลองจากโหนดที่ซ่อนอยู่โดยใช้น้ำหนักที่โหลดไว้ล่วงหน้าเป็น weights['output'].
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/deep_multi_layer.jpg)
เราคำนวณ node_0_0_input โดยใช้น้ำหนักของมัน ['node_0_0'] และ input_data ที่กำหนด จากนั้นใช้ฟังก์ชัน relu () เพื่อรับ node_0_0_output
เราทำเช่นเดียวกับด้านบนสำหรับ node_0_1_input เพื่อรับ node_0_1_output
เราคำนวณ node_1_0_input โดยใช้น้ำหนักของมัน ['node_1_0'] และผลลัพธ์จากเลเยอร์ที่ซ่อนแรก - hidden_0_outputs จากนั้นเราใช้ฟังก์ชัน relu () เพื่อรับ node_1_0_output
เราทำเช่นเดียวกับข้างต้นสำหรับ node_1_1_input เพื่อรับ node_1_1_output
เราคำนวณ model_output โดยใช้น้ำหนัก ['output'] และเอาต์พุตจากอาร์เรย์ hidden_1_outputs ชั้นที่สองที่ซ่อนอยู่ เราไม่ใช้ฟังก์ชัน relu () กับผลลัพธ์นี้
![](https://post.nghiatu.com/assets/tutorial/python_deep_learning/images/multi_hidden_layer.jpg)
import numpy as np
input_data = np.array([3, 5])
weights = {
'node_0_0': np.array([2, 4]),
'node_0_1': np.array([4, -5]),
'node_1_0': np.array([-1, 1]),
'node_1_1': np.array([2, 2]),
'output': np.array([2, 7])
}
def predict_with_network(input_data):
# Calculate node 0 in the first hidden layer
node_0_0_input = (input_data * weights['node_0_0']).sum()
node_0_0_output = relu(node_0_0_input)
# Calculate node 1 in the first hidden layer
node_0_1_input = (input_data*weights['node_0_1']).sum()
node_0_1_output = relu(node_0_1_input)
# Put node values into array: hidden_0_outputs
hidden_0_outputs = np.array([node_0_0_output, node_0_1_output])
# Calculate node 0 in the second hidden layer
node_1_0_input = (hidden_0_outputs*weights['node_1_0']).sum()
node_1_0_output = relu(node_1_0_input)
# Calculate node 1 in the second hidden layer
node_1_1_input = (hidden_0_outputs*weights['node_1_1']).sum()
node_1_1_output = relu(node_1_1_input)
# Put node values into array: hidden_1_outputs
hidden_1_outputs = np.array([node_1_0_output, node_1_1_output])
# Calculate model output: model_output
model_output = (hidden_1_outputs*weights['output']).sum()
# Return model_output
return(model_output)
output = predict_with_network(input_data)
print(output)
เอาต์พุต
364