การใช้ Transfer Learning ใน Deep Learning

Transfer Learning เป็นเทคนิคหนึ่งใน Deep Learning ที่ช่วยให้เราสามารถนำโมเดล (model) ที่ได้ถูกสร้างแล้วมาใช้ในการแก้ปัญหาที่แตกต่างกันได้ โดยไม่ต้องสร้างโมเดลใหม่ตั้งแต่เริ่มต้น

การสร้างโมเดลใน Deep Learning มักจะใช้ข้อมูลจำนวนมากในการเรียนรู้ และการเทรนโมเดลจะใช้เวลาและทรัพยากรมาก ๆ เช่นกัน ดังนั้นเมื่อต้องการสร้างโมเดลสำหรับแก้ไขปัญหาใหม่ โดยมีข้อมูลน้อยกว่า หรือไม่เพียงพอสำหรับการเทรนโมเดลใหม่ การสร้างโมเดลใหม่จากศูนย์อาจจะไม่ได้ผล หรือเราอาจจะต้องใช้เวลาและทรัพยากรมากมายในการเรียนรู้และเทรนโมเดลใหม่เพื่อให้มีความแม่นยำในการแก้ไขปัญหา

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

วิธีการใช้ Transfer Learning มีหลายวิธี ซึ่งเราจะแบ่งออกเป็นสามขั้นตอนหลักๆ ดังนี้

1. โหลดโมเดล pre-trained
   โหลดโมเดล Deep Learning ที่ฝึกด้วยชุดข้อมูลใหญ่ที่มีโมเดลสำเร็จรูปแล้ว เช่น VGG, ResNet, Inception, MobileNet ฯลฯ

2. จัดการข้อมูล
   ปรับปรุงข้อมูลในชุดข้อมูลเล็กให้เข้ากับโมเดล pre-trained เช่น ปรับขนาดรูปภาพ, ปรับรูปแบบของชุดข้อมูล และแปลง target เป็นรูปแบบ One-Hot Encoding

3. สร้างโมเดลใหม่
   สร้างโมเดลใหม่โดยใช้โมเดล pre-trained เป็นชุดฝึก และเพิ่มชั้น Fully Connected Layer ด้านบนของโมเดล pre-trained สำหรับการจัดหมวดหมู่หรือทำนาย

สำหรับ Transfer Learning นี้ จะช่วยลดเวลาในการฝึกโมเดลและทำให้ได้ผลลัพธ์ที่ดีขึ้น โดยเฉพาะเมื่อเรามีชุดข้อมูลที่มีขนาดเล็ก และต้องการจัดหมวดหมู่หรือทำนายบนชุดข้อมูลนั้น ๆ โดยทั่วไป Transfer Learning นี้จะใช้กับงาน Computer Vision หรือ การประมวลผลภาพ

Transfer Learning มักถูกใช้งานในการสร้างโมเดล Deep Learning ที่มีประสิทธิภาพสูงด้วยการนำโมเดลที่ถูกฝึกสอนไว้แล้ว (pre-trained model) มาใช้ในงานอื่นๆ โดยไม่ต้องฝึกสอนตั้งแต่เริ่มต้นใหม่ทั้งหมด โมเดลที่ถูกฝึกสอนไว้แล้วนั้นมักเป็นโมเดลที่มีขนาดใหญ่และมีความซับซ้อน ซึ่งการฝึกสอนใหม่ใช้เวลาและทรัพยากรมากกว่าการนำโมเดลที่ถูกฝึกสอนไว้แล้วมาใช้งานต่อ

ตัวอย่างของโมเดลที่ถูกฝึกสอนไว้แล้วที่นิยมใช้งานใน Transfer Learning ได้แก่โมเดลที่ได้รับการฝึกสอนด้วยชุดข้อมูล ImageNet ซึ่งเป็นชุดข้อมูลขนาดใหญ่ที่มีภาพถ่ายจำนวนมากที่ถูกแบ่งออกเป็นหลายๆ ประเภทของวัตถุ การฝึกสอนโมเดลด้วยชุดข้อมูล ImageNet นั้นมักใช้โมเดล Convolutional Neural Network (CNN) ที่มีความลึก (depth) มาก อย่างเช่น VGG, ResNet, Inception ฯลฯ

วิธีการใช้ Transfer Learning มีหลายวิธี แต่วิธีที่ง่ายที่สุดคือการนำ pre-trained model มาใช้งานในงานที่ต้องการ โดยไม่ต้องทำการปรับปรุงหรือเพิ่มเติมชั้นใหม่ให้กับโมเดล ในกรณีที่ข้อมูลที่ต้องการนำมาใช้งานต่อมีความเหมือนหรือใกล้เคียงกับชุดข้อมูลที่ใช้ฝึก

ข้อดีของการใช้ Transfer Learning มีดังนี้

1. ลดเวลาในการฝึกโมเดล
   โมเดลที่มีประสิทธิภาพสูงในการแก้ปัญหาที่คล้ายคลึงกันมักมีขนาดใหญ่และค่อนข้างซับซ้อน ดังนั้นการฝึกโมเดลใหม่ตั้งแต่ต้นอาจใช้เวลานานและเป็นการใช้ทรัพยากรของเครื่องมากกว่าที่จะใช้ Transfer Learning แทน โมเดล Deep Learning ใช้เวลาในการฝึกมากถึงหลายวันหรือหลายสัปดาห์ในกรณีที่มีข้อมูลใหญ่ ๆ โมเดลที่ฝึกด้วย Transfer Learning สามารถลดเวลาและค่าใช้จ่ายในการฝึกได้เพราะว่าเราสามารถใช้โมเดลที่ได้ฝึกไว้แล้วและทำงานได้ดีกับข้อมูลที่คล้ายกันมาใช้เป็นพื้นฐานของโมเดลใหม่ เนื่องจากเราสามารถใช้โมเดลที่ถูกฝึกก่อนมาแล้วและมีความแม่นยำสูง เพื่อเรียนรู้แนวโน้มของข้อมูลที่ต้องการจากชุดข้อมูลใหม่ได้เลย ซึ่งทำให้เราไม่ต้องเสียเวลาในการฝึกโมเดลใหม่ตั้งแต่เริ่มต้น และสามารถลดเวลาในการฝึกจนถึง 90% ของเวลาที่ใช้กับการฝึกโมเดลใหม่ได้

2. ลดจำนวนข้อมูลที่ต้องใช้ในการฝึกโมเดล
   การฝึกโมเดลใหม่ตั้งแต่ต้นอาจต้องใช้จำนวนข้อมูลที่มากกว่าเพื่อให้โมเดลสามารถเรียนรู้และสามารถทำนายได้อย่างแม่นยำ แต่ในการใช้ Transfer Learning จะใช้โมเดลที่ถูกฝึกไว้แล้วจึงไม่จำเป็นต้องใช้จำนวนข้อมูลที่มากเท่านั้น การฝึกโมเดลใหม่อาจต้องใช้จำนวนข้อมูลที่มากกว่าการใช้ Transfer Learning เนื่องจากโมเดลที่ใช้ใน Transfer Learning นั้นได้ถูกฝึกกับชุดข้อมูลใหญ่มาก่อนแล้ว และมีความสามารถในการแยกแยะและค้นหาลักษณะของข้อมูลที่ซับซ้อนได้ดีกว่าโมเดลที่ฝึกใหม่ ดังนั้นการใช้ Transfer Learning สามารถลดจำนวนข้อมูลที่ต้องใช้ในการฝึกโมเดลใหม่ได้เป็นอย่างมาก

3. ช่วยในการป้องกัน Overfitting
   การฝึกโมเดลใหม่ตั้งแต่ต้นอาจทำให้เกิด Overfitting ได้ง่าย เนื่องจากจำนวนข้อมูลที่มีไม่เพียงพอเพื่อให้โมเดลสามารถเรียนรู้และสามารถทำนายได้อย่างแม่นยำ แต่ในการใช้ Transfer Learning โมเดลที่ถูกฝึกไว้แล้วมักมีขนาดใหญ่และเรียนรู้ได้ดีจึงช่วยลดความเสี่ยงในการเกิด Overfitting ลง

4. ประหยัดทรัพยากร
   การฝึกโมเดลใหม่ตั้งแต่ต้นอาจต้องใช้ทรัพยากรของเครื่องมากกว่าปกติ การฝึกโมเดล Deep Learning สำหรับงานที่มีข้อมูลใหญ่ ๆ ต้องใช้ทรัพยากรมากมาย เช่น ฮาร์ดแวร์ที่มี GPU หรือ TPU เพื่อให้การฝึกเร็วขึ้น การใช้ Transfer Learning สามารถประหยัดทรัพยากรได้เพราะไม่ต้องใช้การคำนวณฝึกโมเดลใหม่ทั้งหมด  เนื่องจากมันต้องการการเรียนรู้จากข้อมูลมหาศาล การใช้ Transfer Learning จะช่วยลดเวลาและทรัพยากรที่ใช้ในการสร้างโมเดลใหม่โดยการนำโมเดลที่เรียนรู้แล้วมาใช้ให้กับงานใหม่

5. ปรับปรุงความแม่นยำ
   การใช้ Transfer Learning สามารถช่วยปรับปรุงความแม่นยำของโมเดลใหม่ได้ ด้วยเหตุผลว่าโมเดลต้นแบบที่เรานำมาใช้มีความแม่นยำสูงและถูกฝึกด้วยข้อมูลที่มีความหลากหลาย การนำเอาโมเดลต้นแบบมาใช้จะช่วยให้โมเดลใหม่มีความแม่นยำเพิ่มขึ้นเมื่อเทียบกับการฝึกโมเดลใหม่จากศูนย์ ซึ่งโมเดล Deep Learning ที่ได้รับการสร้างโดยใช้ Transfer Learning มีโอกาสที่จะมีประสิทธิภาพที่ดีกว่าโมเดลที่สร้างใหม่โดยตรง เนื่องจากมีการเรียนรู้จากข้อมูลมาก่อนแล้ว และมีความสามารถในการแยกแยะวัตถุที่ดีกว่า

6. ประหยัดค่าใช้จ่าย
   การสร้างโมเดล Deep Learning ใหม่สำหรับงานใหม่ๆ จะมีค่าใช้จ่ายสูง โดยเฉพาะในกรณีที่ต้องมีการซื้อฮาร์ดแวร์ที่จะรองรับการสร้างโมเดล แต่การใช้ Transfer Learning จะลดค่าใช้จ่ายลงอย่างมาก เนื่องจากมีโมเดลพร้อมใช้งานอยู่แล้ว

การใช้ Transfer Learning ใน Deep Learning

ประกอบไปด้วยขั้นตอนต่อไปนี้

1. เลือกโมเดลที่เหมาะสม
   ต้องเลือกโมเดลที่มีความเหมาะสมกับงานที่ต้องการ โดยที่โมเดลนั้นจะถูกสร้างขึ้นมาเพื่อแก้ไขปัญหาในงานที่คล้ายคลึงกัน

2. ทำการโหลด Pre-trained Model
   สำหรับ Transfer Learning เราจะใช้โมเดลที่มีการ Pre-trained กับข้อมูลในงานใดก็ตาม เพื่อเราจะได้ไม่ต้องฝึกโมเดลใหม่ตั้งแต่ต้น ซึ่งจะช่วยประหยัดเวลาและทรัพยากรการคำนวณ

3. ปรับปรุงโมเดล
   ปรับปรุงโมเดลให้เหมาะสมกับงานที่ต้องการ โดยที่ไม่ต้องเรียนรู้ตั้งแต่ต้น เช่น การปรับเปลี่ยนชั้น fully connected layer เพื่อเข้ากับปัญหาที่ต้องการ และ/หรือการปรับค่า Hyperparameters ต่างๆ

4. Fine-tuning
   หลังจากปรับปรุงโมเดลให้เหมาะสมแล้ว ให้ทำการ fine-tuning โมเดลด้วยการเรียนรู้จากข้อมูลใหม่เพื่อให้โมเดลมีความแม่นยำต่องานใหม่

5. ทดสอบโมเดล
   ทดสอบโมเดลด้วยข้อมูลทดสอบ เพื่อวัดประสิทธิภาพของโมเดล

6. ปรับปรุงและทดสอบ
   หากโมเดลยังไม่ได้ให้ผลลัพธ์ที่ต้องการ ให้ทำการปรับปรุงและทดสอบโมเดลเพิ่มเติมจนกว่าจะได้ผลลัพธ์ที่น่าพอใจ

การใช้ Transfer Learning ใน Deep Learning ด้วย Python สามารถทำได้โดยใช้ไลบรารี Keras ซึ่งเป็นไลบรารีสำหรับการสร้างและฝึกโมเดล Deep Learning ได้อย่างรวดเร็วและง่ายดาย โดยสามารถใช้โมเดลที่ถูกฝึกเรียบร้อยแล้วและมีความสามารถในการแยกแยะภาพในแบบต่างๆ มาใช้เป็นพื้นฐานสำหรับโมเดลใหม่ที่ต้องการสร้างขึ้นมาใหม่ โดยมีขั้นตอนการทำดังนี้

1. โหลดโมเดลพร้อมนำเข้าชุดข้อมูล
   ในขั้นตอนนี้เราจะโหลดโมเดลที่ต้องการใช้ในการ transfer learning มาใช้ พร้อมกับนำเข้าชุดข้อมูลที่ต้องการใช้ในการ train โมเดลใหม่ เช่น จากตัวอย่างเช่นการโหลดโมเดล VGG16 พร้อมกับนำเข้าชุดข้อมูลดอกไม้ iris มาใช้งาน

2. ปรับปรุงโมเดล
   ในขั้นตอนนี้เราจะปรับปรุงโมเดลที่โหลดมาให้เหมาะสมกับงานที่ต้องการ โดยการปรับปรุงนั้นสามารถทำได้หลากหลายวิธี เช่น การปรับแต่งชั้น Fully Connected Layers, การเปลี่ยนแปลงชุดข้อมูลที่นำเข้า, การปรับแต่ง Hyperparameters เป็นต้น โดยในตัวอย่างนี้จะทำการแก้ไขชั้น Fully Connected Layers เพื่อให้เหมาะสมกับงานด้านการจำแนกหมวดหมู่ดอกไม้

3. Train โมเดล
   ในขั้นตอนสุดท้ายเราจะ train โมเดลใหม่ด้วยชุดข้อมูลที่เราได้เตรียมไว้ โดยในขั้นตอนนี้จะเน้นให้ train เพียงชั้น Fully Connected Layers เท่านั้น โดยส่วนอื่นๆ ที่มากับโมเดลต้นฉบับจะถูกเรียนรู้แล้ว จากนั้นจึงทำการประเมินความแม่นยำของโมเดลที่ได้จากการ train โดยใช้ชุดข้อมูลทดสอบ

ตัวอย่าง การใช้ Transfer Learning ใน Deep Learning ด้วย Keras ดังนี้

from keras.applications import VGG16
from keras.models import Model
from keras.layers import Dense, Flatten
from keras.preprocessing.image import ImageDataGenerator

# โหลดโมเดล VGG16 ที่ถูก train แล้วจากฐานข้อมูล ImageNet
vgg16_base = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# เพิ่มชั้น FC (Fully Connected) ด้านบนของโมเดล VGG16
x = vgg16_base.output
x = Flatten()(x)
x = Dense(256, activation='relu')(x)
x = Dense(1, activation='sigmoid')(x)

# สร้างโมเดลใหม่โดยใช้โมเดล VGG16 เป็นโครงข่ายหลัก
model = Model(inputs=vgg16_base.input, outputs=x)

# ปิดการเรียนรู้กับชั้น CNN ของโมเดล VGG16 ในขั้นตอนการฝึกโมเดลใหม่
for layer in vgg16_base.layers:
    layer.trainable = False

# แปลงข้อมูลรูปภาพให้อยู่ในรูปแบบที่เหมาะสมสำหรับ VGG16
train_datagen = ImageDataGenerator(rescale=1./255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1./255)

# สร้างชุดข้อมูลสำหรับฝึกโมเดล
train_generator = train_datagen.flow_from_directory('train', target_size=(224, 224), batch_size=32, class_mode='binary')
validation_generator = test_datagen.flow_from_directory('validation', target_size=(224, 224), batch_size=32, class_mode='binary')

# ฝึกโมเดลใหม่โดยใช้ชุดข้อมูลที่สร้างขึ้นมา
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(train_generator, steps_per_epoch=2000, epochs=50, validation_data=validation_generator, validation_steps=800)

# บันทึกโมเดลที่ฝึกได้เพื่อนำไปใช้งาน
model.save('my_model.h5')

จากตัวอย่าง ในการสร้างโมเดล Convolutional Neural Network (CNN) โดยใช้โมเดล VGG16 ที่ถูก train แล้วจากฐานข้อมูล ImageNet เป็นโครงข่ายหลัก โดยโค้ดนี้จะเพิ่มชั้น Fully Connected (FC) ด้านบนของโมเดล VGG16 โดยปิดการเรียนรู้กับชั้น CNN ของโมเดล VGG16 ในขั้นตอนการฝึกโมเดลใหม่ เพื่อป้องกันไม่ให้การปรับค่าน้ำหนักของชั้น CNN ส่งผลกระทบต่อการเรียนรู้ของชั้น FC ด้านบน

โดยใช้ ImageDataGenerator เพื่อแปลงข้อมูลรูปภาพให้อยู่ในรูปแบบที่เหมาะสมสำหรับ VGG16 และสร้างชุดข้อมูลสำหรับฝึกโมเดล โดยกำหนด train_generator และ validation_generator ขึ้นมาจากโฟลเดอร์ ‘train’ และ ‘validation’ ตามลำดับ โดยกำหนด target_size ของรูปภาพเป็น (224, 224) และ batch_size เป็น 32

สำหรับการฝึกโมเดลใหม่จะใช้ optimizer เป็น adam และ loss function เป็น binary_crossentropy โดยกำหนดจำนวน epochs เท่ากับ 50 และใช้ข้อมูล validation ในการตรวจสอบความแม่นยำของโมเดล โดยโมเดลที่ฝึกได้จะถูกบันทึกเป็นไฟล์ ‘my_model.h5’ เพื่อนำไปใช้งานในอนาคต

การฝึกโมเดล VGG16 จบไปแล้ว ดังนั้นเราสามารถเขียนโค้ดเพื่อโหลดโมเดลที่ฝึกได้และนำมาใช้งานได้ดังนี้

from keras.models import load_model
from keras.preprocessing import image
import numpy as np

# โหลดโมเดลที่ฝึกไว้
model = load_model('my_model.h5')

# โหลดรูปภาพที่ต้องการทำนาย
img_path = 'test_image.jpg'
img = image.load_img(img_path, target_size=(224, 224))

# แปลงรูปภาพเป็น numpy array
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = x / 255.0

# ทำนายผลลัพธ์
prediction = model.predict(x)

if prediction < 0.5:
    print("This is a cat")
else:
    print("This is a dog")

โดยที่ test_image.jpg เป็นชื่อไฟล์รูปภาพที่ต้องการทำนาย ส่วนเงื่อนไขในการแสดงผลลัพธ์เป็นตัวอย่างเท่านั้น ขึ้นอยู่กับประเภทของโมเดลที่ใช้ฝึกด้วย

ตัวอย่าง การใช้ Transfer Learning ใน Deep Learning ด้วย RNN ต่อไปนี้

from keras.applications import VGG16
from keras.layers import Input, LSTM, Dense
from keras.models import Model
from keras.preprocessing.sequence import pad_sequences
import numpy as np

# โหลดโมเดล VGG16 ที่ถูก train แล้วจากฐานข้อมูล ImageNet
vgg16_base = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# สร้างชั้น Input สำหรับรับ sequence ของ feature vectors จาก VGG16
sequence_input = Input(shape=(None, 7, 7, 512))

# ใช้ LSTM เพื่อประมวลผล sequence ของ feature vectors
x = LSTM(256, return_sequences=True)(sequence_input)
x = LSTM(128)(x)
x = Dense(1, activation='sigmoid')(x)

# สร้างโมเดลใหม่โดยใช้โมเดล VGG16 เป็นโครงข่ายหลัก
model = Model(inputs=sequence_input, outputs=x)

# ปิดการเรียนรู้กับชั้น CNN ของโมเดล VGG16 ในขั้นตอนการฝึกโมเดลใหม่
for layer in vgg16_base.layers:
    layer.trainable = False

# กำหนดขนาด sequence และสร้างชุดข้อมูลสำหรับฝึกโมเดล
sequence_length = 10
train_data = np.random.random((100, sequence_length, 7, 7, 512))
train_labels = np.random.randint(0, 2, size=(100, 1))
train_data = pad_sequences(train_data, maxlen=sequence_length, padding='post', dtype='float32')

# ฝึกโมเดลใหม่โดยใช้ชุดข้อมูลที่สร้างขึ้นมา
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(train_data, train_labels, epochs=10, batch_size=32)

# บันทึกโมเดลที่ฝึกได้เพื่อนำไปใช้งาน
model.save('my_model.h5')

จากตัวอย่าง ได้ใช้โมเดล VGG16 ที่ถูก train แล้วจากฐานข้อมูล ImageNet ในการสกัด feature vectors จากรูปภาพ แล้วนำ feature vectors ที่ได้มาใช้เป็น input ของโมเดล RNN ที่ประมวลผล sequence

การใช้ Transfer Learning ใน Deep Learning ด้วย RNN โดยใช้โมเดล VGG16 ที่ถูก train แล้วจากฐานข้อมูล ImageNet ในการสกัด feature vectors ของภาพ และนำ feature vectors เหล่านี้มาฝึกโมเดล LSTM โดยการประมวลผล sequence ของ feature vectors เพื่อจำแนกภาพตามคลาสของภาพ โดยใช้ชุดข้อมูลที่สร้างขึ้นมาจาก numpy.random และ pad_sequences ใช้สำหรับจัดเรียง sequence ให้อยู่ในรูปแบบเดียวกัน โดยเป็นการเรียนรู้โดยใช้ optimizer=’adam’ และ loss=’binary_crossentropy’ และจำนวน epoch เท่ากับ 10 โดยสร้างโมเดลใหม่โดยใช้โมเดล VGG16 เป็นโครงข่ายหลัก และเก็บโมเดลที่ฝึกได้เป็นไฟล์ ‘my_model.h5’ เพื่อนำไปใช้งานต่อไปได้

เมื่อเราฝึกโมเดลและบันทึกโมเดลลงในไฟล์ my_model.h5 แล้ว เราสามารถโหลดโมเดลนี้เข้ามาใช้งานได้ดังนี้

from keras.models import load_model
import numpy as np

# โหลดโมเดลที่ฝึกได้
model = load_model('my_model.h5')

# สร้างข้อมูลสำหรับใช้ทดสอบโมเดล
test_data = np.random.random((10, 5, 7, 7, 512))
test_data = pad_sequences(test_data, maxlen=5, padding='post', dtype='float32')

# ใช้โมเดลที่ฝึกได้ทำนายผลลัพธ์
predictions = model.predict(test_data)

โดยจะโหลดโมเดลที่ฝึกได้จากไฟล์ my_model.h5 แล้วสร้างข้อมูลสำหรับใช้ทดสอบโมเดล ในตัวอย่างข้างบนจะใช้ข้อมูลทดสอบที่มีขนาด 10x5x7x7x512 และใช้โมเดลที่ฝึกได้ในการทำนายผลลัพธ์ โดยผลลัพธ์จะเป็นเมทริกซ์ขนาด 10×1 ซึ่งแต่ละคอลัมน์จะแทนความน่าจะเป็นของแต่ละตัวอย่างในชุดข้อมูลทดสอบที่จะมีค่าอยู่ระหว่าง 0 ถึง 1

ตัวอย่าง การใช้ Transfer Learning ใน Deep Learning ด้วย Deep Belief Network (DBN)

Deep Belief Network (DBN) เป็นโมเดล Deep Learning ที่ใช้กันอย่างแพร่หลาย ในตัวอย่างนี้เราจะใช้ Transfer Learning ด้วย DBN ในการจัดการกับปัญหาการจำแนกภาพ โดยใช้ชุดข้อมูล MNIST ซึ่งเป็นชุดข้อมูลภาพขนาดเล็กที่มีค่าความแม่นยำสูง

ก่อนที่จะเริ่มต้นใช้ DBN ในการฝึกโมเดล จำเป็นต้องติดตั้งโมดูล theano และ pylearn2 ก่อน โดยใช้คำสั่งต่อไปนี้

!pip install theano
!pip install pylearn2

การใช้ Transfer Learning ใน Deep Learning ด้วย Deep Belief Network (DBN) ดังนี้

import numpy as np
import theano
from theano import tensor as T
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import OneHotEncoder
from sklearn.datasets import fetch_mldata
from sklearn.model_selection import train_test_split
from pyll.utils import Timer

from pyll import dbn
from pyll.utils import shared_x

# โหลดชุดข้อมูล MNIST
mnist = fetch_mldata('MNIST original')
X = mnist.data.astype('float32') / 255.
y = mnist.target.astype('int32')
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# แปลง target ให้อยู่ในรูปแบบ One-Hot Encoding
enc = OneHotEncoder(sparse=False)
y_train_onehot = enc.fit_transform(y_train.reshape(-1, 1))
y_test_onehot = enc.transform(y_test.reshape(-1, 1))

# โหลดโมเดล pre-trained จาก DBN ที่ฝึกด้วยชุดข้อมูล MNIST
pretrained_dbn = dbn.DBN.load_from('mnist_dbn.pkl')

# ใช้โมเดล pre-trained เป็นการจัดการ feature ของภาพทั้งหมดในชุดข้อมูล
X_train_transformed = pretrained_dbn.transform(X_train)
X_test_transformed = pretrained_dbn.transform(X_test)

# สร้างโมเดลใหม่จาก feature vectors ที่ได้จากการใช้ DBN กับชุดข้อมูล MNIST
input_var = T.fmatrix('inputs')

จากตัวอย่าง การใช้ Transfer Learning ใน Deep Learning ด้วย Deep Belief Network (DBN) โดยใช้ชุดข้อมูล MNIST ในการฝึกและทดสอบโมเดล การทำงานของโค้ดจะทำการโหลดชุดข้อมูล MNIST และแปลง target ให้อยู่ในรูปแบบ One-Hot Encoding จากนั้นโหลดโมเดล pre-trained จาก DBN ที่ฝึกด้วยชุดข้อมูล MNIST และใช้โมเดล pre-trained เพื่อจัดการ feature ของภาพทั้งหมดในชุดข้อมูล โดยการใช้โมเดล pre-trained เป็น Transfer Learning ใน Deep Learning หลังจากนั้นโค้ดจะสร้างโมเดลใหม่จาก feature vectors ที่ได้จากการใช้ DBN กับชุดข้อมูล MNIST และใช้โมเดลใหม่นี้ในการทดสอบโดยใช้ accuracy_score เพื่อประเมินผลที่ได้จากการทำนายข้อมูลทดสอบ โดยใช้ชุดข้อมูล X_test_transformed และ y_test_onehot ซึ่งเป็น feature vectors และ target ที่ถูกแปลงไว้ล่วงหน้า สุดท้ายโค้ดจะแสดงผลลัพธ์ accuracy ที่ได้จากการทดสอบโมเดลใหม่นี้

เราสามารถโหลดโมเดลที่ฝึกด้วย DBN ได้โดยใช้ method load_from() ของคลาส DBN ใน pyll ดังนี้

pretrained_dbn = dbn.DBN.load_from('mnist_dbn.pkl')

โดย mnist_dbn.pkl เป็นไฟล์ที่เก็บโมเดลที่ฝึกด้วย DBN ก่อนหน้านี้ ซึ่งเราสามารถสร้างไฟล์นี้ได้จากการฝึกโมเดลด้วย DBN และบันทึกโมเดลลงเป็นไฟล์โดยใช้ method save() ของคลาส DBN ดังนี้

my_dbn = dbn.DBN(n_layers=[784, 500, 500, 2000], binary=[True, True, True, False])
my_dbn.fit(X_train, n_epochs=10, batch_size=100)
my_dbn.save('mnist_dbn.pkl')

หลังจากโหลดโมเดลเสร็จแล้ว เราสามารถใช้โมเดลนี้ในการจัดการ feature ของภาพทั้งหมดในชุดข้อมูล โดยใช้ method transform() ของ DBN ดังนี้

X_train_transformed = pretrained_dbn.transform(X_train)
X_test_transformed = pretrained_dbn.transform(X_test)

โดย X_train_transformed และ X_test_transformed จะเป็น feature vectors ที่ได้จากการใช้ DBN กับชุดข้อมูล MNIST แล้ว ซึ่งจะถูกนำไปใช้ในการฝึกโมเดลแบบ supervised ในขั้นตอนต่อไป