โครงข่ายความเชื่อเชิงลึก Deep Belief Network (DBN)

Deep Belief Network (DBN) เป็นโมเดลประสาทเทียมเชิงลึกที่ประกอบด้วยหลายๆ ชั้นของ Restricted Boltzmann Machines (RBM) โดยใช้การเรียนรู้อย่างไม่มีผู้ควบคุม (unsupervised learning) และมักถูกนำมาใช้ในงานประมวลผลภาพและวิดีโอ เช่น การจำแนกวัตถุในภาพ การแยกประเภทเสียง การจำแนกข้อความ และอื่นๆ

DBN เป็นโมเดลประสาทเทียมที่มีความซับซ้อนมากกว่า Feedforward Neural Network และ Recurrent Neural Network ด้วยการใช้งาน RBM หลายชั้น โดย RBM เป็นโมเดลประสาทเทียมเชิงลึกที่ใช้ในการเรียนรู้แบบไม่มีผู้ควบคุม (unsupervised learning) โดยมีโครงสร้างประกอบด้วยสองชั้นคือ visible layer และ hidden layer โดยที่แต่ละชั้นจะมีโหนดหลายๆ โหนด ซึ่ง RBM นี้จะมีการเชื่อมโยงระหว่างโหนดใน visible layer กับโหนดใน hidden layer โดยที่การเชื่อมโยงนี้จะมีน้ำหนักในการเชื่อมโยงแตกต่างกันไปตามการเรียนรู้ของโมเดล

DBN จะทำการ pre-train ก่อน โดยการเรียนรู้แบบ unsupervised ด้วย RBM แต่ละชั้น จากนั้นจึงทำการ fine-tune ด้วย supervised learning จนถึงขั้นตอนการทำนาย และการเรียนรู้แบบ unsupervised ใน DBN นี้จะช่วยให้สามารถเรียนรู้ลักษณะของข้อมูลได้ดีขึ้น

ถูกออกแบบมาเพื่อจำลองการเรียนรู้ของระบบประสาทเทียมที่มีการเรียนรู้แบบ “unsupervised” หรือไม่มีการใช้ข้อมูลผลลัพธ์เป็นตัวชี้วัดในการเรียนรู้ ซึ่ง DBN เป็นโมเดลประสาทเทียมที่ใช้การรวมร่วมของ Restricted Boltzmann Machines (RBM) หลายชั้นเข้าด้วยกัน โดย DBN จะมีชั้นแรกเป็น RBM แบบ visible layer ซึ่งเป็น input layer ของโมเดล และชั้นสุดท้ายเป็น RBM แบบ hidden layer ซึ่งมักจะใช้เป็น classifier ในงานที่เรียนรู้แบบ supervised

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

Deep Belief Network (DBN) เป็นโมเดลประสาทเทียมที่มีการเรียนรู้แบบจำลองเชิงลึก (deep generative model) โดยใช้การประมวลผลแบบไม่มีผู้สอน (unsupervised learning) โดยมีการเชื่อมต่อระหว่างชั้น (layer) โดยใช้แนวคิดของ Restricted Boltzmann Machine (RBM) และ Deep Autoencoder รูปแบบของ DBN ประกอบด้วยชั้น RBM หลายชั้นที่เชื่อมต่อกันเป็นอย่างละชั้นโดยตรง และสุดท้ายเป็นชั้นของ Deep Autoencoder

โครงสร้างของ DBN ประกอบด้วย

1. Input Layer:
   เป็นชั้นแรกมีหน้าที่รับข้อมูล input เข้ามา โดยทั่วไปจะมีจำนวน node เท่ากับจำนวน feature ของข้อมูล input ซึ่งแต่ละ node จะรับข้อมูล input เพียงค่าเดียวเท่านั้น และนำ input นั้นมาคูณกับ weight ของแต่ละ node และนำผลรวมทั้งหมดมาส่งต่อไปยัง hidden layer ต่อไป การรับ input จากข้อมูลแต่ละตัว โดย input จะเป็น vector ขนาด n ซึ่ง n คือจำนวน feature ของข้อมูล และจะมี neuron ใน input layer จำนวน n เท่ากับจำนวน feature ของข้อมูล แต่ละ neuron จะรับ input จาก feature เดียวกันของข้อมูลแต่ละตัว 
   
   Input layer จะไม่มีการคำนวณใด ๆ นอกจากการแปลงข้อมูล input เป็นค่า activation ของแต่ละ neuron ด้วยฟังก์ชัน activation ที่กำหนดไว้ ซึ่งฟังก์ชัน activation ที่ใช้กันอยู่บ่อยคือ Sigmoid function หรือ Rectified Linear Unit (ReLU) function ในบางกรณี การเลือกฟังก์ชัน activation ที่เหมาะสมจะช่วยให้โมเดลมีประสิทธิภาพในการเรียนรู้และทำนายดีขึ้นได้ โดยใน Deep Belief Network (DBN) จะมีการใช้ Restricted Boltzmann Machine (RBM) เป็น layer ถัดไปหลังจาก input layer ซึ่งจะช่วยในการเรียนรู้คุณลักษณะของข้อมูลได้อย่างมีประสิทธิภาพยิ่งขึ้น โดยจะมีการสร้าง RBM หลายๆ ชั้นเพื่อสร้าง Deep Belief Network (DBN) ในการเรียนรู้และทำนายข้อมูลอย่างมีประสิทธิภาพจากข้อมูล input ที่รับเข้ามา

2. Hidden Layer:
   เป็นชั้นที่เชื่อมต่อกับ input layer โดยใช้ RBM หลายชั้น โดยแต่ละชั้นจะเป็น RBM ที่เป็น unsupervised learning จะประกอบไปด้วย hidden layer หลายชั้น โดยแต่ละชั้นจะเป็น Restricted Boltzmann Machine (RBM) ที่เรียนรู้และแยกแยะลักษณะหรือแบบแผนการเรียนรู้ของข้อมูลที่เข้ามา

   ในแต่ละชั้น RBM จะมี node หลายๆ โหนด (node) ซึ่งแต่ละโหนดจะเป็นเลเยอร์ป้อนเข้า (input layer) และเลเยอร์ซ้อนกันอีกชั้นหนึ่ง (hidden layer) โดยมีการเชื่อมโยงกันแบบ full-connectivity ระหว่าง input layer กับ hidden layer ประกอบด้วยหลายๆ ชั้น (layers) โดยแต่ละชั้นจะประกอบไปด้วยหลายๆ โหนด (nodes) ซึ่งจะมีองค์ประกอบพื้นฐานที่สำคัญคือ Weight matrix (น้ำหนักเมทริกซ์) และ Bias vector (เวกเตอร์ไบอัส)

   โดย Hidden Layer ของ DBN จะถูกใช้ในการเรียนรู้ลักษณะของข้อมูลจาก input layer และแบบแผนการเรียนรู้ของข้อมูล ซึ่งจะถูกแยกแยะเป็นลักษณะพื้นฐาน (feature) ของข้อมูล และเป็นโมเดลประสาทเทียมที่มีความซับซ้อนมากขึ้นเรื่อยๆ จนกระทั่งเข้าสู่ output layer ซึ่งจะใช้ในการจำแนกหรือคาดคะเนผลลัพธ์ที่ต้องการ

   Hidden Layer ใน Deep Belief Network ประกอบด้วย 2 ชั้นหลัก ได้แก่ Restricted Boltzmann Machines (RBM) และ Autoencoder

   • Restricted Boltzmann Machines (RBM)
     RBM เป็นโมเดลประสาทเทียมชนิดหนึ่งที่สามารถเรียนรู้และทำนายข้อมูลได้ โดยมีโครงสร้างเป็นแบบ bipartite graph ที่ประกอบด้วย 2 ชั้น ได้แก่ Visible Layer และ Hidden Layer โดย Visible Layer เป็น input layer ของโมเดลและ Hidden Layer เป็น layer ที่ประกอบด้วยเซลล์ประสาทแต่ละเซลล์เชื่อมต่อกับเซลล์ใน Visible Layer

   โดย RBM นั้นสามารถทำการเรียนรู้โดยการปรับค่า weight และ bias โดยมีการเรียนรู้แบบ Unsupervised Learning ซึ่งหมายความว่าไม่ต้องมี label ในการเรียนรู้ และสามารถนำไปใช้ในการลดจำนวน Dimensionality ของข้อมูล หรือเพื่อการจัดกลุ่ม (Clustering) หรือแม้แต่ทำนายข้อมูล

   • Autoencoder
     เป็นโมเดลประสาทเทียมที่มีโครงสร้างคล้ายกับ RBM โดยมีชั้น Input Layer, Hidden Layer, และ Output Layer โดยจุดประสงค์ของ Autoencoder คือการเรียนรู้การเข้ารหัสข้อมูลใน Hidden Layer โดยที่ข้อมูล input จะถูกแปลงเป็นข้อมูลใน Hidden Layer โดยใช้ Neural Network และต่อมาจึงถูกถอดรหัสกลับเป็น Output Layer

   โดยจุดประสงค์ของการใช้ Autoencoder ใน Deep Belief Network นั้นเป็นการเป็นโมเดลประสาทเทียมที่มีความสามารถในการลด Dimensionality ของข้อมูล และเพิ่มความเป็น sparse ของข้อมูล (sparse representation)

3. Output Layer:
   เป็นชั้นที่ใช้ Deep Autoencoder สำหรับการเรียนรู้แบบ supervised learning โดยการปรับค่าน้ำหนักที่ได้จาก RBM แต่ละชั้นใน hidden layer สิ่งที่สำคัญในชั้นนี้ทำหน้าที่คำนวณผลลัพธ์เอาไว้ โดยใช้เทคนิคทางคณิตศาสตร์เช่น softmax หรือ logistic function ซึ่งช่วยในการแปลงค่าผลรวมของชั้นก่อนหน้านั้นให้อยู่ในรูปของความน่าจะเป็นที่แต่ละคลาส (class) จะเป็นผลลัพธ์ได้ เพื่อให้สามารถนำไปใช้งานได้ง่าย ยกตัวอย่างเช่นในงานจำแนกภาพ หากต้องการแยกประเภทของภาพเป็นหมวดหมู่ต่าง ๆ เช่น ภาพมนุษย์ ภาพสัตว์ เป็นต้น จะใช้ softmax function ในการคำนวณความน่าจะเป็นของแต่ละหมวดหมู่

   นอกจากนี้ Output Layer ของ DBN ยังสามารถใช้กับงานต่าง ๆ ได้ เช่น งานจำแนกเสียง เพื่อทำนายตัวพูดว่าเป็นเสียงของใคร งานจำแนกออกแบบ (design recognition) เพื่อทำนายรูปแบบที่จะได้รับความนิยมในอนาคต เป็นต้น

   องค์ประกอบของ Output Layer สามารถแบ่งออกได้เป็น 2 ประเภท คือ

   • Linear Output Layer
     จะไม่มีการใช้ฟังก์ชัน activation ใดๆ กำหนดให้ output มีค่าออกมาเป็น linear combination ของ input ของ layer นั้นๆ โดยมักนิยมใช้ในงาน regression หรือการคำนวณค่าต่างๆ เช่น ค่าพิกัดของวัตถุ

   • Non-linear Output Layer
     จะใช้ฟังก์ชัน activation เพื่อแปลงค่า linear combination ของ input ให้อยู่ในรูปแบบที่เหมาะสมกับงานที่ต้องการ ซึ่งฟังก์ชัน activation ที่นิยมใช้มีหลายแบบ เช่น sigmoid, softmax, ReLU และอื่นๆ ซึ่งแต่ละแบบจะเหมาะสมกับงานที่แตกต่างกันไป

   โดยทั่วไปแล้ว Output Layer ใน Deep Belief Network จะนิยมใช้ Non-linear Output Layer เพื่อให้สามารถจำแนกหรือทำนายได้ดีกว่า แต่ในบางกรณีที่ต้องการเพียงแค่คำนวณค่าต่างๆ จะนิยมใช้ Linear Output Layer ด้วย มีหน้าที่เป็นการแปลงข้อมูลจาก Hidden Layer ให้อยู่ในรูปแบบที่เหมาะสมสำหรับการใช้งาน เช่น การจำแนก (classification) หรือการทำนาย (prediction)

การใช้ Python ในการสร้างและใช้งาน Deep Belief Network

มีหลักการที่คล้ายคลึงกับการใช้ Python ในการสร้างและใช้งานโมเดลประสาทเทียมอื่น ๆ โดยมักจะใช้ไลบรารี TensorFlow, PyTorch หรือ Keras เป็นต้นเพื่อสร้างโมเดล Deep Belief Network ดังนั้นสิ่งที่ต้องทำตามขั้นตอน คือ

1. นำเข้าไลบรารีและโมดูลที่เกี่ยวข้อง เช่น tensorflow, keras, numpy เป็นต้น

import tensorflow as tf
import numpy as np

2. นิยามโมเดล Deep Belief Network โดยระบุจำนวนชั้นและจำนวนโหนดในแต่ละชั้น

model = tf.keras.Sequential([
    tf.keras.layers.Dense(256, activation='relu', input_shape=(input_dim,)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(output_dim, activation='softmax')
])

3. ระบุตัวแปรสำหรับการสร้างโมเดล Deep Belief Network โดยรวมถึงพารามิเตอร์ที่เกี่ยวข้อง เช่น ความลึกของแต่ละชั้น, จำนวนโหนดในแต่ละชั้น, อัลกอริทึมการเทรนโมเดล, จำนวนรอบการเทรนเป็นต้น

input_dim = 784
output_dim = 10
hidden_dim1 = 256
hidden_dim2 = 128
hidden_dim3 = 64

model = tf.keras.Sequential([
    tf.keras.layers.Dense(hidden_dim1, activation='relu', input_shape=(input_dim,)),
    tf.keras.layers.Dense(hidden_dim2, activation='relu'),
    tf.keras.layers.Dense(hidden_dim3, activation='relu'),
    tf.keras.layers.Dense(output_dim, activation='softmax')
])

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

4. นำเข้าชุดข้อมูลและปรับปรุงรูปแบบของข้อมูลตามความเหมาะสม เช่น การสเกลข้อมูล (Scaling), การแปลงข้อมูลให้อยู่ในรูปแบบที่เหมาะสมเพื่อนำมาใช้กับโมเดล เป็นต้น หลังจากได้รับชุดข้อมูลมาแล้ว การปรับปรุงรูปแบบของข้อมูลเป็นขั้นตอนที่สำคัญในการนำไปใช้กับโมเดล Deep Belief Network (DBN) โดยเฉพาะอย่างยิ่งในกระบวนการสร้างโมเดล DBN โดยปกติแล้วการปรับปรุงรูปแบบของข้อมูลมักจะเป็นการทำ scaling หรือ normalization เพื่อให้ข้อมูลมีค่าอยู่ในช่วงที่เหมาะสมกับโมเดลที่จะนำไปใช้ โดยใน Python เราสามารถทำ scaling หรือ normalization ด้วยการใช้โมดูลที่มีให้ใน scikit-learn.preprocessing เช่น MinMaxScaler, StandardScaler และอื่นๆ

การทำ scaling ด้วย MinMaxScaler

from sklearn.preprocessing import MinMaxScaler

# สร้าง object scaler
scaler = MinMaxScaler()

# ใช้ object scaler ปรับปรุงข้อมูลให้อยู่ในช่วง [0,1]
scaled_data = scaler.fit_transform(data)

หลังจากที่ได้ทำ scaling หรือ normalization เรียบร้อยแล้ว ข้อมูลจะเป็นรูปแบบที่เหมาะสมกับการนำไปใช้กับโมเดล Deep Belief Network (DBN) ซึ่งจะมีขั้นตอนต่อไปทำการสร้างโมเดลและเทรนโมเดลในขั้นตอนต่อไป

การทำ Scaling โดยใช้ MinMaxScaler() จาก scikit-learn.preprocessing

from sklearn.preprocessing import MinMaxScaler

# สร้าง MinMaxScaler object
scaler = MinMaxScaler()

# ทำการ scaling ข้อมูลโดยใช้ fit_transform กับข้อมูล train และ transform กับข้อมูล test
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

ข้างต้น X_train และ X_test คือชุดข้อมูลของ feature และ y_train และ y_test คือชุดข้อมูลของ label ของข้อมูลในการทำนาย

5. สร้างและฝึกโมเดล Deep Belief Network (DBN)

โดยใช้ไลบรารี Theano หรือ TensorFlow เพื่อเรียนรู้และสกัดลักษณะของข้อมูล หลังจากได้ทำการเตรียมข้อมูลเสร็จเรียบร้อยแล้ว ขั้นตอนต่อไปคือการสร้างและฝึกโมเดล Deep Belief Network (DBN) เพื่อให้โมเดลเรียนรู้และสกัดลักษณะของข้อมูลที่มีความซับซ้อน เพื่อนำไปใช้ในการทำนายหรือแยกประเภทข้อมูล

การสร้างและฝึกโมเดล DBN สามารถทำได้โดยใช้ไลบรารี Theano หรือ TensorFlow ซึ่งเป็นไลบรารีที่ใช้ในการคำนวณและสร้างโมเดล Deep Learning ต่าง ๆ อย่างแม่นยำและมีประสิทธิภาพสูง โดยการสร้างโมเดล DBN จะประกอบด้วยหลาย Hidden Layer โดยแต่ละ Hidden Layer จะมีจำนวนโหนด (node) และหน่วยประมวลผล (neuron) ที่แตกต่างกันไป และจะมี Output Layer ที่ใช้สำหรับทำนายหรือแยกประเภทข้อมูล

การฝึกโมเดล DBN จะใช้เทคนิคการเรียนรู้แบบ Unsupervised Learning ซึ่งจะสามารถสกัดลักษณะของข้อมูลเอง โดยใช้เทคนิคการสร้าง Model ที่มีลักษณะเป็น Deep Belief Network (DBN) ที่มีชั้น Hidden Layer หลายชั้น เพื่อทำการสกัดลักษณะของข้อมูลออกมาในแต่ละชั้น จากนั้นจึงทำการ Fine-tune โมเดลด้วยเทคนิคการเรียนรู้แบบ Supervised Learning

import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras import Sequential
from tensorflow.keras import initializers

class DBN:
    def __init__(self, input_dim=None, rbm_layers=None, output_dim=None, rbm_gibbs_k=None, rbm_epochs=None, rbm_batch_size=None, finetune_epochs=None, finetune_batch_size=None):
        self.input_dim = input_dim
        self.rbm_layers = rbm_layers
        self.output_dim = output_dim
        self.rbm_gibbs_k = rbm_gibbs_k
        self.rbm_epochs = rbm_epochs
        self.rbm_batch_size = rbm_batch_size
        self.finetune_epochs = finetune_epochs
        self.finetune_batch_size = finetune_batch_size
        self.rbm_weights = []
        self.rbm_biases = []
        self.autoencoder = None
        
    def fit(self, X, y=None):
        # Pretrain แต่ละ RBM layer
        prev_layer_input = X
        for i, n_components in enumerate(self.rbm_layers):
            rbm = RBM(n_components=n_components, gibbs_k=self.rbm_gibbs_k, epochs=self.rbm_epochs, batch_size=self.rbm_batch_size, verbose=0)
            rbm.fit(prev_layer_input)
            prev_layer_input = rbm.transform(prev_layer_input)
            self.rbm_weights.append(rbm.weights)
            self.rbm_biases.append(rbm.hidden_bias)
        
        # Build และ compile = autoencoder
        self.autoencoder = Sequential()
        for i, n_components in reversed(list(enumerate(self.rbm_layers))):
            if i == len(self.rbm_layers) - 1:
                self.autoencoder.add(Dense(n_components, input_shape=(self.input_dim,), activation='relu', name='encoder_%d' % i))
            else:
                self.autoencoder.add(Dense(n_components, activation='relu', name='encoder_%d' % i))
        for i, n_components in enumerate(self.rbm_layers):
            self.autoencoder.add(Dense(n_components, activation='relu', name='decoder_%d' % i))
        self.autoencoder.add(Dense(self.input_dim, activation='linear', name='decoder_output'))
        self.autoencoder.compile(loss='mse', optimizer='adam')
        
        # Set pretrained weights to autoencoder
        for i, layer in enumerate(self.autoencoder.layers[:len(self.rbm_layers)]):
            layer.set_weights([self.rbm_weights[-i - 1].T, self.rbm_biases[-i - 1]])
        
        # Fine-tune the autoencoder
        self.autoencoder.fit(X, X, epochs=self.finetune_epochs, batch_size=self.finetune_batch_size)
        
    def transform(self, X):
        h = tf.convert_to_tensor(X, dtype=tf.float32)
        for i, rbm in enumerate(self.rbm_layers):
            h = tf.nn.sigmoid(tf.matmul(h, self.rbm_weights[i]) + self.rbm_biases[i])
        return h
    
    def fit_transform(self, X, y=None):
        self.fit(X)
        return self.transform(X)

การสร้างคลาส DBN ที่ใช้ TensorFlow ในการสร้างและฝึก Deep Belief Network (DBN) ซึ่งเป็นโมเดลประเภท deep learning ที่สามารถสกัดลักษณะของข้อมูลได้

การสร้างคลาส DBN จะเริ่มต้นด้วยการกำหนดพารามิเตอร์ต่างๆ เช่น input_dim, rbm_layers, output_dim, rbm_gibbs_k, rbm_epochs, rbm_batch_size, finetune_epochs และ finetune_batch_size โดยทั้งหมดนี้จะใช้ในการกำหนดโครงสร้างและการฝึกโมเดล

โดยมีเมทอด fit ที่ใช้ในการฝึกโมเดลด้วยข้อมูล input X โดยการสร้างแต่ละ RBM layer และ pretrain โมเดลด้วย RBM โดยเก็บ weight และ bias ของแต่ละ RBM layer เพื่อนำไปใช้ในการ fine-tune โมเดล autoencoder ที่ถูกสร้างขึ้นด้วย Sequential โดยมีชั้น Dense สำหรับสร้าง encoder และ decoder และใช้ optimizer เป็น adam และ loss function เป็น mean squared error (MSE)

เมทอด transform ใช้ในการแปลงข้อมูล input X ด้วย pretrained RBM layers โดยใช้ activation function เป็น sigmoid และการคำนวณด้วยการคูณ weight กับ input และบวก bias

เมทอด fit_transform ใช้ในการฝึกโมเดลและสกัดลักษณะของข้อมูล input X ในขั้นตอนเดียวกันโดยการเรียกใช้เมทอด fit และ transform ตามลำดับ

6. แบ่งชุดข้อมูลเป็นชุด Train และ Test โดยใช้ฟังก์ชัน train_test_split() จาก scikit-learn.model_selection และกำหนด Test size เท่ากับ 0.2 (20% ของข้อมูล) สำหรับโมเดล Deep Belief Network (DBN):

import numpy as np
from sklearn.model_selection import train_test_split
from dbn import DBN # นำเข้าโมดูล DBN

# โหลดชุดข้อมูล (X) และตัวเป้าหมาย (y)
X = np.load('data.npy')
y = np.load('target.npy')

# แบ่งชุดข้อมูลเป็นชุด Train และ Test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# สร้างโมเดล DBN
dbn = DBN(input_dim=X_train.shape[1], rbm_layers=[512, 256], output_dim=10, 
          rbm_epochs=5, rbm_batch_size=32, finetune_epochs=100, finetune_batch_size=128)

# ฝึกโมเดลด้วยชุด Train
dbn.fit(X_train)

# ใช้โมเดลที่ฝึกด้วยชุด Test เพื่อประเมินประสิทธิภาพ
score = dbn.autoencoder.evaluate(X_test, X_test)
print("Test loss:", score)

โดย data.npy และ target.npy คือไฟล์ที่เก็บชุดข้อมูลและตัวเป้าหมายตามลำดับ และ dbn.py เป็นไฟล์ Python ที่เก็บคลาส DBN ที่เรานำเข้ามาใช้ในโค้ด

7. สร้างโมเดล Deep Belief Network โดยใช้ PyDeepBelief โดยกำหนดจำนวน Hidden Layer เท่ากับ 2, และจำนวนโหนดของแต่ละ Hidden Layer คือ 1000

PyDeepBelief เป็นไลบรารีที่ใช้สำหรับการสร้าง Deep Belief Network ด้วย Python โดยใช้ Theano ในการคำนวณ และมี pre-trained model จาก ImageNet ให้ใช้งานได้ทันที โดยสามารถติดตั้งได้ผ่าน pip ดังนี้

pip install pydeeplearn

สร้าง DBN ด้วย PyDeepBelief ที่มีจำนวน Hidden Layer เท่ากับ 2 และจำนวนโหนดของแต่ละ Hidden Layer เท่ากับ 1000

from deepbelief import DBN
import numpy as np

# โหลดข้อมูล
X_train = np.load('X_train.npy')
X_test = np.load('X_test.npy')

# กำหนด hyperparameters
n_hidden_layers = 2
n_hidden_units = [1000, 1000]

# สร้าง DBN object และ fit กับข้อมูล Train
dbn = DBN(hidden_layers_sizes=n_hidden_units, pretrain_epochs=10, finetune_epochs=50)
dbn.fit(X_train)

# ทำนายข้อมูล Test
predictions = dbn.predict(X_test)

โหลดข้อมูล Train และ Test จากไฟล์ numpy ก่อน และกำหนด hyperparameters ของ DBN โดยใช้ตัวแปร n_hidden_layers และ n_hidden_units ซึ่งในที่นี้กำหนดจำนวน Hidden Layer เป็น 2 และจำนวนโหนดของแต่ละ Hidden Layer เป็น 1000 ตามลำดับ และกำหนดจำนวน epoch ในการ pretrain และ finetune ตามลำดับ โดยในที่นี้กำหนดให้ pretrain_epochs=10 และ finetune_epochs=50

จากนั้นสร้าง object DBN และ fit กับข้อมูล Train โดยใช้ method fit และพยายามทำนายข้อมูล Test ด้วย method predict ซึ่งจะได้ผลลัพธ์เป็น numpy array ที่มีขนาดเท่ากับจำนวนข้อมูล Test

8. ฝึกโมเดลด้วยชุด Train data โดยใช้ fit() จาก PyDeepBelief

from pydeepbelief import Autoencoder

# โหลดชุดข้อมูล
data = load_data()

# กำหนดค่าพารามิเตอร์
n_hidden_layers = 2
n_nodes = [1000, 1000]
n_epochs = 100

# สร้างโมเดล
model = Autoencoder(n_visible=data.shape[1], n_hidden=n_nodes, n_layers=n_hidden_layers)

# ฝึกโมเดลด้วยชุด Train data
model.fit(data, n_epochs=n_epochs)

โดยที่ load_data() คือฟังก์ชันที่โหลดข้อมูลเข้ามา และ n_visible คือจำนวน feature ในชุดข้อมูลของเรา ซึ่งในที่นี้ถูกกำหนดโดย data.shape[1] ซึ่งหมายถึงจำนวน feature ของชุดข้อมูล data

9. ทำนายผลด้วยชุด Test data โดยใช้ predict() จาก PyDeepBelief สามารถทำได้ดังนี้

# สมมติว่า X_test เป็นข้อมูล Test data
# ให้ใช้ model.predict(X_test) เพื่อทำนายผล
predictions = model.predict(X_test)

โดยที่ model เป็นโมเดล Deep Belief Network (DBN) ที่ถูกฝึกด้วยชุด Train data ด้วยฟังก์ชัน fit() จาก PyDeepBelief แล้ว

10. ประเมินผลโมเดลโดยใช้ค่า Accuracy, F1-score, Precision และ Recall โดยใช้ sklearn.metrics และคำนวณด้วยคำสั่ง classification_report() สามารถทำได้ดังนี้

from sklearn.metrics import classification_report

# ใช้โมเดลที่เรา train ขึ้นมากับชุดข้อมูล test เพื่อทำนายผล
y_pred = model.predict(X_test)
y_pred = (y_pred > 0.5)

# แสดงผลลัพธ์ด้วย classification report
print(classification_report(y_test, y_pred))

โดยที่ y_test คือค่าจริงที่เราต้องการทำนาย และ y_pred คือผลลัพธ์ที่ได้จากการทำนายด้วยโมเดล และ X_test เป็น feature ของชุดข้อมูล test ที่เรานำมาใช้ในการทำนายผล

model คือ โมเดล Deep Belief Network ที่ถูกฝึกด้วยชุด Train data, X_test คือ feature ของชุด Test data, y_test คือ label ของชุด Test data ที่เป็น ground truth และ y_pred คือ label ที่ทำนายได้จากโมเดล Deep Belief Network โดยใช้ค่า threshold เท่ากับ 0.5 ในการแปลงค่าความน่าจะเป็นของแต่ละคลาสที่ได้จากโมเดลให้เป็น binary class. จากนั้นใช้คำสั่ง classification_report() เพื่อคำนวณค่า Accuracy, F1-score, Precision และ Recall ของโมเดล โดยสามารถแสดงผลลัพธ์ได้ในรูปแบบตาราง (table) ได้เลย

ตัวอย่าง  Deep Belief Network (DBN) โดยใช้ PyDeepBelief

from pydeepbelief import deepbelief
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# โหลด dataset digits จาก scikit-learn
digits = load_digits()
X = digits.data
y = digits.target

# แบ่งชุดข้อมูลเป็นชุด Train และ Test โดยใช้ train_test_split() จาก scikit-learn.model_selection
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# สร้างโมเดล Deep Belief Network โดยกำหนดจำนวน Hidden Layer เท่ากับ 2 และจำนวนโหนดของแต่ละ Hidden Layer คือ 1000
dbn = deepbelief.DeepBeliefNetwork([X_train.shape[1], 1000, 1000, len(set(y_train))])

# ฝึกโมเดลด้วยชุด Train data โดยใช้ fit() จาก PyDeepBelief
dbn.fit(X_train)

# ใช้โมเดลในการทำนายผลด้วยชุด Test data โดยใช้ predict() จาก PyDeepBelief
y_pred = dbn.predict(X_test)

# ประเมินผลโมเดลโดยใช้ค่า Accuracy, F1-score, Precision และ Recall โดยใช้ sklearn.metrics และคำนวณด้วยคำสั่ง classification_report()
print(classification_report(y_test, y_pred))

จากตัวอย่าง ใช้ชุดข้อมูล digits จาก scikit-learn โดยใช้ฟังก์ชัน load_digits() เพื่อโหลด dataset มาใช้ในการฝึกและทดสอบโมเดล DBN โดยจะแบ่งชุดข้อมูลเป็นชุด Train และ Test โดยใช้ train_test_split() จาก scikit-learn.model_selection โดยกำหนด Test size เท่ากับ 0.2 (20% ของข้อมูล)

จากนั้นสร้างโมเดล DBN โดยใช้ PyDeepBelief และกำหนดจำนวน Hidden Layer เท่ากับ 2 และจำนวนโหนดของแต่ละ Hidden Layer คือ 1000 ด้วย `deepbelief.DeepBeliefNetwork([X_train.shape[1], 1000, 1000, len(set(y_train))

ตัวอย่าง โมเดล Deep Belief Network (DBN) เรียนรู้แบบ Unsupervised และ Supervised ได้โดยใช้หลักการ Deep Learning โดยทั่วไปจะใช้ในงานประมวลผลภาพและเสียง เราสามารถใช้ PyDeepBelief เพื่อสร้างและฝึกโมเดล DBN

import numpy as np
from pydeepbelief import deepbelief
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# โหลดชุดข้อมูล Digits จาก scikit-learn
digits = load_digits()
X, y = digits.data, digits.target

# แบ่งชุดข้อมูลเป็น train และ test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# สร้างโมเดล DBN ด้วย PyDeepBelief
dbn = deepbelief.DeepBelief(
    hidden_layers_sizes=[1000, 1000], # 2 hidden layers โดยมี 1000 nodes ในแต่ละ hidden layer
    learning_rate_rbm=0.06, # อัตราการเรียนรู้สำหรับ Restricted Boltzmann Machines (RBM)
    learning_rate_dbn=0.1, # อัตราการเรียนรู้สำหรับ Deep Belief Network (DBN)
    n_epochs_rbm=50, # จำนวนรอบการเทรน RBM
    n_iter_backprop=100, # จำนวนรอบการ backpropagation ในการเทรน DBN
    batch_size=32, # จำนวนตัวอย่างในแต่ละ batch
    verbose=1, # แสดงผลเวลาเทรนโมเดล
    random_seed=42, # กำหนด random seed
)

# ฝึกโมเดลด้วยชุด Train data
dbn.fit(X_train)

# ใช้โมเดลในการทำนายผลด้วยชุด Test data
y_pred = dbn.predict(X_test)

# ประเมินผลโมเดลด้วย classification report
print(classification_report(y_test, y_pred))

จากตัวอย่าง ได้จำแนกภาพเลขของชุดข้อมูล Digits จาก scikit-learn โดยใช้ PyDeepBelief ในการสร้างและเทรนโมเดล DBN ด้วยพารามิเตอร์ต่าง ๆ ที่กำหนดไว้ เช่น จำนวน hidden layers, จำนวน nodes ในแต่ละ hidden layer, อัตราการเรียนรู้ และจำนวนรอบการเทรน เป็นต้น

โดยการใช้งานโมเดล DBN ด้วย PyDeepBelief นั้น สามารถฝึกโมเดลด้วยชุด Train data ด้วยฟังก์ชัน fit() และใช้โมเดลในการทำนายผลด้วยชุด Test data ด้วยฟังก์ชัน predict() ซึ่งจากตัวอย่างโค้ดนี้ ผลการทำนายจะถูกประเมินด้วยค่า Accuracy, F1-score, Precision และ Recall โดยใช้ sklearn.metrics และคำสั่ง classification_report() โดยแสดงผลลัพธ์บนหน้าจอโดยใช้คำสั่ง print()

การสร้างโมเดล DBN ด้วย PyDeepBelief นั้นเป็นไปอย่างง่ายดาย โดยสามารถกำหนดจำนวน hidden layer และจำนวน nodes ของแต่ละ hidden layer ได้โดยง่าย นอกจากนี้ยังสามารถกำหนดพารามิเตอร์อื่นๆ เช่น อัตราการเรียนรู้สำหรับ RBM และ DBN จำนวนรอบการเทรน และ batch size ได้อีกด้วย

หลังจากที่โมเดลถูกฝึกด้วยชุด Train data แล้ว เราสามารถใช้โมเดลเพื่อทำนายผลด้วยชุด Test data และประเมินผลโมเดลได้โดยใช้ sklearn.metrics และคำสั่ง classification_report() ซึ่งสามารถแสดงค่า Accuracy, F1-score, Precision และ Recall ได้ให้เห็นถึงผลการประเมินโมเดล

Deep Belief Network (DBN) เป็นแบบจำลองเชิงลึกที่มีการเรียนรู้อย่างไม่สัมพันธ์ (unsupervised learning) โดยใช้ Restricted Boltzmann Machines (RBM) ซึ่งเป็นแบบจำลองแบบหนึ่งที่ใช้ในการเรียนรู้แบบไม่มีผู้สอน (unsupervised learning) โดยเรียนรู้แบบพลวัต (generative) ซึ่งมีความสามารถในการสร้างข้อมูลใหม่โดยไม่จำเป็นต้องมีข้อมูลใหม่เข้ามาเทรนอีกครั้ง นอกจากนี้ DBN ยังสามารถเรียนรู้แบบสัมพันธ์ (supervised learning) ได้ด้วยการใช้ backpropagation ในการปรับค่าน้ำหนักของเน็ตเวิร์ก

ตัวอย่าง Deep Belief Network (DBN) ที่นำมาใช้ในการจำแนกมะเร็ง โดยใช้ชุดข้อมูล Breast Cancer Wisconsin (Diagnostic) ที่เป็นชุดข้อมูลเชิงพื้นฐานที่ใช้ในการฝึกโมเดลการจำแนกมะเร็ง โค้ดนี้ใช้ PyDeepBelief ในการสร้างและฝึกโมเดล DBN และใช้ sklearn.metrics เพื่อประเมินผลโมเดล

import numpy as np
from pydeepbelief import deepbelief
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# โหลดชุดข้อมูล Breast Cancer Wisconsin (Diagnostic) จาก scikit-learn
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target

# แบ่งชุดข้อมูลเป็น train และ test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# สร้างโมเดล DBN ด้วย PyDeepBelief
dbn = deepbelief.DeepBelief(
    hidden_layers_sizes=[500, 500], # 2 hidden layers โดยมี 500 nodes ในแต่ละ hidden layer
    learning_rate_rbm=0.06, # อัตราการเรียนรู้สำหรับ Restricted Boltzmann Machines (RBM)
    learning_rate_dbn=0.1, # อัตราการเรียนรู้สำหรับ Deep Belief Network (DBN)
    n_epochs_rbm=50, # จำนวนรอบการเทรน RBM
    n_iter_backprop=100, # จำนวนรอบการ backpropagation ในการเทรน DBN
    batch_size=32, # จำนวนตัวอย่างในแต่ละ batch
    verbose=1, # แสดงผลเวลาเทรนโมเดล
    random_seed=42, # กำหนด random seed
)

# ฝึกโมเดลด้วยชุด Train data
dbn.fit(X_train)

# ใช้โมเดลในการทำนายผลด้วยชุด Test data
y_pred = dbn.predict(X_test)

# ประเมินผลโมเดลด้วย classification report
print(classification_report(y_test, y_pred))

# ประเมินผลโมเดลด้วยค่า accuracy
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy: {accuracy}")

จากตัวอย่าง จะทำนายว่าผู้ป่วยที่มีข้อมูลเกี่ยวกับมะเร็งเต้านม Wisconsin (Diagnostic) เป็นมะเร็งเมื่อนำมาวิเคราะห์ หรือไม่เป็นมะเร็ง มีการโหลดชุดข้อมูล Breast Cancer Wisconsin (Diagnostic) จาก scikit-learn และแบ่งชุดข้อมูลเป็น train และ test ด้วยฟังก์ชัน train_test_split() โดยมี test size เท่ากับ 0.2 และ random state เท่ากับ 42

โดยก่อนที่จะนำข้อมูลไปเทรนโมเดล จะต้องทำการแบ่งข้อมูลออกเป็น Train set และ Test set ก่อน โดยจะใช้ฟังก์ชัน train_test_split จาก scikit-learn เพื่อแบ่งชุดข้อมูลออกเป็น Train set และ Test set โดย Test set จะมีขนาด 20% ของข้อมูลทั้งหมด

จากนั้นก็สร้างโมเดล DBN ด้วย PyDeepBelief โดยกำหนดตัวแปรต่างๆ เช่น hidden layer ที่มี 2 layers โดยมี 500 nodes ในแต่ละ hidden layer, อัตราการเรียนรู้สำหรับ Restricted Boltzmann Machines (RBM) และ Deep Belief Network (DBN), จำนวนรอบการเทรน RBM, จำนวนรอบการ backpropagation ในการเทรน DBN, จำนวนตัวอย่างในแต่ละ batch, และอื่นๆ

กำหนดขนาดของ hidden layers ใน RBM ที่ใช้เทรนด้วย 2 hidden layers โดยมี 500 nodes ในแต่ละ hidden layer และกำหนดอัตราการเรียนรู้สำหรับ RBM ที่ 0.06 และสำหรับ DBN ที่ 0.1 และกำหนดจำนวนรอบการเทรน RBM ที่ 50 และจำนวนรอบการ backpropagation ในการเทรน DBN ที่ 100 และกำหนด batch size ที่ 32 โดยพารามิเตอร์อื่นๆ ก็เป็นค่าเริ่มต้น โดยสุดท้ายกำหนด random seed เพื่อให้ผลลัพธ์สามารถทำซ้ำได้

เรียกใช้ฟังก์ชัน fit() เพื่อฝึกโมเดลด้วยชุด Train data และใช้โมเดลในการทำนายผลด้วยชุด Test data โดยใช้ฟังก์ชัน predict() และประเมินผลโมเดลด้วย classification report โดยแสดงค่า precision, recall, f1-score, และ accuracy ของโมเดลบน Test data