โครงข่ายประสาทเทียม Artificial Neural Networks (ANN)

โครงข่ายประสาทเทียม (Artificial Neural Networks) ได้เลียนแบบการทำงานของเซลล์ประสาทในสมองมนุษย์ โดยประกอบด้วยโหนด (node) หรือเรียกอีกชื่อหนึ่งว่าเซลล์ประสาทเทียม (artificial neuron) ที่เชื่อมต่อกันเป็นชั้น (layer) เพื่อสร้างการเรียนรู้และประมวลผลตามข้อมูลที่ได้รับเข้ามา

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

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

แนวคิดเริ่มจากการศึกษาเซลล์ประสาทชีวภาพ (Biological Neuron) ในสมองของมนุษย์ ซึ่งประกอบด้วย “นิวรอน” (Neurons) หรือ เซลล์ประสาท  และ “ซินแนปส์” (Synapses) หรือ จุดประสานประสาท ในแต่ละเซลล์ประสาทนั้นจะประกอบไปด้วยปลายในการรับกระแสประสาท ที่เรียกว่า “เดนไดรท์” (Dendrite) ซึ่งเป็นส่วนของ Input และในการส่งกระแสประสาท เรียกว่า “แอคซอน” (Axon) ซึ่งเป็นเหมือน Output ของเซลล์ โดยเซลล์เหล่านี้ทำงานด้วยปฏิกิริยาไฟฟ้าเคมี เมื่อมีการกระตุ้นด้วยสิ่งเร้าต่าง ๆ จากภายนอกหรือกระตุ้นด้วยเซลล์ด้วยกันก็ได้ กระแสประสาทจะวิ่งผ่าน “เดนไดรท์” (Dendrite) เข้าสู่ “นิวเคลียส” (Nucleus) ซึ่งจะเป็นตัวตัดสินว่าต้องกระตุ้นเซลล์อื่น ๆ ต่อหรือไม่ ถ้ากระแสประสาทมีแรงเพียงพอ นิวเคลียสก็จะกระตุ้นไปยังเซลล์อื่น ๆ ต่อไปผ่านทาง “แอคซอน” (Axon)

โครงข่ายประสาทเทียม (Artificial Neural Networks) เป็นเครื่องมือทางคณิตศาสตร์และการเรียนรู้เชิงลึก (Deep Learning) ที่นิยมใช้ในการแก้ไขปัญหาทางคอมพิวเตอร์ที่ซับซ้อน เช่น การจำแนกภาพ การตรวจจับวัตถุ การแปลภาษา และอื่นๆ เป็นแบบจำลองของระบบประมวลผลข้อมูลที่มีความซับซ้อนและมีความสามารถในการเรียนรู้แบบเชิงลึก (Deep Learning) เพื่อค้นหาความสัมพันธ์ระหว่างข้อมูลที่ซับซ้อน โดยการจำลองการทำงานของเซลล์ประสาทในระบบประสาทของมนุษย์ ซึ่งประกอบด้วยชั้น (layer) ของโนเดลที่เรียกว่า ชั้นป้อนเข้า (input layer) ชั้นซ่อน (hidden layer) และชั้นส่งออก (output layer) โดยสามารถปรับเปลี่ยนจำนวนและขนาดของชั้นต่างๆ ได้ตามต้องการ

โดยโครงข่ายประสาทเทียมประกอบด้วยหน่วยประมวลผล (neurons) ซึ่งเป็นโครงสร้างพื้นฐานของโมเดล แต่ละโหนดจะมีค่าน้ำหนัก (weights) และไบแอส (bias) ซึ่งจะปรับเปลี่ยนตามข้อมูลที่ถูกป้อนเข้ามา โดยใช้ฟังก์ชัน Activation Function เพื่อคำนวณผลลัพธ์ที่ได้จากการนำค่าน้ำหนักและไบแอสมารวมกัน และส่งออกผลลัพธ์ไปยังโหนดในชั้นถัดไป โดยในการสร้างโครงข่ายประสาทเทียมจะต้องกำหนดหลายๆ พารามิเตอร์ เช่น จำนวนชั้นซ่อน จำนวนโหนดในแต่ละชั้น ฟังก์ชัน Activation Function และการเรียนรู้ที่ใช้ เช่น Backpropagation และ Stochastic Gradient Descent เป็นต้น

โครงข่ายประสาทเทียมจะประกอบด้วยหลายชั้น (Layers) โดยแต่ละชั้นจะมีโหนด (Nodes) หรือเซลล์ประสาท (Neurons) ที่เชื่อมต่อกันเป็นเครือข่าย โดยข้อมูลจะถูกส่งผ่านชั้นต่างๆ และผ่านการประมวลผลของโหนดแต่ละตัว เพื่อสร้างรูปแบบ (Pattern) และค้นหาความสัมพันธ์ของข้อมูล

แต่ละโหนดในชั้นต่างๆ ของโครงข่ายประสาทเทียมจะมีฟังก์ชัน Activation ซึ่งเป็นฟังก์ชันทางคณิตศาสตร์ที่ใช้ในการประมวลผลของโหนด เช่น Sigmoid, ReLU, Tanh และ Softmax โดยฟังก์ชัน Activation จะช่วยกำหนดวิธีการคำนวณและปรับค่าน้ำหนัก (Weights) ของเซลล์ประสาท เพื่อให้โมเดลสามารถเรียนรู้และปรับค่าน้ำหนักได้อย่างมีประสิทธิภาพ

โครงข่ายประสาทเทียมประกอบด้วยหลายชั้น (layers) ซึ่งแต่ละชั้นประกอบไปด้วยโหนด (nodes) หรือเรียกว่าเซลล์ประสาท (neurons) ซึ่งแต่ละโหนดจะรับข้อมูลจากโหนดในชั้นก่อนหน้าและส่งผลลัพธ์ไปยังโหนดในชั้นถัดไป

โหนดในชั้นแรกที่รับข้อมูลเรียกว่า Input Layer และโหนดในชั้นสุดท้ายที่ส่งผลลัพธ์ออกมาเรียกว่า Output Layer ซึ่งแต่ละโหนดใน Output Layer จะแสดงผลลัพธ์ในรูปแบบของค่าน้ำหนัก (weights) ของแต่ละหมวดหมู่ (class) โดยมีค่าน้ำหนักเพิ่มขึ้นตามความเหมาะสมของโมเดลในการจำแนกแต่ละหมวดหมู่

นอกจาก Input Layer และ Output Layer ยังมี Hidden Layer ซึ่งเป็นชั้นที่อยู่ระหว่าง Input Layer และ Output Layer ซึ่งชั้นนี้จะมีผลต่อประสิทธิภาพของโมเดลเป็นอย่างมาก การเพิ่มหรือลดจำนวนชั้นและโหนดในแต่ละชั้นจะมีผลต่อการประมวลผลและประสิทธิภาพของโมเดลด้วย การสร้างโครงข่ายประสาทเทียมยังต้องระบุฟังก์ชัน Activation ที่ใช้ในการคำนวณผลลัพธ์ของแต่ละโหนดในโครงข่าย และการเลือกฟังก์ชัน Activation ที่เหมาะสมสามารถทำให้โมเดลมีประสิทธิภาพมากขึ้นด้วย 

โครงข่ายประสาทเทียม (Artificial Neural Networks) จะเลียนแบบการทำงานของเซลล์ประสาทในสมองของมนุษย์ โดยโมเดลจะประกอบไปด้วยหลายๆ โหนด (neurons) ซึ่งแต่ละโหนดนั้นจะมีค่าน้ำหนัก (weight) และจะรวมข้อมูลเข้าด้วยกันจนกว่าจะได้ผลลัพธ์ออกมา

โครงข่ายประสาทเทียม มีหลากหลายโครงสร้างแล้วแต่จุดประสงค์ในการประยุกต์ใช้งาน สามารถแสดงได้ดังนี้

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

องค์ประกอบของโครงข่ายประสาทเทียม (Artificial Neural Networks)

สามารถจำแนกออกได้ดังนี้

1. Input Layer:
   ซึ่งจะรับข้อมูลเข้าสู่โครงข่าย แต่ละโหนดจะแทนค่าของตัวแปรอิสระ (Independent Variable) หรือคุณลักษณะ (Feature) ของข้อมูล รับข้อมูลเข้ามาเป็นค่าเลขที่สามารถจัดเก็บในรูปแบบของเวกเตอร์หรือเมทริกซ์ จำนวนโหนดในชั้นนี้จะเท่ากับจำนวนข้อมูลนำเข้า

2. Hidden Layer:
   ส่วนของโครงข่ายที่มีการประมวลผลและเรียนรู้ข้อมูล โดยปกติจะมีหลายชั้น แต่ละชั้นมีหลายโหนด (Neuron) ที่เชื่อมต่อกันเป็นเครือข่าย ชั้นที่มีโหนดกลางที่คำนวณค่าระหว่าง Input Layer และ Output Layer โดยสามารถมีหลายชั้น แต่ละชั้นมีจำนวนโหนดที่แตกต่างกันไป และมีฟังก์ชัน Activation ที่ใช้ในการคำนวณผลลัพธ์ของแต่ละโหนด

3. Output Layer:
   เป็นการระบุรูปแบบของผลลัพธ์ที่โมเดลจะส่งออก เช่น สถานะของข้อมูล หรือประเภท (Classification) หรือค่าความน่าจะเป็น (Probability) ของผลลัพธ์ (Regression) เป็นชั้นสุดท้ายของโครงข่ายประสาทเทียม รับข้อมูลจากชั้นก่อนหน้า และคำนวณผลลัพธ์ที่ต้องการส่งออก โดยจำนวนโหนดในชั้นนี้จะขึ้นอยู่กับประเภทงานที่ต้องการ

4. Node หรือ Artificial Neuron:
   เป็นหน่วยประมวลผลที่รับข้อมูลเข้ามา และทำการประมวลผลเพื่อส่งข้อมูลออกไปยังโหนดในชั้นถัดไป โดยประกอบด้วยการนำข้อมูลเข้ามาหาผลรวม (weighted sum) และผ่านฟังก์ชันเพื่อให้ได้ผลลัพธ์ที่ต้องการ

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

6. Bias:
   เป็นค่าคงที่ที่เพิ่มความยืดหยุ่นให้กับโมเดล เป็นตัวแปรตัวหนึ่งที่บวกเข้ากับผลลัพธ์ของแต่ละโหนด ค่าคงที่ที่บวกเข้ากับผลรวมของค่าน้ำหนักและค่าข้อมูลในแต่ละโหนดเพื่อเพิ่มความยืดหยุ่นในการเรียนรู้ ให้โมเดลมีความยืดหยุ่นในการเรียนรู้และปรับปรุง

7. Activation Function:
   เป็นฟังก์ชันที่ใช้ในการคำนวณผลลัพธ์ของแต่ละโหนดในโครงข่ายประสาทเทียม ซึ่งมีหลายรูปแบบ เช่น Sigmoid, ReLU, Tanh และ Softmax โดยฟังก์ชัน Activation จะใช้ค่า input ที่ได้จากขั้นตอนก่อนหน้านี้แล้วนำไปคำนวณเพื่อส่งผลลัพธ์ออกมาเป็น output ซึ่งจะไปเป็น input ของโหนดต่อไปในโครงข่ายประสาทเทียม การเลือกใช้ฟังก์ชัน Activation นั้นจะขึ้นอยู่กับประเภทของโครงข่ายประสาทเทียมและการแก้ปัญหาที่ต้องการแก้ไขด้วยโมเดลที่กำลังสร้าง

กระบวนการใช้โครงข่ายประสาทเทียม (ANN) ด้วยภาษา Python

ประกอบด้วยขั้นตอนหลักๆ ดังนี้

1. เตรียมข้อมูล:
   นำเข้าชุดข้อมูลและทำการแปลงข้อมูลให้อยู่ในรูปแบบที่เหมาะสมสำหรับโมเดล ANN โดยใช้โมดูล numpy และ pandas เพื่อจัดการข้อมูลและ numpy ในการคำนวณเชิงเลข ในขั้นตอนนี้จะต้องทำการสำรวจและเตรียมข้อมูลให้เหมาะสมกับการใช้งานโครงข่ายประสาทเทียม เช่น การแปลงรูปแบบของข้อมูล เปลี่ยนขนาดภาพ และการทำ scaling ข้อมูล

2. สร้างโมเดล ANN:
   กำหนดโครงสร้างของโมเดล ANN โดยใช้ Keras ซึ่งเป็นซอฟต์แวร์ Deep Learning ที่ถูกพัฒนาขึ้นโดย Google ในขั้นตอนนี้จะต้องกำหนดโครงสร้างของโมเดล ANN ที่เหมาะสมกับปัญหาที่ต้องการแก้ไข โดยจะต้องเลือกประเภทของ layer และ activation function ที่เหมาะสม และสร้างโมเดล ANN โดยใช้ไลบรารี TensorFlow และ Keras และทำการคอมไพล์โมเดลเพื่อเตรียมใช้งาน

3. คอมไพล์และฝึกโมเดล ANN:
   กำหนดการคอมไพล์และฝึกโมเดล ANN โดยใช้ฟังก์ชัน compile() เพื่อกำหนดข้อมูลเข้าและออกของโมเดล ANN และฟังก์ชัน fit() เพื่อฝึกโมเดล ANN ด้วยชุดข้อมูลที่กำหนด ในขั้นตอนนี้จะต้องนำข้อมูลที่เตรียมไว้มาฝึกโมเดล ANN โดยใช้ฟังก์ชัน compile() และ fit() เพื่อฝึกโมเดล ANN และพัฒนาประสิทธิภาพของโมเดล

4. วัดประสิทธิภาพของโมเดล ANN:
   ใช้ฟังก์ชัน evaluate() เพื่อวัดประสิทธิภาพของโมเดล ANN ด้วยชุดข้อมูลทดสอบ ในขั้นตอนนี้จะต้องทำการวัดประสิทธิภาพของโมเดล ANN โดยใช้ชุดข้อมูลทดสอบ (test data) เพื่อดูว่าโมเดลทำงานได้ถูกต้องและมีประสิทธิภาพมากน้อยแค่ไหน

5. ใช้โมเดล ANN ในการทำนาย:
   ใช้ฟังก์ชัน predict() เพื่อใช้โมเดล ANN ในการทำนายผลลัพธ์จากชุดข้อมูลที่กำหนด

6. ปรับแต่งและประยุกต์ใช้:
   ปรับแต่งและประยุกต์ใช้โมเดล ANN ให้เหมาะสมกับงานที่ต้องการ

การใช้โครงข่ายประสาทเทียม (Artificial Neural Networks) ด้วย Python เป็นเทคนิคที่สำคัญและมีความสำคัญมากในการแก้ไขปัญหาทางด้าน AI, Machine Learning, และ Deep Learning ที่เกี่ยวข้องกับการจำแนกประเภท (Classification), การทำนาย (Prediction), การเรียนรู้ (Learning), การแยกแยะ (Discrimination), การจำแนกข้อมูล (Data Classification), การกระจาย (Distribution), การจัดกลุ่ม (Clustering) และอื่นๆ

การใช้ Python สามารถสร้างโครงข่ายประสาทเทียมได้อย่างรวดเร็วและมีหลากหลายเครื่องมือที่ช่วยให้ง่ายต่อการพัฒนาและปรับปรุงโมเดล ไม่ว่าจะเป็น TensorFlow, Keras, PyTorch, Theano, MXNet หรืออื่นๆ นอกจากนี้ยังมีหลายไลบรารีและเครื่องมืออื่นๆ ที่ช่วยในการวิเคราะห์และแสดงผลข้อมูล อีกทั้งยังมีความยืดหยุ่นในการสร้างโมเดล ANN ตามความต้องการและเป้าหมายของผู้ใช้งาน ทำให้ Python เป็นภาษาโปรแกรมที่ถูกนำมาใช้กันอย่างแพร่หลายในการพัฒนาโมเดล ANN และการแก้ไขปัญหาด้าน AI โดยทั่วไป

ตัวอย่าง โครงข่ายประสาทเทียมที่ใช้ TensorFlow เพื่อจำแนกสิ่งของออกเป็นสองกลุ่ม

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

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

# แปลงข้อมูลเป็นรูปแบบที่เหมาะสม
x_train = x_train.reshape((60000, 28 * 28))
x_train = x_train.astype('float32') / 255

x_test = x_test.reshape((10000, 28 * 28))
x_test = x_test.astype('float32') / 255

# สร้างโมเดล
model = keras.Sequential([
    layers.Dense(512, activation='relu', input_shape=(28 * 28,)),
    layers.Dense(10, activation='softmax')
])

# คอมไพล์และฝึกโมเดล
model.compile(optimizer='rmsprop',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5, batch_size=128)

# ประเมินความแม่นยำ
test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)

จากตัวอย่าง ได้สร้างโมเดลที่ประกอบด้วยเลเยอร์ Dense 2 ชั้น โดยมีฟังก์ชัน activation เป็น relu สำหรับชั้นแรกและฟังก์ชัน activation เป็น softmax สำหรับชั้นสุดท้าย เพื่อส่งออกผลลัพธ์เป็นความน่าจะเป็นของแต่ละคลาส โมเดลนี้ถูกฝึกบนชุดข้อมูล MNIST ซึ่งเป็นชุดข้อมูลภาพตัวเลข และเราใช้ optimizer เป็น rmsprop และ loss function เป็น sparse_categorical_crossentropy ในการคอมไพล์และฝึกโมเดล ในท้ายที่สุดเราประเมินความแม่นยำของโมเดลบนชุดข้อมูลทดสอบและพิมพ์ค่าความแม่นยำออกมา

ตัวอย่าง สร้างและฝึกฝนโมเดลโครงข่ายประสาทเทียม (ANN) ด้วย TensorFlow

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

# สร้างข้อมูลสำหรับการฝึกฝน
x_data = np.linspace(0, 10, 1000)
y_data = np.sin(x_data)

# สร้างโมเดล ANN
model = tf.keras.Sequential([
    tf.keras.layers.Dense(32, activation='relu', input_shape=(1,)),
    tf.keras.layers.Dense(16, activation='relu'),
    tf.keras.layers.Dense(1)
])

# กำหนดการคอมไพล์โมเดล
model.compile(optimizer=tf.keras.optimizers.Adam(0.01),
              loss=tf.keras.losses.mean_squared_error)

# ฝึกโมเดล
history = model.fit(x_data, y_data, epochs=50, verbose=0)

# แสดงผลลัพธ์ด้วยกราฟ
plt.plot(history.history['loss'])
plt.title('Model Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.show()

จากตัวอย่าง จะสร้างโมเดล ANN ที่ประกอบด้วย 3 ชั้น คือชั้นของ Input Layer, ชั้นของ Hidden Layer 1 ที่มี 32 โหนดและใช้ฟังก์ชัน activation เป็น ReLU, ชั้นของ Hidden Layer 2 ที่มี 16 โหนดและใช้ฟังก์ชัน activation เป็น ReLU และ Output Layer ที่มี 1 โหนด โดยไม่ได้ระบุฟังก์ชัน activation เนื่องจากเป็นแบบ Regression คือการทำนายค่าต่อเนื่อง จากนั้นใช้คำสั่ง compile() เพื่อกำหนด optimizer และ loss function และใช้ fit() เพื่อฝึกโมเดล ANN ด้วยข้อมูล x_data และ y_data ที่เตรียมไว้ก่อนหน้า ในลักษณะของ Regression โดยการฝึกฝนใน 50 epochs และไม่แสดงผลลัพธ์ทุกครั้งที่วนรอบ สุดท้ายใช้ matplotlib เพื่อแสดงกราฟของ loss function จากการฝึกฝน

ตัวอย่าง สร้างและฝึกฝนโมเดลโครงข่ายประสาทเทียม (ANN) ด้วย TensorFlow

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

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

# แปลงค่าพิกเซลเป็นค่าที่เหมาะสมสำหรับ ANN
x_train = x_train.reshape(-1, 784).astype("float32") / 255.0
x_test = x_test.reshape(-1, 784).astype("float32") / 255.0

# กำหนดโครงสร้างของโมเดล ANN
inputs = keras.Input(shape=(784,))
x = layers.Dense(512, activation="relu")(inputs)
x = layers.Dropout(0.5)(x)
x = layers.Dense(256, activation="relu")(x)
x = layers.Dropout(0.5)(x)
x = layers.Dense(128, activation="relu")(x)
outputs = layers.Dense(10, activation="softmax")(x)

model = keras.Model(inputs=inputs, outputs=outputs, name="mnist_model")

# สร้างตัวอย่างภาพของโมเดล ANN
keras.utils.plot_model(model, "mnist_model.png", show_shapes=True)

# คอมไพล์และฝึกโมเดล ANN
model.compile(loss="sparse_categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
history = model.fit(x_train, y_train, batch_size=128, epochs=20, validation_split=0.1)

# วัดประสิทธิภาพของโมเดล ANN ด้วยชุดข้อมูลทดสอบ
test_scores = model.evaluate(x_test, y_test, verbose=2)
print("Test loss:", test_scores[0])
print("Test accuracy:", test_scores[1])

จากตัวอย่าง มีการสร้างและฝึกโมเดล ANN ด้วยชุดข้อมูล MNIST ซึ่งเป็นชุดข้อมูลสำหรับการจำแนกตัวเลข 0-9 จากภาพดิจิทัล โดยมีขั้นตอนดังนี้

1. โหลดชุดข้อมูล MNIST และแปลงค่าพิกเซลให้เป็นค่าที่เหมาะสมสำหรับ ANN

(x_train, y_train), (x_test, y_test) = mnist.load_data()

x_train = x_train.reshape(-1, 784).astype("float32") / 255.0
x_test = x_test.reshape(-1, 784).astype("float32") / 255.0

2. กำหนดโครงสร้างของโมเดล ANN ด้วย keras.Input() และ layers.Dense() และเพิ่ม Dropout layer เพื่อลด overfitting

inputs = keras.Input(shape=(784,))
x = layers.Dense(512, activation="relu")(inputs)
x = layers.Dropout(0.5)(x)
x = layers.Dense(256, activation="relu")(x)
x = layers.Dropout(0.5)(x)
x = layers.Dense(128, activation="relu")(x)
outputs = layers.Dense(10, activation="softmax")(x)

model = keras.Model(inputs=inputs, outputs=outputs, name="mnist_model")

3. สร้างและแสดงตัวอย่างภาพของโมเดล ANN ด้วย keras.utils.plot_model()

keras.utils.plot_model(model, "mnist_model.png", show_shapes=True)

4. คอมไพล์และฝึกโมเดล ANN ด้วย model.compile() และ model.fit()

model.compile(loss="sparse_categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
history = model.fit(x_train, y_train, batch_size=128, epochs=20, validation_split=0.1)

5. วัดประสิทธิภาพของโมเดล ANN ด้วยชุดข้อมูลทดสอบ โดยใช้ model.evaluate()

test_scores = model.evaluate(x_test, y_test, verbose=2)
print("Test loss:", test_scores[0])
print("Test accuracy:", test_scores[1])

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

ต่อมา กำหนดชั้น Dense สามชั้น โดยแต่ละชั้นมีจำนวนโหนด (node) คือ 512, 256, และ 128 ตามลำดับ โดยใช้ฟังก์ชัน activation ที่เป็น ReLU และใช้ Dropout เพื่อลดการเรียนรู้โดยไม่จำเป็นของโมเดล (regularization)

ต่อมา กำหนดชั้น output ที่มีจำนวนโหนดเท่ากับจำนวนคลาสในชุดข้อมูลซึ่งในกรณีนี้คือ 10 โดยใช้ฟังก์ชัน activation ที่เป็น softmax เพื่อให้ค่าผลลัพธ์เป็นความน่าจะเป็นในแต่ละคลาส หลังจากนั้นสร้างโมเดลด้วย keras.Model และกำหนดชื่อโมเดลว่า mnist_model

สำหรับการคอมไพล์และฝึกโมเดล ANN ใช้ model.compile และ model.fit ตามลำดับ ซึ่งกำหนด loss function เป็น sparse_categorical_crossentropy เนื่องจากข้อมูลประเภทของเราเป็น categorical แต่เราไม่ได้ทำ One-Hot Encoding จึงใช้ sparse_categorical_crossentropy และ optimizer เป็น adam สุดท้ายตั้งค่า metrics ที่เป็น accuracy สำหรับวัดประสิทธิภาพของโมเดล