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

โมเดลประสาทเทียมแบบ Recurrent Neural Network (RNN) เป็นโมเดลที่ได้รับความนิยมในการใช้งานด้านการประมวลผลข้อมูลชุดนิยามเป็นลำดับ (sequential data) เช่น ข้อความ (text), เสียง (audio) หรือ วิดีโอ (video) เนื่องจาก RNN สามารถเข้าใจลำดับของข้อมูลและเป็นไปตามลำดับนั้นเอง

โมเดล RNN ประกอบด้วยชั้น LSTM (Long Short-Term Memory) หรือ GRU (Gated Recurrent Unit) ซึ่งเป็นแบบประเภทหนึ่งของ RNN ที่ถูกพัฒนาขึ้นมาเพื่อแก้ปัญหาการหาอินพุตก่อนหน้า (vanishing gradient problem) และปัญหาการทำงานกับชุดข้อมูลที่ยาวนาน

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

โมเดลประสาทเทียม Recurrent Neural Network (RNN) เป็นโมเดลที่สามารถใช้งานกับข้อมูลลำดับได้ เช่น ข้อความ หรือ เสียง ซึ่งแต่ละตัวอักษรหรือเสียงจะเป็นข้อมูลลำดับ โดยที่ข้อมูลก่อนหน้าจะมีผลต่อข้อมูลถัดไป

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

RNN มีประโยชน์ในการทำงานกับข้อมูลที่เป็นลำดับ เช่น การทำนายคำถัดไปในประโยค แปลภาษา การจดจำสิ่งที่เกิดขึ้นในช่วงเวลา เป็นต้น โดย RNN มีความสามารถในการเรียนรู้โดยไม่จำเป็นต้องมีข้อมูลแบบ supervised (มีการตอบแทนที่ถูกต้อง) แต่สามารถเรียนรู้ได้จากข้อมูลลำดับเดียวกันที่ได้รับมา โดยใช้กระบวนการ backpropagation ในการปรับค่าพารามิเตอร์ในโมเดล

โมเดลประสาทเทียมแบบ Recurrent Neural Network (RNN) เป็นโมเดลที่มีความสามารถในการจำความเป็นลำดับของข้อมูลได้ดี โดยมีการเชื่อมต่อกันของชั้นประสาทเทียมแต่ละชั้นเป็นแบบ sequence-to-sequence เพื่อให้โมเดลสามารถรับข้อมูลแบบลำดับได้ โดยในแต่ละชั้นประสาทเทียมจะมีการคำนวณในแต่ละ step โดยที่ผลลัพธ์จากขั้นตอนก่อนหน้าจะถูกส่งมาเป็น input ในขั้นตอนถัดไป นอกจากนี้ RNN ยังมีชั้นประสาทเทียมพิเศษที่เรียกว่า Long Short-Term Memory (LSTM) ที่สามารถจำความได้นานและสามารถป้องกันการเกิด vanishing gradient ได้ดีกว่า RNN ปกติ โมเดลประสาทเทียม Recurrent Neural Network (RNN) มีลักษณะแบบซ้อนทับและมีการเชื่อมต่อกลับไปยังตัวเอง ซึ่งช่วยให้ RNN สามารถดูแล้วจำข้อมูลของสถานะก่อนหน้าได้ และสามารถใช้ความเข้าใจเกี่ยวกับความสัมพันธ์ของข้อมูลแบบลำดับได้

โครงสร้างของโมเดล RNN ประกอบด้วย

1. Input Layer

เป็นชั้นแรกของโมเดลที่รับข้อมูลเข้ามา โดยจะมีจำนวน Input Node ตามจำนวน feature ของข้อมูล มีหน้าที่รับข้อมูลเข้ามา โดยปกติแล้ว Input Layer ของ RNN จะรับข้อมูลที่เป็น sequence หรือลำดับของข้อมูล เช่น ข้อมูลภาษาญี่ปุ่นที่เป็นลำดับของตัวอักษร หรือข้อมูลเสียงที่เป็นลำดับของค่าแหล่งเสียง

ขนาดของ Input Layer ของ RNN จะถูกกำหนดโดยลำดับของข้อมูลที่นำเข้า ซึ่งขนาดของ Input Layer จะเท่ากับจำนวนลำดับของข้อมูล (timesteps) ต่อหนึ่งข้อมูลในแต่ละช่วง (epoch) และแต่ละลำดับของข้อมูลจะถูกแทนด้วย vector ขนาด n ซึ่ง n จะเท่ากับจำนวน feature ของข้อมูลที่นำเข้า ตัวอย่างเช่น หากเรานำเข้าข้อมูลภาษาญี่ปุ่น ซึ่งมีจำนวนตัวอักษรเท่ากับ 50 ตัว และแทนแต่ละตัวอักษรด้วย vector ขนาด 100 จะได้ Input Layer ขนาด (timesteps, 100)

มีรูปแบบเป็น Sequence Input Layer ซึ่งจะรับ input ในรูปแบบของ sequence และเป็น tensor 3 มิติ (batch_size, timesteps, input_dim) โดยที่

• • batch_size คือจำนวนของตัวอย่างที่จะใช้ในการเทรนโมเดลในแต่ละ batch
  • timesteps คือจำนวนของ timestep ในแต่ละ sequence โดยที่แต่ละ timestep จะเป็น input vector ขนาด input_dim
  • input_dim คือจำนวนของ features หรือ dimension ในแต่ละ timestep

นอกจากนี้ Input Layer ของ RNN ยังสามารถกำหนดการใช้งาน Dropout Layer หรือ BatchNormalization Layer เพื่อป้องกันการเกิด overfitting ในโมเดลได้ด้วย

2. Hidden Layer

มีการเชื่อมต่อกับตัวเองในชั้นเดียวกัน (Recurrent) เพื่อเก็บข้อมูลสถานะก่อนหน้า โดยจำนวน Node สามารถปรับได้ตามความต้องการ ทำหน้าที่ในการเรียนรู้และเข้าใจลักษณะของข้อมูลจำนวนมากโดยที่ไม่จำเป็นต้องแยกแยะลักษณะเด่นของข้อมูลเหล่านั้นอย่างชัดเจน โดย Hidden Layer จะประกอบไปด้วยหน่วยทำงานหลายๆ หน่วยที่เรียกว่า cells หรือ memory cells ที่สามารถจำข้อมูลของชุดข้อมูลที่ผ่านมาได้ และใช้ข้อมูลเหล่านี้เพื่อสร้างการทำนายผลลัพธ์ของชุดข้อมูลใหม่

ใน Hidden Layer ของ RNN จะมีการใช้ค่าจาก Time Step ก่อนหน้านี้เป็น Input เข้ามาพร้อมกับ Input ใหม่ เพื่อจำแนกและทำนายผลลัพธ์ แต่จะเกิดปัญหาในการทำนายเมื่อข้อมูลใน Time Step ก่อนหน้านั้นมีผลกระทบต่อผลลัพธ์ของ Time Step ปัจจุบันอย่างมากๆ โดยการแก้ปัญหานี้คือใช้โครงสร้าง LSTM และ GRU ซึ่งเป็นโมเดล RNN พิเศษที่สามารถจัดการกับปัญหาของการเก็บความจำได้ดีกว่า RNN แบบธรรมดา

โดย Hidden Layer ในโมเดล RNN จะประกอบไปด้วยหน่วยเก็บความจำ (memory cells) ที่จะเก็บข้อมูลที่ผ่านมาจาก Time Step ก่อนหน้านี้ โดยจะมีการส่ง input และ state จาก Time Step ก่อนหน้าเข้ามาใน Hidden Layer ของ Time Step ปัจจุบัน เพื่อทำนายผลลัพธ์ Hidden Layer สามารถแบ่งออกได้ คือ

• • Recurrent Hidden Layer (หรือ Recurrent Layer)
    เป็นชั้นที่มีลักษณะเด่นคือการเชื่อมต่อกันของโหนด (node) ทั้งหมดภายใน Layer เอง โดยโหนดแต่ละตัวจะรับ Input ไม่เพียงแค่จาก Input Layer เท่านั้น แต่ยังรับ Input จากโหนดของ Layer เดิม ดังนั้น Layer นี้สามารถเรียนรู้และเก็บข้อมูลที่เป็นลำดับ (sequence data) ได้ เช่น ภาษาญี่ปุ่น โดยโหนดแต่ละตัวจะเป็นเหมือน “ความจำ” (memory) ที่บันทึกข้อมูลจากขั้นต่ำกว่า เพื่อใช้ในการตัดสินใจขั้นต่อไป จะไม่มีการเชื่อมต่อกันระหว่างโนดในชั้นเอง เพราะจะใช้ข้อมูลจากอินพุทเลเยอร์ที่เชื่อมต่อเข้ามาเท่านั้น ซึ่งจะช่วยให้โมเดลสามารถจำข้อมูลที่ไม่มีลำดับได้ จะเก็บข้อมูลจากการประมวลผลของข้อมูลก่อนหน้า โดยจะมีการเชื่อมต่อกันระหว่างโนดในชั้นนี้เอง เพื่อให้สามารถจดจำและเรียนรู้ความสัมพันธ์ระหว่างข้อมูลได้ ซึ่งจะช่วยให้โมเดลสามารถจำข้อมูลลำดับได้ เช่น ข้อมูลที่มีลำดับการเกิดเช่น Time Series, Text, Audio เป็นต้น

  • Dense Hidden Layer
    เป็นชั้นที่มีโหนดแต่ละตัวเชื่อมต่อกันแบบแยกต่างหาก โดยโหนดแต่ละตัวจะไม่มีความสัมพันธ์กันโดยตรง เพียงแต่รับ Input เพื่อสร้าง Feature ใหม่โดยอิงจาก Input Layer และ Layer ก่อนหน้า ทุกๆ time step ของข้อมูลจะถูกส่งผ่านตัวประมวลผล Dense Hidden Layer ซึ่งเป็นชั้นซ่อนที่เป็น Fully Connected Layer ที่ทำหน้าที่คำนวณค่าในแต่ละ time step ด้วยคำสั่งเดียวกัน โดยใน Dense Hidden Layer จะประกอบไปด้วยโนด (node) หลายๆ โนดโดยแต่ละโนดจะมี weight และ bias เพื่อใช้ในการคำนวณเลเยอร์ถัดไป

3. Output Layer

เป็นชั้นสุดท้ายของโมเดลและจะแสดงผลลัพธ์ที่เป็นไปได้จากการทำนายของโมเดล โดยจำนวน Node ของชั้น Output Layer จะต้องเป็นไปตามจำนวนคลาสหรือประเภทข้อมูลที่ต้องการทำนาย เป็นชั้นที่ใช้ในการแปลงค่าผลลัพธ์จาก hidden state ในแต่ละ step ของ sequence ให้กลับมาเป็นรูปแบบที่เหมาะสมกับการทำนายผลลัพธ์ของโมเดล เช่น การแปลงค่า hidden state ให้กลับมาเป็นรูปแบบของโอกาสที่จะเป็นแต่ละ class หรือการทำนายค่าต่อไปของ sequence

Output Layer สำหรับงานที่เป็น Classification ส่วนใหญ่จะใช้ชั้น Dense Layer ที่มี activation function เป็น softmax เพื่อแปลงค่าความน่าจะเป็นของแต่ละ class ให้เป็นค่าความน่าจะเป็นที่รวมกันแล้วเท่ากับ 1 ซึ่งใช้สำหรับการคำนวณ cross-entropy loss

สำหรับงานที่เป็น Regression จะใช้ Dense Layer ที่ไม่มี activation function หรือมีเพียงฟังก์ชันเชิงเส้นเพื่อแปลงค่า hidden state ให้กลับมาเป็นผลลัพธ์ที่เหมาะสมกับงาน Regression

LSTM (Long Short-Term Memory)

เป็นอัลกอริทึมของ Recurrent Neural Network (RNN) ที่ถูกออกแบบมาเพื่อแก้ปัญหาการสูญเสียค่า gradient ในการทำ backpropagation ในโมเดล RNN ทั่วไป เนื่องจากโมเดล RNN มีโครงสร้างที่วนกลับและมีความลึก (deep) สูง ทำให้เกิดปัญหา gradient ที่หายไป (vanishing gradient) และ gradient ที่มากเกินไป (exploding gradient) ซึ่งทำให้โมเดลไม่สามารถเรียนรู้และปรับปรุงได้อย่างถูกต้อง

LSTM ใช้โครงสร้างของเซลล์ (cell) ในการเก็บความจำสำหรับข้อมูลก่อนหน้า (previous state) และจะนำข้อมูลเหล่านั้นมาใช้ในการประมวลผลข้อมูลใหม่ โดยมีการควบคุมการเข้าถึงข้อมูลที่เก็บไว้ในเซลล์ด้วย gate 3 ชนิด คือ input gate, forget gate และ output gate

1. Input gate
   ใช้สำหรับเลือกข้อมูลที่จะเข้าสู่เซลล์ โดยอ้างอิงจากข้อมูลใหม่ที่เข้ามาและข้อมูลก่อนหน้า (previous state) แล้วนำมาคำนวณให้ได้ค่า weight ในการเข้าถึงข้อมูลที่จะถูกนำมาประมวลผลในเซลล์
2. Forget gate
   ใช้สำหรับลบข้อมูลที่ไม่สำคัญออกจากเซลล์ โดยอ้างอิงจากข้อมูลใหม่ที่เข้ามาและข้อมูลก่อนหน้า (previous state) แล้วนำมาคำนวณให้ได้ค่า weight ในการลบข้อมูลที่ไม่สำคัญออกจากเซลล์
3. Output gate
   มีหน้าที่คำนวณ output ที่จะส่งออกมาจาก cell โดยใช้ค่าจาก hidden state และ cell state ในการคำนวณ โดย Output gate มีสถานะเปิด (open) หรือปิด (closed) ซึ่งถ้าเป็นสถานะเปิด output จะถูกสร้างขึ้นมาจาก hidden state และ cell state ที่ผ่านการปรับแต่งจาก Output gate ดังนั้น Output gate ช่วยให้ LSTM สามารถปรับ output ได้เหมาะสมกับแต่ละสถานการณ์ที่ต้องการโมเดลให้มีประสิทธิภาพสูงสุด

การใช้ Recurrent Neural Network (RNN) ใน Python

มีขั้นตอนลักษณะเดียวกับการใช้ Neural Network ปกติ โดยสามารถแบ่งเป็นขั้นตอนดังนี้:

1. การเตรียมข้อมูล:
   เพื่อเตรียมสำหรับการนำเข้าโมเดล RNN โดยการทำ feature engineering หรือ preprocessing ข้อมูล เช่น การแปลงข้อมูลให้เป็นรูปแบบที่เหมาะสมกับโมเดล RNN หรือการทำ one-hot encoding เป็นต้น

2. การสร้างโมเดล:
   กำหนดรูปแบบของโมเดล RNN ด้วยการกำหนดจำนวนของชั้นที่ต้องใช้ และตัวแปรสำคัญอื่น ๆ เช่น learning rate, batch size และ epochs

3. การคอมไพล์และเทรนโมเดล:
   การคอมไพล์โมเดล และเทรนโมเดลด้วยข้อมูลที่เตรียมไว้ โดยใช้ optimizer เพื่อปรับค่า weight และ bias ในแต่ละรอบการเทรน

4. การประเมินผล:
   การประเมินผลโมเดล RNN ด้วยข้อมูล test set เพื่อวัดประสิทธิภาพของโมเดล และปรับแก้ไขโมเดลต่อไป

โดยอาจมีขั้นตอนเพิ่มเติมในการปรับแก้ไขโมเดลหลังจากได้ทำการประเมินผล และในบางกรณีอาจต้องทำการ fine-tuning ด้วยการใช้ transfer learning หรือการใช้ pre-trained model ช่วยในการเพิ่มประสิทธิภาพของโมเดล

ตัวอย่าง Recurrent Neural Network (RNN)

import tensorflow as tf
from tensorflow.keras.layers import Dense, LSTM, Input
from tensorflow.keras.models import Model

# โหลดและเตรียมข้อมูล
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# กำหนดขนาดของภาพ
img_rows, img_cols = x_train.shape[1:]

# กำหนดค่า hyperparameters
num_classes = 10
num_epochs = 5
batch_size = 32

# สร้างโมเดล LSTM
inputs = Input(shape=(img_rows, img_cols))
x = LSTM(128)(inputs)
x = Dense(64, activation='relu')(x)
outputs = Dense(num_classes, activation='softmax')(x)
model = Model(inputs=inputs, outputs=outputs)

# แสดงโครงสร้างของโมเดล
model.summary()

# คอมไพล์และเทรนโมเดล
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=batch_size,
          epochs=num_epochs, validation_data=(x_test, y_test))

# ประเมินประสิทธิภาพของโมเดล
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

จากตัวอย่าง ได้ใช้ Recurrent Neural Network (RNN) ในการจำแนกตัวเลขภาพดิจิตอลจากชุดข้อมูล MNIST โดยใช้โมเดล LSTM ซึ่งมีขั้นตอนดังนี้:

1. โหลดและเตรียมข้อมูล แบ่งข้อมูลออกเป็นชุด Train และ Test โดยมีขนาดเท่ากัน และทำการปรับค่าความสว่างของภาพดิจิตอลให้อยู่ในช่วง 0-1

2. กำหนด hyperparameters ในการเทรนโมเดล โดยมีค่าต่าง ๆ ดังนี้: จำนวนคลาสที่ต้องการจำแนก (num_classes), จำนวนรอบการเทรนโมเดล (num_epochs), และขนาดของ batch ในการเทรน (batch_size)

3. สร้างโมเดล LSTM โดยกำหนด Input Layer เป็นขนาดของภาพดิจิตอล (img_rows, img_cols) และใช้ LSTM layer ที่มี 128 units ตามด้วย Dense Hidden Layer ที่มี 64 units และ Activation Function ใช้ ReLU และ Output Layer ที่มี จำนวน Units ตรงกับจำนวนคลาสที่ต้องการจำแนก และใช้ Activation Function ที่เป็น Softmax

4. คอมไพล์และเทรนโมเดล โดยใช้ categorical_crossentropy เป็น Loss Function และ optimizer เป็น adam รวมถึงการวัดประสิทธิภาพด้วย Accuracy

5. ประเมินประสิทธิภาพของโมเดล ด้วยการทดสอบบนชุด Test Data และแสดงผลการประเมินด้วย Test loss และ Test accuracy

ตัวอย่าง Recurrent Neural Network (RNN) ที่นำมาใช้กับข้อมูล Covid-19 ที่เป็นไฟล์ CSV โดยมีการใช้งานไลบรารี TensorFlow 2.x และ Pandas โดยมีไฟล์ตัวอย่าง covid19_data.csv มีข้อมูลดังนี้

SNo,ObservationDate,Province/State,Country/Region,Last Update,Confirmed,Deaths,Recovered
1,01/22/2020,"Anhui",Mainland China,1/22/2020 17:00,1,0,0
2,01/22/2020,"Beijing",Mainland China,1/22/2020 17:00,14,0,0
3,01/22/2020,"Chongqing",Mainland China,1/22/2020 17:00,6,0,0
4,01/22/2020,"Fujian",Mainland China,1/22/2020 17:00,1,0,0
5,01/22/2020,"Gansu",Mainland China,1/22/2020 17:00,0,0,0
6,01/22/2020,"Guangdong",Mainland China,1/22/2020 17:00,26,0,0
7,01/22/2020,"Guangxi",Mainland China,1/22/2020 17:00,2,0,0
8,01/22/2020,"Guizhou",Mainland China,1/22/2020 17:00,1,0,0
9,01/22/2020,"Hainan",Mainland China,1/22/2020 17:00,4,0,0
10,01/22/2020,"Hebei",Mainland China,1/22/2020 17:00,1,0,0
11,01/22/2020,"Heilongjiang",Mainland China,1/22/2020 17:00,0,0,0
12,01/22/2020,"Henan",Mainland China,1/22/2020 17:00,5,0,0
13,01/22/2020,"Hong Kong",Hong Kong,1/22/2020 17:00,0,0,0
14,01/22/2020,"Hubei",Mainland China,1/22/2020 17:00,444,17,28
15,01/22/2020,"Hunan",Mainland China,1/22/2020 17:00,4,0,0
16,01/22/2020,"Inner Mongolia",Mainland China,1/22/2020 17:00,0,0,0
17,01/22/2020,"Jiangsu",Mainland China,1/22/2020 17:00,1,0,0
18,01/22/2020,"Jiangxi",Mainland China,1/22/2020 17:00,2,0,0
19,01/22/2020,"Jilin",Mainland China,1/22/2020 17:00,0,0,0
20,01/22/2020,"Liaoning",Mainland China,1/22/2020 17:00,2,0,0
.
.
.

สามารถเขียนโค้ดได้ดังนี้

import pandas as pd
import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Dense, LSTM, Input
from tensorflow.keras.models import Model
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler

# โหลดไฟล์ CSV
data = pd.read_csv('covid19_data.csv')

# ลบคอลัมน์ที่ไม่จำเป็น
data.drop(['SNo', 'ObservationDate'], axis=1, inplace=True)

# แปลงวันที่ให้กลายเป็นระยะเวลาที่ผ่านไปเป็นจำนวนวัน
data['Date'] = pd.to_datetime(data['Date'])
data['Date'] = (data['Date'] - data['Date'].min()).dt.days

# กำหนดขนาดของชุดข้อมูลสำหรับการทดสอบ
test_size = 0.2

# แบ่งชุดข้อมูลเป็นชุดฝึกฝนและชุดทดสอบ
train, test = train_test_split(data, test_size=test_size)

# กำหนดค่า hyperparameters
num_features = train.shape[1] - 1
num_units = 64
num_epochs = 100
batch_size = 32

# ปรับขนาดข้อมูลเพื่อให้อยู่ในช่วง [0, 1]
scaler = MinMaxScaler()
train_scaled = scaler.fit_transform(train)
test_scaled = scaler.transform(test)

# แบ่งชุดข้อมูลเป็น X_train, Y_train, X_test, Y_test
def create_dataset(X, y, time_steps=1):
    Xs, ys = [], []
    for i in range(len(X) - time_steps):
        Xs.append(X[i:(i + time_steps), :])
        ys.append(y[i + time_steps])
    return np.array(Xs), np.array(ys)

time_steps = 7
X_train, y_train = create_dataset(train_scaled, train_scaled[:, 0], time_steps)
X_test, y_test = create_dataset(test_scaled, test_scaled[:, 0], time_steps)

# สร้างโมเดล LSTM
inputs = Input(shape=(time_steps, num_features))
x = LSTM(num_units)(inputs)
x = Dense(num_units, activation='relu')(x)
outputs = Dense(1, activation='linear')(x)
model = Model(inputs=inputs, outputs=outputs)

# แสดงโครงสร้างของโมเดล
model.summary()

# คอมไพล์และเทรนโมเดล
model.compile(optimizer='adam', loss='mean_squared_error')
model.fit(X_train, y_train, epochs=num_epochs, batch_size=batch_size)

# ทำนายผลลัพธ์ของชุดข้อมูลทดสอบ
y_pred = model.predict(X_test)

# แปลงข้อมูลที่ถูกปรับค่าแล้วกลับมาเป็นข้อมูลเดิม
y_pred = scaler.inverse_transform(np.concatenate((y_pred, X_test[:, -1, 1:]), axis=1))[:, 0]

# แปลงผลลัพธ์ของ Y_test เพื่อให้อยู่ในรูปแบบเดียวกับ y_pred
y_test = scaler.inverse_transform(np.concatenate((y_test.reshape(-1, 1), X_test[:, -1, 1:]), axis=1))[:, 0]

# คำนวณค่า MAPE (Mean Absolute Percentage Error)
mape = np.mean(np.abs((y_test - y_pred) / y_test)) * 100
print('MAPE: {:.2f}%'.format(mape))

# แสดงกราฟผลลัพธ์การทำนาย
import matplotlib.pyplot as plt
plt.plot(y_test, label='True')
plt.plot(y_pred, label='Predicted')
plt.legend()
plt.show()

จากตัวอย่าง เป็นการสร้างโมเดล เพื่อทำนายจำนวนผู้ติดเชื้อ COVID-19 โดยใช้ข้อมูลจากไฟล์ CSV ซึ่งมีการทำ preprocessing ข้อมูลดังนี้

ตัวอย่าง  Recurrent Neural Network (RNN) แบบ LSTM ด้วย TensorFlow 2 สำหรับการทำนายราคาสูงสุดของรุ่นรถยนต์แต่ละแบรนด์ โดยดึงข้อมูลจาก car_prices.csv ที่จะมีรายละเอียดดังนี้

• มีข้อมูลราคาสูงสุดของรถยนต์ของแต่ละแบรนด์ในแต่ละเดือน ปี 2018-2019

• ประกอบด้วยคอลัมน์ดังต่อไปนี้:

  • brand: ชื่อแบรนด์รถยนต์
  • model: ชื่อรุ่นรถยนต์
  • date: วันที่ (รูปแบบ: yyyy-mm-dd)
  • max_price: ราคาสูงสุดของรถยนต์ในเดือนนั้น

ตัวอย่างข้อมูล car_prices.csv:

brand,model,date,max_price
Toyota,Yaris,2018-01-01,700000
Toyota,Yaris,2018-02-01,710000
Toyota,Yaris,2018-03-01,720000
Toyota,Yaris,2018-04-01,730000
Toyota,Yaris,2018-05-01,740000
Toyota,Yaris,2018-06-01,750000
Toyota,Yaris,2018-07-01,760000
Toyota,Yaris,2018-08-01,770000
Toyota,Yaris,2018-09-01,780000
Toyota,Yaris,2018-10-01,790000
Toyota,Yaris,2018-11-01,800000
Toyota,Yaris,2018-12-01,810000
Toyota,Yaris,2019-01-01,820000
Toyota,Yaris,2019-02-01,830000
Toyota,Yaris,2019-03-01,840000
Toyota,Yaris,2019-04-01,850000
Toyota,Yaris,2019-05-01,860000
Toyota,Yaris,2019-06-01,870000
Toyota,Yaris,2019-07-01,880000
Toyota,Yaris,2019-08-01,890000
Toyota,Yaris,2019-09-01,900000
Toyota,Yaris,2019-10-01,910000
Toyota,Yaris,2019-11-01,920000
Toyota,Yaris,2019-12-01,930000
Honda,City,2018-01-01,800000
Honda,City,2018-02-01,810000
Honda,City,2018-03-01,820000
Honda,City,2018-04-01,830000
Honda,City,2018-05-01,840000
Honda,City,2018-06-01,850000
Honda,City,2018-07-01,860000
Honda,City,2018-08-01,870000
Honda,City,2018-09-01,880000
Honda,City,2018-10-01,890000
Honda,City,2018-11-01,900000
.
.
.

สามารถเขียนโค้ดได้ดังนี้

import pandas as pd
import numpy as np
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
import matplotlib.pyplot as plt

# 1. Load data
df = pd.read_csv('car_prices.csv', parse_dates=['Date'])

# 2. Drop unnecessary columns
df = df.drop(columns=['Brand', 'Model', 'Price'])

# 3. Convert date to number of days
df['Date'] = (df['Date'] - df['Date'].min()).dt.days

# 4. Split data into training and testing sets
train_size = int(len(df) * 0.8)
train_data = df.iloc[:train_size].values
test_data = df.iloc[train_size:].values

# 5. Scale data to range [0, 1]
scaler = MinMaxScaler()
train_data = scaler.fit_transform(train_data)
test_data = scaler.transform(test_data)

# 6. Prepare training and testing data
time_steps = 12 # number of frames in each input sequence
X_train, Y_train = [], []
for i in range(time_steps, len(train_data)):
    X_train.append(train_data[i-time_steps:i])
    Y_train.append(train_data[i][0])
X_train, Y_train = np.array(X_train), np.array(Y_train)

X_test, Y_test = [], []
for i in range(time_steps, len(test_data)):
    X_test.append(test_data[i-time_steps:i])
    Y_test.append(test_data[i][0])
X_test, Y_test = np.array(X_test), np.array(Y_test)

# 7. Create LSTM model
model = tf.keras.models.Sequential([
    tf.keras.layers.LSTM(units=64, return_sequences=True, input_shape=(time_steps, 1)),
    tf.keras.layers.LSTM(units=32, return_sequences=True),
    tf.keras.layers.LSTM(units=16),
    tf.keras.layers.Dense(units=1)
])

# 8. Compile and train model
model.compile(optimizer='adam', loss='mean_squared_error')
history = model.fit(X_train, Y_train, epochs=100, batch_size=32)

# 9. Predict test data
y_pred = model.predict(X_test)

# 10. Inverse scaling of data
y_pred = scaler.inverse_transform(np.concatenate((y_pred, np.zeros((len(y_pred), 2))), axis=1))[:, 0]
Y_test = scaler.inverse_transform(np.concatenate((Y_test.reshape(-1, 1), np.zeros((len(Y_test), 2))), axis=1))[:, 0]

# 11. Calculate MAPE
mape = np.mean(np.abs((Y_test - y_pred) / Y_test)) * 100

# 12. Plot results
plt.plot(Y_test, label='Actual')
plt.plot(y_pred, label='Predicted')
plt.xlabel('Time (months)')
plt.ylabel('Max price')
plt.title(f'MAPE: {mape:.2f}%')
plt.legend()
plt.show()

จากตัวอย่าง เป็นการสร้างและทดสอบโมเดล LSTM ในการทำนายราคาขายรถยนต์ โดยทำการแปลงวันที่เป็นจำนวนวันที่ผ่านไปตั้งแต่วันแรกของข้อมูล และทำการ scale ข้อมูลให้อยู่ในช่วง [0, 1] เพื่อให้โมเดลสามารถเรียนรู้และทำนายได้ดีขึ้น โมเดลที่สร้างมีการใช้ LSTM layer 3 layers ซึ่งเป็นโมเดลที่มีความซับซ้อนสูง และสามารถเรียนรู้ลักษณะแบบ sequence ได้ดี โมเดลถูก compile และ train ด้วย optimizer แบบ Adam และ loss function เป็น mean squared error (MSE) โดย train 100 epochs และใช้ batch size 32

จากนั้นทำการทดสอบโมเดลด้วยข้อมูลทดสอบและทำการ inverse scaling เพื่อเปลี่ยนค่าที่ scale กลับเป็นค่าเดิม จากนั้นคำนวณ MAPE (Mean Absolute Percentage Error) เพื่อวัดความคลาดเคลื่อนของโมเดล และ plot ผลลัพธ์ของการทดสอบโมเดลเปรียบเทียบกับค่าจริงในกราฟเพื่อให้เห็นภาพชัดเจนของผลลัพธ์

การสร้างและฝึกโมเดล LSTM (Long Short-Term Memory) ในการทำนายราคารถยนต์ของบริษัทหนึ่ง โดยใช้ข้อมูลเป็นชุดข้อมูลประวัติศาสตร์ของราคาตั้งแต่ปี 2000 ถึงปี 2019 โดยแต่ละชุดข้อมูลประกอบด้วยวันที่ (Date) และราคาสูงสุด (Max Price) ของรถยนต์ที่บริษัทนั้นขายในวันนั้น

โดยมีกระบวนการทำงานของโค้ดจะประกอบไปด้วยหลายขั้นตอนดังนี้

1. Load data: โหลดข้อมูลราคารถยนต์จากไฟล์ car_prices.csv โดยใช้ pandas.read_csv() เพื่ออ่านข้อมูลและแปลงข้อมูลวันที่เป็น datetime object ด้วยคำสั่ง parse_dates=[‘Date’]

2. Drop unnecessary columns: ลบคอลัมน์ Brand, Model และ Price ที่ไม่จำเป็นออกจากข้อมูลด้วยคำสั่ง pandas.DataFrame.drop()

3. Convert date to number of days: แปลงวันที่ในคอลัมน์ Date ให้อยู่ในรูปของจำนวนวันนับตั้งแต่วันแรกของชุดข้อมูล ด้วยการลบวันแรกของชุดข้อมูลจากวันที่ปัจจุบันแล้วแปลงให้เป็นจำนวนวันด้วยคำสั่ง (df[‘Date’] – df[‘Date’].min()).dt.days

4. Split data into training and testing sets: แบ่งชุดข้อมูลเป็นชุดฝึกฝนและชุดทดสอบโดยกำหนด train_size ให้เป็น 80% ของข้อมูลและใช้ pandas.DataFrame.iloc() เพื่อแยกชุดข้อมูล

5. Scale data to range [0, 1]: ปรับข้อมูลให้อยู่ในช่วง [0, 1] โดยใช้ MinMaxScaler() จาก scikit-learn.preprocessing

6. Prepare training and testing data: จัดเตรียมข้อมูลสำหรับการฝึกฝนและทดสอบโมเดล LSTM โดยกำหนดความยาวของ sequence (หรือ time_steps) ที่จะนำเข้าโมเดล และสร้างชุดข้อมูลสำหรับการฝึกฝน (training set) และชุดข้อมูลสำหรับการทดสอบ (testing set) จากข้อมูลที่ถูก scale แล้ว

7. Create LSTM model: สร้างโมเดล LSTM ด้วย Keras โดยกำหนดจำนวน unit และชนิดของ layer ต่าง ๆ เช่น LSTM และ Dense ที่จะนำมาใช้ในการสร้างโมเดล LSTM

8. Compile and train model: กำหนด optimizer และ loss function และฝึกฝนโมเดล LSTM ด้วยชุดข้อมูลที่จัดเตรียมไว้ จากนั้นนับจำนวนรอบการฝึกฝน (epochs) และกำหนดขนาดของชุดข้อมูลที่จะนำมาฝึกฝน (batch_size)

9. Predict test data: ทำนายค่าผลลัพธ์จากโมเดล LSTM ด้วยชุดข้อมูลสำหรับการทดสอบ

10. Inverse scaling of data: นำค่าผลลัพธ์ที่ได้จากการทำนายกลับมาเป็น scale ต้นฉบับโดยใช้ MinMaxScaler().inverse_transform()

11. Calculate MAPE: คำนวณค่า MAPE (Mean Absolute Percentage Error) เพื่อวัดความคลาดเคลื่อนของโมเดล LSTM โดยใช้สูตร (|actual-predicted|/actual)*100

12. Plot results: พล็อตกราฟเปรียบเทียบผลลัพธ์จากการทำนายกับผลลัพธ์จริง