โมเดลประสาทเทียม Feedforward Neural Network (FNN)

Feedforward Neural Network เป็นโมเดลประสาทเทียม (neural network) แบบหนึ่งที่มีโครงสร้างประกอบด้วยเลเยอร์ (layer) ของโหนด (node) ที่เชื่อมต่อกันเป็นลำดับ โดยข้อมูลจะถูกส่งผ่านจากลำดับแรกไปยังลำดับถัดไป จนกระทั่งถึงลำดับสุดท้ายที่จะให้ผลลัพธ์ออกมา โมเดลนี้เรียกว่า Feedforward Neural Network เพราะข้อมูลจะถูกส่งไปตามทิศทางเดียว ไม่มีการวนกลับมาตรวจสอบผลลัพธ์เดิมเหมือนกับโมเดลประสาทเทียม (neural network) แบบอื่น ๆ เช่น Recurrent Neural Network หรือ Convolutional Neural Network ซึ่งแต่ละแบบมีลักษณะและการใช้งานที่แตกต่างกันไป โมเดลแบบ Feedforward Neural Network มักนิยมใช้ในการแก้ไขปัญหาที่เป็นปัญหาการจำแนกหรือคาดการณ์ เช่น การจำแนกออกเป็นกลุ่มของข้อมูลต่าง ๆ หรือการคาดการณ์ค่าของตัวแปรต่าง ๆ ด้วยข้อมูลที่มีอยู่ในชุดข้อมูลที่ใช้สร้างโมเดล โดยการเรียนรู้โมเดลจะได้รับการจัดเตรียมด้วยการเรียนรู้จากชุดข้อมูลการฝึก และจะถูกนำไปใช้งานกับชุดข้อมูลที่มีอยู่จริงเพื่อให้ได้ผลลัพธ์ที่แม่นยำและสามารถนำไปใช้งานได้จริงในชีวิตจริง

Feedforward Neural Network เป็นโมเดลประสาทเทียมที่มีการส่งข้อมูลผ่านชั้นของโนด (neurons) จากแหล่งข้อมูล (input) ผ่านชั้นของโนดจนถึงเป้าหมายหรือผลลัพธ์ (output) โดยไม่มีการต่อ Feedback Loop กลับมายังขั้นตอนก่อนหน้านั้นเอง ซึ่งทำให้ Feedforward Neural Network เป็นแบบโมเดลที่ไม่มีการเรียนรู้แบบ supervised จากผลลัพธ์ของการทำนาย (output) ที่ได้กลับมา

Feedforward Neural Network ประกอบด้วยชั้นของโนด (neurons) ที่เรียงต่อกันเป็นชั้น โดยแต่ละโนดในแต่ละชั้นจะเชื่อมต่อกับโนดในชั้นถัดไป โดยจะมีการกำหนดค่าน้ำหนัก (weight) และค่า bias ในการคำนวณผลลัพธ์ของแต่ละโนดในชั้นถัดไป

Feedforward Neural Network มักถูกนำมาใช้ในงานที่เกี่ยวข้องกับการจำแนกและทำนายข้อมูล เช่น การจำแนกอักษรหรือเลขหมายเลขบัตรเครดิต การทำนายราคาหุ้นหรืออสังหาริมทรัพย์ และอื่นๆ โดยใช้ข้อมูล input ที่เป็น vector ที่มีคุณสมบัติหรือลักษณะเฉพาะที่เป็นตัวบอกสภาพปัจจุบันของข้อมูล และใช้โมเดล Feedforward Neural Network ในการประมวลผลข้อมูลเพื่อสร้างผลลัพธ์ที่ถูกต้องในการทำนายหรือการจำแนกข้อมูล

Feedforward Neural Network เป็นโมเดลประเภทหนึ่งของ Neural Network ที่มีการเชื่อมต่อกันของโหนด (nodes) หรือเรียกอีกชื่อว่าเซลล์ประสาท (neurons) ตามลำดับเพื่อให้ข้อมูลสามารถไหลผ่านไปยังชั้นถัดไปของโมเดลได้ โดยไม่มีการกลับไปย้อนหลัง (no feedback) กล่าวคือการคำนวณในทุกๆ ชั้นจะไม่ถูกผลิตขึ้นมาจากการคำนวณในชั้นก่อนหน้า ดังนั้นชื่อ Feedforward Neural Network นั้นมาจากการที่ข้อมูลไหลเข้าไปในโมเดลเรียงลำดับ (feed forward) จากชั้นนึงไปยังอีกชั้นหนึ่งไปเรื่อยๆ จนไปถึงชั้นสุดท้ายที่เป็น output layer

Feedforward Neural Network จะมีทั้งหมด 3 ชั้น ด้วยกัน ได้แก่

Input Layer :
เป็นชั้นแรกของโมเดลที่รับข้อมูลเข้ามา ซึ่งจะประกอบด้วยโหนดหลายๆ โหนดที่แตกต่างกันตามจำนวนข้อมูลเข้าแต่ละช่อง Input Layer ของ Feedforward Neural Network คือชั้นแรกของโมเดลที่รับข้อมูลเข้ามา โดยมีจำนวนโหนด (nodes) จำกัดตามจำนวนคุณสมบัติ (features) ของข้อมูลที่ต้องการจะใช้ในการประมวลผล เช่น หากต้องการจะใช้ภาพขนาด 28×28 เป็นข้อมูลเข้า ก็จะมีจำนวนโหนดใน Input Layer เท่ากับ 784 (28×28) โดยแต่ละโหนดจะรับค่าพิกเซล (pixel) จากภาพ 1 พิกเซลต่อ 1 โหนด และค่าข้อมูลที่รับเข้ามาจะถูกปรับค่าให้อยู่ในช่วงที่สอดคล้องกับการทำงานของโมเดล ใน Input Layer จะไม่มีการทำนายผล (prediction) และไม่มีการเรียนรู้เช่นเดียวกับ Hidden Layer และ Output Layer ใน Feedforward Neural Network ซึ่งในการที่ Input Layer เป็นชั้นแรกของ Feedforward Neural Network นั้นจะรับข้อมูลเข้ามาใช้ในการทำนายหรือจำแนก (classification) โดยปกติแล้ว Input Layer จะมีจำนวนโหนด (nodes) เท่ากับจำนวนตัวแปรเข้า (input variables) ในข้อมูล เช่น หากมีข้อมูลที่มี 5 ตัวแปรเข้า ก็จะมี Input Layer ที่มีจำนวนโหนดเป็น 5
Hidden Layer :
เป็นชั้นที่ตามมาหลัง Input Layer ซึ่งจะประกอบด้วยโหนดหลายๆ โหนดที่เกี่ยวข้องกับการคำนวณหรือประมวลผลของข้อมูล โดย Hidden Layer ของ Feedforward Neural Network คือชั้นที่ตั้งอยู่ระหว่าง Input Layer และ Output Layer ซึ่งจะมีหลายชั้นก็ได้ แต่ละชั้นจะประกอบด้วยหน่วยคำนวณ (neuron) หลายๆ หน่วย ซึ่งแต่ละหน่วยก็จะทำหน้าที่เป็นตัวแปรในการคำนวณค่า โดย Hidden Layer จะทำหน้าที่คำนวณผลรวมของผลคูณของค่า input กับค่าน้ำหนัก (weight) แล้วนำผลรวมนั้นมาใช้กับฟังก์ชัน activation function เพื่อให้ได้ผลลัพธ์ที่เป็นไปได้ของ output ที่เหมาะสมตามการเรียนรู้ของโมเดล ในการกำหนดจำนวน Hidden Layer ใน Feedforward Neural Network จะขึ้นอยู่กับความซับซ้อนของปัญหาและจำนวนของข้อมูลที่ใช้ในการฝึกโมเดล โดยจะมีวิธีการกำหนดจำนวน Hidden Layer ตามกฎได้แก่ Rule of Thumb, Grid Search, หรือใช้ Cross Validation แล้วดูจำนวน Hidden Layer ที่ให้ผลลัพธ์ที่ดีที่สุด นอกจากนี้ การเลือกประเภทของ activation function ใน Hidden Layer ก็มีความสำคัญอย่างมากเช่นกัน เนื่องจากจะมีผลต่อการเรียนรู้ของโมเดล ซึ่ง activation function ที่ใช้กันอยู่ส่วนใหญ่ใน Hidden Layer ได้แก่ ReLU, Sigmoid, Tanh และ LeakyReLU โดย ReLU ถือว่าเป็น activation function ที่ได้รับความนิยมมากที่สุดในปัจจุบันเนื่องจากมีประสิทธิภาพและคำนวณได้เร็ว และแม้ว่าจะไม่ใช่ activation function ที่เหมาะสมที่สุด สิ่งที่สำคัญ Hidden Layer สามารถมีได้หลายชั้น (multi-layer) ซึ่งจะเพิ่มความซับซ้อนและความยากในการเรียนรู้ของโมเดล ซึ่งจะมีการเรียนรู้เกิดขึ้นในแต่ละเลเยอร์แยกต่างหาก ดังนั้นถ้าเราต้องการโมเดลที่ซับซ้อนมากๆ เราสามารถเพิ่มจำนวนชั้นและจำนวนเลเยอร์ในแต่ละชั้นได้
Output Layer :
เป็นชั้นสุดท้ายของโมเดลที่แสดงผลลัพธ์ที่ได้จากการคำนวณแล้ว ซึ่งจะประกอบด้วยโหนดเพียงตัวเดียวหรือหลายๆ โหนดขึ้นอยู่กับลักษณะของปัญหา โดย Output Layer ของ Feedforward Neural Network เป็นชั้นสุดท้ายของโมเดลและใช้สำหรับการประมวลผลเอาต์พุตของโมเดล โดยจะมีจำนวนโหนด (neurons) เท่ากับจำนวนคลาสหรือตัวแปรเป้าหมาย (target variable) ในข้อมูล ซึ่งเป็นเลข 1 ถึง K ในกรณีที่มี K คลาส สำหรับงานที่เป็นการจำแนกประเภท (classification) โดยเฉพาะ โมเดลจะใช้ฟังก์ชัน activation ที่เหมาะสมกับประเภทของการจำแนก ซึ่งเป็นฟังก์ชัน softmax สำหรับการจำแนกหลายคลาส (multi-class classification) โดยสามารถแปลงผลลัพธ์จากโหนดในชั้น Output Layer ให้อยู่ในรูปของความน่าจะเป็นของแต่ละคลาส (class probabilities) ที่มีค่ารวมกันเท่ากับ 1 และใช้ค่าความน่าจะเป็นสูงสุดเป็นคำตอบของโมเดล สำหรับงานที่เป็นการทำนาย (prediction) โมเดลจะใช้ฟังก์ชัน activation ที่เหมาะสมกับประเภทของข้อมูลเป้าหมาย เช่น ฟังก์ชัน linear activation สำหรับการทำนายค่าตัวเลข หรือฟังก์ชัน sigmoid สำหรับการทำนายค่า binary ที่มีค่าอยู่ระหว่าง 0 ถึง 1 โหนดใน Output Layer จะใช้ activation function ที่เหมาะสมกับประเภทงานที่ต้องการทำ ยกตัวอย่างเช่น ในงานทำนายค่าตัวเลข (regression) อาจใช้ activation function เช่น linear function หรือ sigmoid function ส่วนในงานที่ต้องการแยกประเภท (classification) อาจใช้ activation function เช่น softmax function หรือ sigmoid function ขึ้นอยู่กับจำนวนคลาสที่ต้องการแยกและลักษณะของข้อมูล

รูปแบบของ Feedforward Neural Network (FFNN) เป็นโครงสร้างของการเชื่อมต่อระหว่างโนด (nodes) หรือประตูตัดสินใจ (decision gates) ต่าง ๆ โดยมีลักษณะเป็นชั้น (layers) ต่อเนื่องกันจากชั้นหน้าสุด (input layer) ไปจนถึงชั้นหลังสุด (output layer) โดยข้อมูลจะถูกส่งผ่านเน็ตเวิร์ก โดยมีการใช้น้ำหนัก (weights) ในการปรับข้อมูลก่อนถูกส่งในโนดต่อไป ยังมีองค์ประกอบอื่นๆ ได้แก่

Activation Function :
ฟังก์ชันที่ใช้ในการปรับค่าออกมาเพื่อให้ได้ผลลัพธ์ที่ต้องการ เช่น ฟังก์ชัน sigmoid, ReLU, tanh, softmax เป็นต้น
Loss Function :
ฟังก์ชันที่ใช้วัดความคลาดเคลื่อนของผลลัพธ์ที่ได้จากโมเดลกับผลลัพธ์จริง ซึ่งจะนำมาใช้ในการปรับค่าน้ำหนัก (weights) ของโมเดล เช่น ฟังก์ชัน mean squared error, cross-entropy เป็นต้น
Optimization Algorithm :
วิธีการปรับค่าน้ำหนักในโมเดล เช่น Gradient Descent, Stochastic Gradient Descent (SGD), Adam, RMSprop เป็นต้น

โมเดลแบบ Feedforward Neural Network เป็นโมเดลประสาทเทียมที่มีการส่งข้อมูลผ่านชั้นของโนด (nodes) หรือเรียกว่าเลเยอร์ (layers) ตามลำดับจากอินพุต (input) ไปยังเอาต์พุต (output) โดยไม่มีการเชื่อมต่อระหว่างโนดในชั้นเดียวกันหรือระหว่างเลเยอร์ เรียกว่า Feedforward เพราะข้อมูลเคลื่อนที่ไปข้างหน้าเท่านั้น

โมเดลแบบ Feedforward Neural Network นั้นมีโครงสร้างหลายรูปแบบ โดยที่รูปแบบพื้นฐานประกอบด้วย 3 ชั้นหลัก ได้แก่ ชั้นอินพุต (input layer) ชั้นซ่อน (hidden layer) และชั้นเอาต์พุต (output layer)

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

การสร้างโมเดลแบบ Feedforward Neural Network ใช้ภาษา Python สามารถทำได้โดยใช้ไลบรารีต่าง ๆ เช่น TensorFlow, Keras, PyTorch, หรือ Scikit-learn ซึ่งแต่ละไลบรารีนั้นจะมีวิธีการสร้างโมเดลแบบ Feedforward Neural Network ที่ต่างกันไปตาม

โมเดลการเรียนรู้เชิงลึกที่เป็นส่วนหนึ่งของ Deep Learning ซึ่งมีโครงสร้างประกอบด้วยชั้นของโนด (nodes) หรือเรียกว่าเลเยอร์ (layers) ซึ่งมีหน้าที่รับข้อมูลเข้ามาที่ชั้นแรกแล้วผ่านการประมวลผลเชิงเส้นตรง (linear transformation) และการสังเคราะห์ (activation function) ก่อนส่งผลลัพธ์ออกมาที่ชั้นถัดไป โดยที่ไม่มีการเชื่อมต่อกลับ (feedback) ระหว่างชั้นต่าง ๆ

โมเดล FFNN นี้สามารถนำมาประยุกต์ใช้กับงานต่าง ๆ เช่น การจำแนกประเภทของภาพ (image classification) หรือการทำนายผลการเลือกตัวเลือก (predicting election outcomes) เป็นต้น โดยใช้การเรียนรู้แบบ Supervised Learning โดยมีการสอนให้โมเดลได้รับตัวอย่างของข้อมูล (training data) ที่มีการแยกแยะเป็นกลุ่มต่าง ๆ และต้องการให้โมเดลสามารถจำแนกหรือทำนายผลได้อย่างแม่นยำในข้อมูลที่ไม่เคยเห็น (unseen data) โดยจะใช้วิธีการปรับค่าน้ำหนัก (weights) และการเรียนรู้จากความผิดพลาด (error) เพื่อปรับปรุงประสิทธิภาพของโมเดลให้ดีขึ้น

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

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

การเรียนรู้ของโมเดล FFNN นั้น มีหลักการหลายแนวทาง เช่นการใช้ Gradient Descent ในการปรับค่าน้ำหนักและค่าไบแอส เพื่อลดค่าความผิดพลาดของโมเดล หรือการใช้ Dropout เพื่อลดโอกาสเกิด Overfitting ในกรณีที่โมเดลมีจำนวนพารามิเตอร์มากเกินไป นอกจากนี้ ยังมีการพัฒนาโมเดลประเภทอื่น ๆ เช่น Convolutional Neural Networks (CNNs) สำหรับงานที่เกี่ยวข้องกับภาพ และ Recurrent Neural Networks (RNNs) สำหรับงานที่เกี่ยวข้องกับชุดข้อมูลแบบลำดับ (sequence data)

Feedforward Neural Network (FFNN) เป็นโมเดลการเรียนรู้เชิงลึกที่ใช้กันอย่างแพร่หลายในงานที่เกี่ยวข้องกับการประมวลผลข้อมูล โดยเฉพาะอย่างยิ่งในงานที่มีการจำแนกประเภท (classification) หรือการทำนาย (prediction) ข้อมูล นอกจากนี้ยังมีงานอื่น ๆ ที่เกี่ยวข้องกับ FFNN ดังนี้

การจำแนกภาพ (Image Classification) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการจำแนกภาพ เช่น การจำแนกว่าภาพเป็นอะไร เช่น รถยนต์หรือไม่ หรือการจำแนกว่าภาพเป็นแมวหรือสุนัข
การจำแนกเสียง (Speech Recognition) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการจำแนกเสียง เช่น การแยกประเภทเสียงหรือการแปลความหมายของเสียง
การจำแนกข้อความ (Text Classification) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการจำแนกข้อความ เช่น การจำแนกว่าเป็นเรื่องราวเกี่ยวกับอะไรหรือการจำแนกว่าเป็นข่าวที่มีข้อความเชิงลบหรือเชิงบวก
การทำนาย (Prediction) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการทำนาย เช่น การทำนายราคาหุ้นหรือการทำนายการเกิดภัยพิบัติธรรมชาติ
การวิเคราะห์ข้อมูล (Data Analysis) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการวิเคราะห์ข้อมูล เช่น การวิเคราะห์ข้อมูลการขายสินค้า
การประมวลผลภาษาธรรมชาติ (Natural Language Processing) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการประมวลผลภาษาธรรมชาติ เช่น การแปลภาษาอัตโนมัติหรือการสร้างและจำแนกคำศัพท์ภาษาธรรมชาติ
การตรวจสอบข้อผิดพลาด (Error Detection) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการตรวจสอบข้อผิดพลาด เช่น การตรวจสอบความถูกต้องของข้อมูลหรือการตรวจสอบการแฝงข้อมูล (Steganography)
การประมวลผลเสียง (Audio Processing) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการประมวลผลเสียง เช่น การแยกเสียงออกจากกันหรือการเปรียบเทียบเสียงที่แตกต่างกัน
การวิเคราะห์ภาพ (Image Analysis) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการวิเคราะห์ภาพ เช่น การค้นหาวัตถุในภาพหรือการสร้างภาพอัตโนมัติ
การพยากรณ์ (Forecasting) – สามารถนำมาใช้ในงานที่เกี่ยวข้องกับการพยากรณ์ เช่น การพยากรณ์การเปลี่ยนแปลงสภาพอากาศหรือการพยากรณ์ความน่าจะเป็นในการเกิดเหตุการณ์ต่าง ๆ

Activation Function ส่วนใหญ่จะใช้ใน Hidden Layer ได้แก่

ReLU (Rectified Linear Unit), Sigmoid, Tanh (Hyperbolic Tangent) และ LeakyReLU (Leaky Rectified Linear Unit) เป็นฟังก์ชัน activation function ที่มักถูกนำมาใช้ใน neural network เพื่อเปิดปิดเซลล์ (neuron) ในแต่ละ layer ของโมเดล neural network

ReLU (Rectified Linear Unit)
คือ ฟังก์ชันที่ใช้ในการแปลงค่า input ของ neuron ให้เป็น output โดยที่หาก input เป็นค่าบวกจะได้ output เท่ากับ input แต่หาก input เป็นค่าลบ จะให้ output เป็น 0 ดังนั้น ReLU จะช่วยในการแยกข้อมูลของคลาสได้ดีขึ้น และมีความเร็วในการคำนวณสูง ฟังก์ชัน ReLU จะรับค่า input และเปลี่ยนค่าที่น้อยกว่าศูนย์เป็นศูนย์ และค่าที่มากกว่าศูนย์ถูกส่งออกไปเป็นค่าเดียว ซึ่งทำให้เป็นฟังก์ชันที่เร็วที่สุดและที่ได้ผลลัพธ์มากที่สุดในการทำงาน

สมการของ ReLU:
f(x) = max(0, x)

Sigmoid
คือ ฟังก์ชันที่ใช้ในการแปลงค่า input ของ neuron ให้เป็น output ที่มีค่าอยู่ระหว่าง 0 ถึง 1 ซึ่งสามารถแปลงค่า input เป็นความน่าจะเป็นของ output ที่เป็นคลาส 2 ได้ ฟังก์ชัน Sigmoid จะรับค่า input และแปลงเป็นค่าระหว่าง 0 ถึง 1 ซึ่งใช้ในการประมวลผลข้อมูลที่ต้องการหาความน่าจะเป็น (probability) ของผลลัพธ์

สมการของ Sigmoid:
f(x) = 1 / (1 + exp(-x))

Tanh (Hyperbolic Tangent)
คือ ฟังก์ชันที่ใช้ในการแปลงค่า input ของ neuron ให้เป็น output ที่มีค่าอยู่ระหว่าง -1 ถึง 1 ซึ่งสามารถแปลงค่า input เป็นความน่าจะเป็นของ output ที่เป็นคลาส 2 ได้ ฟังก์ชัน Tanh จะรับค่า input และแปลงเป็นค่าระหว่าง -1 ถึง 1 ซึ่งใช้ในการประมวลผลข้อมูลที่ต้องการให้ค่า output มีค่าติดลบและบวกได้

สมการของ Tanh:
f(x) = (exp(x) – exp(-x)) / (exp(x) + exp(-x))

LeakyReLU
คือ ฟังก์ชันที่มีคุณสมบัติเหมือนกับ ReLU แต่สามารถรับค่า input ที่เป็นค่าลบได้ โดยใช้ค่า alpha เพื่อกำหนดให้มีค่าเป็นจำนวนเล็กบวกเมื่อ input เป็นค่าลบ LeakyReLU จะคล้ายกับ ReLU แต่จะไม่เป็น 0 ที่ค่า input ติดลบ แต่จะเป็นค่าน้อยที่สุดของ input คูณด้วยค่าที่เรียกว่า slope ซึ่งช่วยให้โมเดลสามารถปรับการเรียนรู้และทำงานได้ดีกว่า ReLU ในบางกรณี

สมการของ LeakyReLU:
f(x) = max(alpha * x, x)

จุดเด่น Feedforward Neural Network ได้แก่

สามารถใช้กับการแก้ไขปัญหาที่ซับซ้อนได้: โมเดล Feedforward Neural Network สามารถใช้กับปัญหาที่มีความซับซ้อนได้มาก เช่น การจำแนกภาพ, การแปลภาษาและการทำนายต่างๆ
การเรียนรู้แบบอัตโนมัติ: โมเดล Feedforward Neural Network สามารถเรียนรู้แบบอัตโนมัติ โดยไม่ต้องใช้การคำนวณค่าความสัมพันธ์ของตัวแปรเอง
การปรับค่าน้ำหนักแบบอัตโนมัติ: โมเดล Feedforward Neural Network สามารถปรับค่าน้ำหนักของโมเดลเองได้อัตโนมัติ โดยใช้วิธีการ Backpropagation
ความสามารถในการประมวลผลข้อมูลแบบพร้อมกัน: โมเดล Feedforward Neural Network สามารถประมวลผลข้อมูลได้พร้อมกันหลายข้อมูลพร้อมกัน ดังนั้นจึงเหมาะสำหรับการประมวลผลแบบที่มีการใช้งานพร้อมกันมากๆ เช่น การจำแนกภาพในแบบ Real-time
ความแม่นยำ: โมเดล Feedforward Neural Network สามารถให้ผลลัพธ์ที่แม่นยำ โดยอาจมีความแม่นยำสูงถึง 99% ในการจำแนกภาพหรือการตรวจสอบสถานะต่างๆ
สามารถประมวลผลข้อมูลที่มีขนาดใหญ่ได้: Feedforward Neural Network สามารถรับข้อมูลที่มีขนาดใหญ่ได้ เนื่องจากแต่ละชั้นของโมเดลสามารถเรียนรู้และแยกแยะลักษณะของข้อมูลอย่างมีประสิทธิภาพ โดยไม่จำเป็นต้องมีการเข้าถึงทุกส่วนของข้อมูลพร้อมกัน
ความสามารถในการเรียนรู้: Feedforward Neural Network มีความสามารถในการเรียนรู้แบบไม่ต้องมีการสอนในกรณีที่มีข้อมูลเป็นจำนวนมาก โดยระบบจะเรียนรู้วิธีการแยกแยะและจำแนกข้อมูลจากตัวอย่างที่มีอยู่ นอกจากนี้ Feedforward Neural Network ยังสามารถปรับปรุงความแม่นยำของการแยกแยะข้อมูลได้โดยการปรับแต่งพารามิเตอร์ของโมเดล
สามารถนำไปใช้กับงานหลากหลาย: Feedforward Neural Network สามารถนำไปใช้กับงานหลากหลายได้ เช่น การจำแนกอินพุทเป็นกลุ่ม, การจำแนกภาพ, การจำแนกเสียงและการจำแนกข้อความ เป็นต้น
การเรียนรู้แบบโดยไม่ต้องมีผู้ควบคุม: Feedforward Neural Network สามารถเรียนรู้แบบไม่ต้องมีผู้ควบคุม (unsupervised learning) ได้ ซึ่งให้ความสามารถในการปรับปรุงการแยกแยะและจำแนกข้อมูลอย่างมีประสิทธิภาพโดยอิสระ

การเขียนโปรแกรมด้วย Python เพื่อใช้งาน Feedforward Neural Network

สามารถทำได้โดยใช้ library ของ Python ที่มีให้ใช้งานอย่างมากมาย เช่น Keras, TensorFlow, PyTorch เป็นต้น โดยทั่วไปแล้วกระบวนการการเขียนโค้ดแบ่งออกเป็น 3 ขั้นตอนหลัก ได้แก่

การเตรียมข้อมูล (Data Preparation):
เป็นขั้นตอนที่ใช้ในการนำเข้าและเตรียมข้อมูลสำหรับใช้งานในโมเดล Feedforward Neural Network โดยอาจจะมีการทำ Scaling, Normalization, One-hot encoding หรือการแปลงข้อมูลเป็นรูปแบบที่เหมาะสมกับการนำเข้าของโมเดล เช่นการแปลงข้อมูลภาพให้เป็นรูปแบบ Matrix
การสร้างโมเดล (Model Creation):
เป็นขั้นตอนที่ใช้ในการสร้างโมเดล Feedforward Neural Network โดยปกติแล้วจะมีการกำหนดค่า Hyperparameters เช่น จำนวน Layer, จำนวน Node ในแต่ละ Layer, การกำหนด Activation function และการกำหนด Loss function เป็นต้น
การทดสอบและปรับปรุง (Testing and Tuning):
เป็นขั้นตอนที่ใช้ในการทดสอบและปรับปรุงโมเดล Feedforward Neural Network โดยจะมีการแบ่งข้อมูลเป็น Training set, Validation set, Test set เพื่อใช้ในการทดสอบและปรับ Hyperparameters ของโมเดลให้ดียิ่งขึ้น โดยจะใช้เทคนิคต่าง ๆ เช่น Cross-validation, Early stopping เป็นต้น

ตัวอย่าง การสร้างและใช้งาน Feedforward Neural Network ด้วย Python โดยใช้ Keras และ TensorFlow 2

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# สร้างโมเดล Feedforward Neural Network
model = keras.Sequential(
    [
        layers.Dense(64, activation="relu", input_shape=(784,)),
        layers.Dense(10, activation="softmax"),
    ]
)

# คอมไพล์โมเดล
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])

# โหลดข้อมูล
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# ปรับปรุงข้อมูล
x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

# ฝึกโมเดล
history = model.fit(x_train, y_train, batch_size=32, epochs=5, validation_split=0.2)

# ประเมินประสิทธิภาพ
test_scores = model.evaluate(x_test, y_test, verbose=2)
print("Test loss:", test_scores[0])
print("Test accuracy:", test_scores[1])

จากตัวอย่าง ได้สร้างโมเดล Feedforward Neural Network ที่ประกอบด้วย 2 ชั้น (หรือ Layer) โดยมี 64 โหนดในชั้นแรกและ 10 โหนดในชั้นสุดท้าย โดยใช้ activation function คือ ReLU ในชั้นแรกและ softmax ในชั้นสุดท้าย (สำหรับการจำแนกหลายคลาส) และใช้ categorical crossentropy เป็น loss function และ Adam optimizer ในการคอมไพล์โมเดล ในตัวอย่างนี้เราใช้ชุดข้อมูล MNIST ที่ประกอบด้วยภาพของตัวเลข 0-9 และเรียนรู้ว่าภาพนั้นๆ เป็นตัวเลขอะไรโดยใช้โมเดลที่สร้างขึ้นมา และประเมินประสิทธิภาพของโมเดลด้วยชุดข้อมูลทดสอบ (test set)

ตัวอย่าง การใช้งาน Feedforward Neural Network เพื่อการจำแนกภาพด้วย Keras และ TensorFlow

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# 1. โหลดข้อมูล MNIST dataset จาก Keras
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# 2. ทำแปลงข้อมูลภาพให้เป็นเวกเตอร์ของ pixel และปรับ normalization
x_train = x_train.reshape(-1, 28 * 28).astype("float32") / 255.0
x_test = x_test.reshape(-1, 28 * 28).astype("float32") / 255.0

# 3. สร้างโมเดล Feedforward Neural Network
model = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(784,)),
    layers.Dense(128, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# 4. กำหนด loss function, optimizer, และ metrics สำหรับการ train model
model.compile(loss='sparse_categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

# 5. ฝึกโมเดลโดยใช้ training data และ validation data และกำหนด epochs
history = model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

# 6. ทดสอบโมเดลบน test data และแสดงผลลัพธ์
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('\nTest accuracy:', test_acc)

จากตัวอย่าง ได้ใช้ MNIST dataset เพื่อฝึกโมเดล Feedforward Neural Network สำหรับการจำแนกภาพตัวเลข 0-9 ด้วย Keras และ TensorFlow โดยมี 2 hidden layers ที่ใช้ ReLU activation function และ output layer ที่ใช้ softmax activation function สำหรับการจำแนกตัวเลข 0-9 โมเดลจะถูก train ด้วย loss function เป็น sparse categorical crossentropy และ optimizer เป็น adam optimizer โดยกำหนด epochs 10 และ validation data คือ test data สุดท้ายโมเดลจะถูกทดสอบบน test data และแสดงผลลัพธ์ accuracy ที่ได้

ตัวอย่าง การใช้ Feedforward Neural Network ในการทำนายสภาพอากาศโดยใช้ข้อมูลปริมาณน้ำฝน อุณหภูมิและความชื้นในอากาศเป็นตัวแปรอิสระ และสภาวะอากาศปกติและฝนตกเป็นตัวแปรตาม โมเดลที่ได้จะใช้ Feedforward Neural Network โดยมี 1 Hidden Layer ที่มี 10 โหนด และใช้ฟังก์ชัน Activation ประเภท ReLU ใน Hidden Layer และใช้ Softmax ใน Output Layer

ข้อมูลจะถูกนำเข้ามาจากไฟล์ CSV (weather.csv) ที่มีโครงสร้างดังนี้

Rainfall	Temperature	Humidity	Normal/ Rainy
0.2	0.5	0.8	0
0.0	0.7	0.6	1
0.5	0.2	0.3	1

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from keras.models import Sequential
from keras.layers import Dense

# อ่านข้อมูลจากไฟล์ CSV
data = pd.read_csv('weather.csv')

# แบ่งข้อมูลออกเป็น Features (X) และ Labels (y)
X = data.iloc[:, :-1].values
y = data.iloc[:, -1].values

# แบ่งข้อมูลเป็น Training set และ Test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# Feature Scaling
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

# กำหนดโครงสร้างของโมเดล Feedforward Neural Network
model = Sequential()
model.add(Dense(units=10, activation='relu', input_dim=X_train.shape[1]))
model.add(Dense(units=1, activation='sigmoid'))

# Compile โมเดล
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train โมเดล
model.fit(X_train, y_train, batch_size=32, epochs=100)

# Evaluate โมเดล
accuracy = model.evaluate(X_test, y_test)[1]
print('Accuracy:', accuracy)

ตัวอย่าง การใช้ Feedforward Neural Network ในการจำแนกและตรวจจับวัตถุด้วยภาพด้วยการใช้ Keras และ TensorFlow

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# โหลดข้อมูลภาพ
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

# แปลงค่า pixel เป็นช่วง 0-1
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

# สร้างโมเดล Feedforward Neural Network
model = keras.Sequential(
    [
        keras.Input(shape=(32, 32, 3)),
        layers.Flatten(),
        layers.Dense(512, activation="relu"),
        layers.Dense(256, activation="relu"),
        layers.Dense(128, activation="relu"),
        layers.Dense(10),
    ]
)

# คอมไพล์โมเดล
model.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    optimizer=keras.optimizers.Adam(lr=3e-4),
    metrics=["accuracy"],
)

# ฝึกโมเดล
model.fit(x_train, y_train, batch_size=64, epochs=10, verbose=2)

# ประเมินโมเดล
model.evaluate(x_test, y_test, batch_size=64, verbose=2)

จากตัวอย่าง ได้ใช้ข้อมูล CIFAR-10 ซึ่งเป็นชุดข้อมูลภาพที่มีการจำแนก 10 หมวดหมู่ของวัตถุต่าง ๆ และเราสร้างโมเดล Feedforward Neural Network ที่มี 4 hidden layers ที่ใช้ activation function เป็น ReLU และ output layer ที่ไม่มี activation function ในการทำนายหมวดหมู่ของวัตถุที่แตกต่างกัน โดยใช้ SparseCategoricalCrossentropy เป็นฟังก์ชัน loss function และ Adam optimizer ในการเรียนรู้

หลังจากฝึกโมเดลแล้ว เราสามารถประเมินผลการทำงานของโมเดลด้วยการใช้ฟังก์ชัน evaluate() บนชุดข้อมูลทดสอบ x_test และ y_test ที่เราแยกไว้ตั้งแต่แรก

ตัวอย่าง การใช้ Feedforward Neural Network ในการประมวลผลภาษาธรรมชาติ (Natural Language Processing) โดยใช้ Keras และ TensorFlow 2 ตัวอย่าง ข้อมูลในไฟล์ data.csv คือ
text,label
This is a positive sentence,1
This is a negative sentence,0
I am feeling good today,1
I am feeling bad today,0
The weather is nice today,1
The weather is terrible today,0
This movie is great,1
The plot is weak,0
The acting is superb,1
I didn’t like the ending,0

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# โหลดข้อมูล
df = pd.read_csv('data.csv')

# แบ่งข้อมูลเป็นชุด train และ test
train_size = int(len(df) * 0.8)
train_text = df['text'][:train_size].tolist()
train_labels = df['label'][:train_size].tolist()
test_text = df['text'][train_size:].tolist()
test_labels = df['label'][train_size:].tolist()

# แปลงข้อความเป็นตัวเลขโดยใช้ Tokenizer
tokenizer = Tokenizer(num_words=5000)
tokenizer.fit_on_texts(train_text)
train_sequences = tokenizer.texts_to_sequences(train_text)
test_sequences = tokenizer.texts_to_sequences(test_text)

# กำหนดความยาวของตัวอักษรเป็นค่าคงที่
max_sequence_length = 200
train_data = pad_sequences(train_sequences, maxlen=max_sequence_length)
test_data = pad_sequences(test_sequences, maxlen=max_sequence_length)

# สร้างโมเดล Feedforward Neural Network
model = Sequential([
    Dense(64, input_shape=(max_sequence_length,), activation='relu'),
    Dropout(0.5),
    Dense(32, activation='relu'),
    Dropout(0.5),
    Dense(1, activation='sigmoid')
])

# กำหนด optimizer และ loss function
optimizer = Adam(learning_rate=0.001)
model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])

# สอนโมเดล
model.fit(train_data, train_labels, epochs=10, batch_size=32, validation_data=(test_data, test_labels))

จากตัวอย่างเป็นการใช้ Feedforward Neural Network ในการจำแนกข้อความ โดยใช้ตัวอย่างข้อมูลจากไฟล์ ‘data.csv’ โดยโมเดลที่สร้างมีโครงสร้างดังนี้

ชั้น input มีจำนวนโหนด 200 (max_sequence_length) เพื่อรับ input ของข้อความที่มีความยาวไม่เกิน 200 ตัวอักษร
ชั้นซ่อนที่ 1 มีจำนวนโหนด 64 และใช้ activation function เป็น ReLU
ชั้น Dropout ที่ 0.5 เพื่อลดการเกิด overfitting
ชั้นซ่อนที่ 2 มีจำนวนโหนด 32 และใช้ activation function เป็น ReLU
อีกชั้น Dropout ที่ 0.5 เพื่อลดการเกิด overfitting
ชั้น output มีจำนวนโหนดเพียง 1 โดยใช้ activation function เป็น sigmoid เพื่อให้ได้ผลลัพธ์ออกมาเป็นค่าความน่าจะเป็นของข้อความที่ input เป็น positive class (1) หรือ negative class (0)

ใช้ข้อมูลภาษาธรรมชาติจากไฟล์ data.csv ซึ่งประกอบไปด้วยคอลัมน์ text และ label โดย text เป็นข้อความและ label เป็นคลาสของข้อความนั้น (0 หรือ 1) ต่อมาเราแบ่งข้อมูลเป็นชุด train และ test ด้วยอัตราส่วน 80:20 และใช้ Tokenizer เพื่อแปลงข้อความให้กลายเป็นตัวเลข

โมเดลจะถูกสอนด้วยข้อมูล train_data และ train_labels ใน 10 รอบ (epochs) และ batch size คือ 32 ด้วย optimizer เป็น Adam ที่มี learning rate เท่ากับ 0.001 และ loss function เป็น binary_crossentropy และเมื่อสอนเสร็จสิ้นจะได้ผลลัพธ์ accuracy จากการทดสอบด้วยข้อมูล test_data และ test_labels ออกมาด้วย

Feedforward Neural Network จะมีทั้งหมด 3 ชั้น ด้วยกัน ได้แก่

Activation Function ส่วนใหญ่จะใช้ใน Hidden Layer ได้แก่

จุดเด่น Feedforward Neural Network ได้แก่

การเขียนโปรแกรมด้วย Python เพื่อใช้งาน Feedforward Neural Network

ล่าสุด

เครื่องมือปัญญาประดิษฐ์ในการสร้างสื่อ (Generative Artificial Intelligence Media Tools)

การใช้เทคโนโลยีสมัยใหม่เพื่อเพิ่มประสิทธิภาพผลผลิตเกษตรในฟาร์มอัจฉริยะ

การใช้เทคโนโลยีสวมใส่ (Wearable Technology) เพื่อตรวจสอบสุขภาพสัตว์และประสิทธิภาพผลผลิต

การใช้เทคโนโลยีการประมวลผลภาพ (Image Processing Technology) เพื่อเพิ่มประสิทธิภาพในฟาร์มอัจฉริยะ

หมวดหมู่

ดร.กิตติมศักดิ์ ในจิต

โมเดลประสาทเทียม Feedforward Neural Network (FNN)

Feedforward Neural Network จะมีทั้งหมด 3 ชั้น ด้วยกัน ได้แก่

Activation Function ส่วนใหญ่จะใช้ใน Hidden Layer ได้แก่

จุดเด่น Feedforward Neural Network ได้แก่

การเขียนโปรแกรมด้วย Python เพื่อใช้งาน Feedforward Neural Network

ล่าสุด

เครื่องมือปัญญาประดิษฐ์ในการสร้างสื่อ (Generative Artificial Intelligence Media Tools)

การใช้เทคโนโลยีสมัยใหม่เพื่อเพิ่มประสิทธิภาพผลผลิตเกษตรในฟาร์มอัจฉริยะ

การใช้เทคโนโลยีสวมใส่ (Wearable Technology) เพื่อตรวจสอบสุขภาพสัตว์และประสิทธิภาพผลผลิต

การใช้เทคโนโลยีการประมวลผลภาพ (Image Processing Technology) เพื่อเพิ่มประสิทธิภาพในฟาร์มอัจฉริยะ

หมวดหมู่

Tags

ดร.กิตติมศักดิ์ ในจิต