การใช้ Gradient Descent ใน Deep Learning

Gradient Descent เป็นอัลกอริทึมที่ใช้ในการปรับค่าพารามิเตอร์ของโมเดลใน Deep Learning โดยมีวัตถุประสงค์เพื่อลดค่าความคลาดเคลื่อนระหว่างค่าเอาต์พุตจากโมเดลกับค่าเฉี่ยของเอาต์พุตจริง (ground truth) ซึ่งเป็นเทคนิคหนึ่งที่สำคัญในการเรียนรู้ของเครื่อง และเป็นเครื่องมือสำคัญในการสร้างโมเดล Deep Learning ที่มีประสิทธิภาพสูง

ในการใช้ Gradient Descent ใน Deep Learning จะใช้โครงสร้าง Neural Network ในการเรียนรู้และปรับค่าพารามิเตอร์ โดย Gradient Descent จะทำงานโดยคำนวณค่าเกรเดียนต์ (gradient) ของฟังก์ชันค่าสูญเสีย (loss function) โดยใช้ค่าเอาต์พุตที่ได้จากโมเดลและค่าเฉี่ยของเอาต์พุตจริง เพื่อหาวิธีปรับค่าพารามิเตอร์ให้เหมาะสม

การใช้ Gradient Descent ใน Deep Learning มีหลายรูปแบบ อย่างไรก็ตามวิธีที่ใช้กันอย่างแพร่หลายในปัจจุบันคือ Stochastic Gradient Descent (SGD) ซึ่งจะทำการปรับค่าพารามิเตอร์เป็นชุดย่อย ๆ (batch) จากการสุ่มออกมาจากชุดข้อมูลที่ใช้ในการเรียนรู้ โดยทุกครั้งที่ได้ชุดข้อมูลใหม่ Gradient Descent จะทำการคำนวณค่าเกรเดียนต์และปรับค่าพารามิเตอร์จนกระทั่งค่าความคลาดเคลื่อนลดลงอย่างเหมาะสม

Gradient Descent เป็นอัลกอริทึมที่นิยมใช้ในการอัพเดตค่าพารามิเตอร์ใน Deep Learning โดยจะใช้ค่า gradient (ค่าความชัน) ของฟังก์ชันความสูญเสีย (loss function) ในการปรับค่าพารามิเตอร์ เพื่อให้ค่าความสูญเสียลดลง จนถึงจุดที่มีค่าความสูญเสียน้อยที่สุด

กระบวนการ Gradient Descent สามารถแบ่งออกเป็น 3 ประเภท ได้แก่

1. Batch Gradient Descent (BGD) 
   การอัพเดตพารามิเตอร์โดยการคำนวณ gradient ของฟังก์ชันความสูญเสียบนชุดข้อมูลทั้งหมด (batch) แล้วจึงอัพเดตค่าพารามิเตอร์ทั้งหมดในรอบเดียวกัน

   เป็นวิธีการใช้ Gradient Descent ในการปรับค่าพารามิเตอร์ของโมเดลใน Deep Learning โดยที่ BGD จะปรับค่าพารามิเตอร์โดยคำนวณค่า gradient ของฟังก์ชัน cost function ที่ได้จากทุกตัวอย่างในชุดข้อมูล (batch) เพื่อหาค่าพารามิเตอร์ที่ทำให้ cost function มีค่าต่ำที่สุด

   ในกระบวนการ BGD จะใช้ชุดข้อมูลทั้งหมดในการคำนวณ gradient และปรับค่าพารามิเตอร์ ซึ่งทำให้ BGD มีข้อดีในการลด cost function ได้อย่างมั่นคงและเร็วขึ้น แต่ก็มีข้อเสียคือการใช้เวลาในการคำนวณ gradient และปรับค่าพารามิเตอร์ที่มากกว่า Gradient Descent ชนิดอื่น ๆ เช่น Stochastic Gradient Descent (SGD) และ Mini-Batch Gradient Descent

   การใช้ BGD ใน Deep Learning จะต้องคำนึงถึงความจุของหน่วยความจำ และเวลาในการคำนวณ gradient ซึ่งอาจทำให้ไม่สามารถใช้ BGD กับชุดข้อมูลขนาดใหญ่ได้ แต่ในกรณีที่มีข้อมูลขนาดเล็ก BGD จะช่วยลด cost function ได้ดีกว่า Gradient Descent ชนิดอื่น ๆ

2. Stochastic Gradient Descent (SGD) 
   การอัพเดตพารามิเตอร์โดยการคำนวณ gradient ของฟังก์ชันความสูญเสียบนชุดข้อมูลแต่ละตัว แล้วจึงอัพเดตค่าพารามิเตอร์ที่สอดคล้องกับข้อมูลนั้น ๆ ในรอบเดียวกัน

   เป็นวิธีการที่ใช้ในการอัพเดทพารามิเตอร์ใน Deep Learning โดยการอัพเดทพารามิเตอร์แต่ละครั้งจะใช้ข้อมูลชุดเดียวกันที่สุ่มมาจากข้อมูลต้นฉบับ ซึ่งเป็นการประมวลผลที่เร็วกว่า Batch Gradient Descent (BGD) แต่มีความไม่แน่นอนมากกว่า เนื่องจากเราไม่รู้ว่าจะได้รับข้อมูลชุดไหนในแต่ละครั้ง

   SGD มักถูกใช้ในงาน Deep Learning ที่ข้อมูลมีขนาดใหญ่ โดยเฉพาะในการสร้างโมเดลของการประมวลผลภาพ โดยการใช้ SGD จะช่วยลดเวลาในการฝึกโมเดลเพราะไม่ต้องคำนวณค่าสูญเสียจากข้อมูลทั้งหมดในแต่ละครั้ง แต่ในกรณีข้อมูลน้อยๆ การใช้ SGD อาจทำให้เกิดการเดินเวียนได้ง่ายขึ้นหรืออาจจะไม่พบจุดต่ำสุดที่ดีที่สุดได้

3. Mini-batch Gradient Descent (MBGD)
   เป็นเทคนิค Gradient Descent ที่ใช้ในการอัพเดทค่าพารามิเตอร์ของโมเดลใน Deep Learning โดยการอัพเดทค่าพารามิเตอร์นั้นจะไม่ใช้ทุกข้อมูลในชุดข้อมูล (dataset) ในแต่ละครั้ง แต่จะเลือกใช้เฉพาะข้อมูลบางส่วนที่เรียกว่า mini-batch มาใช้ในการอัพเดท

   ขนาดของ mini-batch จะมีผลต่อประสิทธิภาพและความเร็วของการเทรนโมเดล ถ้าเลือกใช้ mini-batch ที่มีขนาดเล็กจะช่วยลดการใช้หน่วยความจำและเพิ่มความเร็วในการเทรนโมเดล แต่ในทางกลับกันถ้าเลือกใช้ mini-batch ที่มีขนาดใหญ่เกินไปอาจทำให้เกิด overfitting หรือการเทรนโมเดลที่ไม่แม่นยำกับข้อมูลทดสอบ

   กระบวนการในการอัพเดทค่าพารามิเตอร์ใน MBGD จะคล้ายกับ SGD โดยการคำนวณ gradient ของฟังก์ชันความสูญเสีย (loss function) จะใช้กับ mini-batch ทั้งหมด และจากนั้นใช้ gradient นี้ในการอัพเดทค่าพารามิเตอร์ โดยปกติแล้ว MBGD จะใช้ในการเทรนโมเดลในขนาดของ dataset ที่มีขนาดใหญ่เพื่อเพิ่มความเร็วในการเทรนโมเดลและลดการใช้หน่วยความจำในการเก็บข้อมูล

การใช้ Gradient Descent ใน Deep Learning เป็นกระบวนการที่สำคัญมาก เพราะสามารถช่วยให้โมเดล Deep Learning ให้ความแม่นยำมากขึ้น และเรียนรู้ได้เร็วขึ้นด้วยการปรับค่าพารามิเตอร์ให้เหมาะสมกับข้อมูลที่รับเข้ามา และมีความสามารถในการทำนายได้มากยิ่งขึ้น

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

นอกจาก Gradient Descent แล้วยังมีเทคนิคอื่นๆ ที่นิยมใช้ในการเทรนโมเดล Deep Learning อย่างเช่น Momentum-based Gradient Descent, Nesterov Accelerated Gradient, AdaGrad, RMSProp, Adam, Adadelta ฯลฯ ซึ่งเทคนิคเหล่านี้มีการปรับปรุงและพัฒนาจาก Gradient Descent และสามารถช่วยลดเวลาในการเทรนโมเดลได้มากขึ้น

หลักการการเขียน Python โดยการนำ Gradient Descent มาใช้ใน Deep Learning

เพื่อการปรับปรุงค่าพารามิเตอร์ของโมเดล เช่น น้ำหนัก (weights) และไบอัส (biases) โดยใช้ค่าความคลาดเคลื่อน (loss) หรือฟังก์ชันความผิดพลาด (cost function) เป็นตัวชี้วัดคุณภาพของโมเดลที่ต้องการปรับปรุง การปรับปรุงนี้จะทำตามทิศทางของค่า gradient ของฟังก์ชันความคลาดเคลื่อนในแต่ละครั้งที่คำนวณค่าพารามิเตอร์ของโมเดล โดย Gradient Descent จะทำการปรับปรุงพารามิเตอร์โดยลดค่าของฟังก์ชันความคลาดเคลื่อนลงจนกว่าจะเข้าสู่จุดต่ำสุด (global minimum) หรือจุดที่น้อยกว่านั้น (local minimum) ซึ่งเป็นค่าพารามิเตอร์ที่ดีที่สุดสำหรับโมเดลนั้นๆ

การเขียน Python โดยใช้ Gradient Descent ใน Deep Learning สามารถทำได้โดยใช้ไลบรารี TensorFlow ซึ่งเป็นไลบรารี Open Source ที่พัฒนาโดย Google โดยใช้คำสั่ง tf.train.GradientDescentOptimizer() เพื่อสร้างตัวอัลกอริทึม Gradient Descent และใช้ minimize() เพื่อปรับปรุงค่าพารามิเตอร์ของโมเดล โดยมีขั้นตอนการเขียนโค้ดดังนี้

1. นำเข้าไลบรารีและโมดูลที่จำเป็น เช่น NumPy, TensorFlow, หรือ PyTorch

import numpy as np
import tensorflow as tf

2. กำหนดค่าคงที่ ที่จำเป็นสำหรับการฝึกโมเดล เช่น อัตราการเรียนรู้ (learning rate) จำนวนรอบการฝึก (training epochs) ขนาดของแบตช์ (batch size) และช่วงการแสดงผล (display step) ตามที่เหมาะสมสำหรับงานที่ต้องการ

learning_rate = 0.01
training_epochs = 1000
batch_size = 100
display_step = 50

3. กำหนดขนาดของข้อมูล และตัวแปร input (X) และ output (Y)

n_samples = train_x.shape[0]
X = tf.placeholder(tf.float32, [None, n_input])
Y = tf.placeholder(tf.float32, [None, n_classes])

4. กำหนดตัวแปร weights และ biases ในโมเดล

weights = tf.Variable(tf.zeros([n_input, n_classes]))
biases = tf.Variable(tf.zeros([n_classes]))

5. สร้างโมเดล โดยใช้ฟังก์ชัน activation ที่เหมาะสม เช่น softmax, sigmoid, relu หรือ tanh

pred = tf.nn.softmax(tf.matmul(X, weights) + biases)

6. กำหนดฟังก์ชันความผิดพลาด (cost function) ที่เหมาะสม เช่น mean squared error, cross-entropy หรือ KL divergence

cost = tf.reduce_sum(tf.pow(pred-Y, 2))/(2*n_samples)

7. กำหนดวิธีการปรับค่า weights และ biases โดยใช้ Gradient Descent optimizer เช่น SGD, Adam, RMSprop

optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

8. เริ่มการฝึกโมเดล โดยกำหนดค่าเริ่มต้นให้กับตัวแปร weights และ biases ด้วยฟังก์ชัน global_variables_initializer() และใช้ loop เพื่อฝึกโมเดล

init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

    # ฝึกโมเดล
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(n_samples/batch_size)
        for i in range(total_batch):
            batch_x, batch_y = get_random_batch(train_x, train_y, batch_size)
            _, c = sess.run([optimizer, cost], feed_dict={X: batch_x, Y: batch_y})
            avg_cost += c / total_batch

        # คำนวณค่าความผิดพลาด
        if (epoch+1) % display_step == 0:
            print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))

    # แสดงผลลัพธ์
    print("Optimization Finished!")
    training_cost = sess.run(cost, feed_dict={X: train_x, Y: train_y})
    print("Training cost=", training_cost, "W=", sess.run(weights), "b=", sess.run(biases))

ตัวอย่าง การใช้ Gradient Descent ในการฝึกโมเดล Neural Network โดยใช้ TensorFlow

import tensorflow as tf

# กำหนดค่าคงที่
learning_rate = 0.01
training_epochs = 1000
display_step = 50

# กำหนดขนาดของข้อมูล
n_samples = train_x.shape[0]

# กำหนดตัวแปรในการฝึกโมเดล
X = tf.placeholder(tf.float32, [None, n_input])
Y = tf.placeholder(tf.float32, [None, n_classes])

# กำหนดตัวแปร weights และ biases
weights = tf.Variable(tf.zeros([n_input, n_classes]))
biases = tf.Variable(tf.zeros([n_classes]))

# สร้างโมเดล
pred = tf.nn.softmax(tf.matmul(X, weights) + biases)

# กำหนดฟังก์ชันความผิดพลาด
cost = tf.reduce_sum(tf.pow(pred-Y, 2))/(2*n_samples)

# ใช้ Gradient Descent ในการฝึกโมเดล
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# เริ่มการฝึกโมเดล
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

    # ฝึกโมเดล
    for epoch in range(training_epochs):
        for (x, y) in zip(train_x, train_y):
            sess.run(optimizer, feed_dict={X: x.reshape(1, n_input), Y: y.reshape(1, n_classes)})

        # คำนวณค่าความผิดพลาด
        if (epoch+1) % display_step == 0:
            c = sess.run(cost, feed_dict={X: train_x, Y: train_y})
            print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(c))

    # แสดงผลลัพธ์
    print("Optimization Finished!")
    training_cost = sess.run(cost, feed_dict={X: train_x, Y: train_y})
    print("Training cost=", training_cost, "W=", sess.run(weights), "b=", sess.run(biases))

จากตัวอย่าง เป็นการใช้ Gradient Descent ในการฝึกโมเดล Deep Learning โดยใช้ TensorFlow ในการสร้างโมเดล โดยได้กำหนดค่าคงที่ learning_rate = 0.01 เพื่อระบุอัตราการเรียนรู้ของโมเดล และกำหนดจำนวนรอบการฝึก training_epochs = 1000 และ display_step = 50 เพื่อกำหนดจำนวนรอบการฝึกและความถี่ในการแสดงผลลัพธ์ในการฝึกโมเดล

ต่อมาได้กำหนดขนาดของข้อมูล n_samples = train_x.shape[0] และกำหนดตัวแปรในการฝึกโมเดล X และ Y โดยใช้ tf.placeholder เพื่อระบุขนาดและประเภทของข้อมูลที่จะนำมาฝึก

ต่อมาได้กำหนดตัวแปร weights และ biases ในการสร้างโมเดล และสร้างโมเดลด้วย tf.nn.softmax(tf.matmul(X, weights) + biases) ซึ่งจะทำการคำนวณผลลัพธ์ที่เป็นความน่าจะเป็นของผลลัพธ์

จากนั้นกำหนดฟังก์ชันความผิดพลาด cost ด้วย tf.reduce_sum(tf.pow(pred-Y, 2))/(2*n_samples) โดยใช้ผลลัพธ์ของโมเดล pred และผลลัพธ์จริง Y ในการคำนวณ

ได้มีการใช้ Gradient Descent ในการฝึกโมเดลด้วย
                optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
และเริ่มการฝึกโมเดลด้วย init = tf.global_variables_initializer() และสั่งรันการฝึกโมเดลใน loop โดยใช้ zip(train_x, train_y) เพื่อนำข้อมูลเข้า Feed และใช้ sess.run(optimizer, feed_dict={X: x.reshape(1, n_input), Y: y.reshape(1, n_classes)}) เพื่อให้โมเดลได้รับค่าความผิดพลาดใหม่

การใช้ TensorFlow ในการสร้างและฝึกโมเดลด้วย Gradient Descent ในการแก้ปัญหาคลาสิฟิเคชัน โดยใช้ข้อมูล train_x และ train_y เพื่อฝึกโมเดล โดยกำหนดค่าคงที่ learning_rate, training_epochs, และ display_step และกำหนดตัวแปร X และ Y สำหรับใส่ข้อมูลและเฉลยเป้าหมาย ต่อมากำหนดตัวแปร weights และ biases เพื่อใช้ในการคำนวณค่าผลลัพธ์ pred จากนั้นกำหนดฟังก์ชันความผิดพลาด cost และใช้ Gradient Descent ในการฝึกโมเดลด้วย optimizer โดยทำการฝึกโมเดลด้วย loop ซ้อนกัน 2 ชั้น ก่อนจะแสดงผลลัพธ์จากการฝึกโมเดล โดยแสดงผลค่า cost ทุก 50 epoch และแสดงผลลัพธ์การฝึกโมเดลสำหรับค่า weights และ biases ที่ได้ในที่สุด

การใช้ TensorFlow ในการฝึกโมเดลด้วย Gradient Descent เป็นวิธีการที่ได้รับความนิยมในการสร้างและฝึกโมเดล Deep Learning ในปัจจุบัน เนื่องจาก TensorFlow เป็นไลบรารีที่มีความสามารถในการทำงานแบบจำลองกระบวนการ Deep Learning มากมาย และสามารถใช้ Gradient Descent หลายแบบได้ เช่น BGD, SGD และ MBGD โดยจะต้องเลือกใช้เทคนิคที่เหมาะสมกับงานและข้อมูลที่มีอยู่

ตัวอย่าง การใช้ Gradient Descent ในการฝึกโมเดล Deep Learning ด้วย TensorFlow 2.x

import tensorflow as tf
import numpy as np

# กำหนดค่าคงที่
learning_rate = 0.01
training_epochs = 1000
display_step = 50

# กำหนดขนาดของข้อมูล
n_samples = train_x.shape[0]

# กำหนดตัวแปรในการฝึกโมเดล
X = tf.placeholder(tf.float32, [None, n_input])
Y = tf.placeholder(tf.float32, [None, n_classes])

# กำหนดตัวแปร weights และ biases
weights = tf.Variable(tf.zeros([n_input, n_classes]))
biases = tf.Variable(tf.zeros([n_classes]))

# สร้างโมเดล
def model(X, weights, biases):
    return tf.nn.softmax(tf.matmul(X, weights) + biases)

# กำหนดฟังก์ชันความผิดพลาด
def loss_fn(y_true, y_pred):
    return tf.reduce_mean(tf.square(y_true - y_pred))

# ใช้ Gradient Descent ในการฝึกโมเดล
optimizer = tf.optimizers.SGD(learning_rate)

# เริ่มการฝึกโมเดล
for epoch in range(training_epochs):
    avg_loss = 0.0
    total_batch = int(n_samples/batch_size)

    for i in range(total_batch):
        # สุ่มตัวอย่างจากข้อมูลเพื่อใช้ในการฝึก
        batch_x, batch_y = next_batch(batch_size, train_x, train_y)

        # คำนวณค่า gradient และอัปเดต weights และ biases ด้วย optimizer
        with tf.GradientTape() as tape:
            pred = model(batch_x, weights, biases)
            loss = loss_fn(batch_y, pred)
        gradients = tape.gradient(loss, [weights, biases])
        optimizer.apply_gradients(zip(gradients, [weights, biases]))

        # คำนวณค่าความผิดพลาด
        avg_loss += loss/total_batch

    # แสดงผลลัพธ์
    if (epoch+1) % display_step == 0:
        print("Epoch:", '%04d' % (epoch+1), "loss=", "{:.9f}".format(avg_loss))

# แสดงผลลัพธ์
print("Optimization Finished!")
training_cost = loss_fn(train_y, model(train_x, weights, biases)).numpy()
print("Training cost=", training_cost, "W=", weights.numpy(), "b=", biases.numpy())

จากตัวอย่าง การใช้ Gradient Descent แบบ Mini-batch Gradient Descent (MBGD) ในการฝึกโมเดล Deep Learning ด้วย TensorFlow 2.0 โดยใช้ฟังก์ชันความผิดพลาดเป็น Mean Squared Error (MSE) และอัปเดต weights และ biases ด้วย Stochastic Gradient Descent (SGD) optimizer

การใช้ Gradient Descent แบบ Mini-batch Gradient Descent (MBGD) ในการฝึกโมเดล Deep Learning ด้วย TensorFlow 2.x

โดยโค้ดประกอบไปด้วยขั้นตอนต่างๆ ดังนี้

1. กำหนดค่าคงที่ เช่น learning_rate, training_epochs, และ display_step เพื่อใช้ในการฝึกโมเดล

2. กำหนดขนาดของข้อมูลโดยใช้ n_samples เพื่อใช้ในการแบ่งข้อมูลเป็น mini-batches

3. กำหนดตัวแปร X และ Y เพื่อใช้เป็น placeholders สำหรับรับข้อมูล input และ output ตามลำดับ

4. กำหนดตัวแปร weights และ biases เพื่อใช้เป็นพารามิเตอร์ของโมเดล

5. สร้างฟังก์ชัน model สำหรับคำนวณค่า output ของโมเดล โดยใช้ softmax function

6. กำหนดฟังก์ชันความผิดพลาด loss_fn โดยใช้ mean squared error (MSE) เพื่อคำนวณค่าความผิดพลาดระหว่าง output จริงและ output ที่คำนวณได้จากโมเดล

7. ใช้ Gradient Descent optimizer แบบ Stochastic Gradient Descent (SGD) เพื่อใช้ในการอัปเดต weights และ biases ในแต่ละ batch ของข้อมูล

8. ใช้ loop ในการฝึกโมเดลในแต่ละ epoch โดยแบ่งข้อมูลออกเป็น mini-batches และคำนวณค่า gradient และอัปเดต weights และ biases โดยใช้ optimizer ในแต่ละ mini-batch

9. คำนวณค่าความผิดพลาดเฉลี่ยสำหรับแต่ละ epoch และแสดงผลลัพธ์ทุกๆ display_step epochs

10. แสดงผลลัพธ์ของการฝึกโมเดลเมื่อเสร็จสิ้น

โดยการทำงานของโค้ดจะเป็นการวนลูปเพื่อฝึกโมเดลในแต่ละ epoch โดยในแต่ละ epoch จะแบ่งข้อมูลออกเป็น batch ขนาดเท่ากับ batch_size เพื่อนำไปฝึกโมเดล ในแต่ละ batch จะสุ่มตัวอย่างจากข้อมูลเพื่อใช้ในการฝึก และคำนวณค่า gradient และอัปเดต weights และ biases ด้วย optimizer โดยใช้ GradientTape ในการคำนวณ gradient ต่อไปนี้คือการแสดงผลลัพธ์จะแสดงผลลัพธ์ทุกๆ display_step รอบ

หลังจากการฝึกโมเดลเสร็จสิ้น โค้ดจะแสดงผลลัพธ์ดังนี้ ค่า training cost และค่า weights และ biases ที่ได้จากการฝึกโมเดล

การกำหนดค่าคงที่ learning_rate, training_epochs, และ display_step โดยค่าเหล่านี้ใช้ในการกำหนดความถี่ในการแสดงผลลัพธ์การฝึกโมเดล และในการกำหนดจำนวน epoch ที่ใช้ในการฝึกโมเดล

ต่อมาจะเห็นว่าโค้ดได้กำหนดขนาดของข้อมูล n_samples ตามจำนวนตัวอย่างในชุดข้อมูล train_x และ train_y ที่ใช้ในการฝึกโมเดล

ต่อมาในการสร้างโมเดลนั้น ได้กำหนดตัวแปร weights และ biases โดยให้มีค่าเริ่มต้นเป็น 0 และใช้ฟังก์ชัน softmax เพื่อปรับค่า output ให้อยู่ในรูปแบบของความน่าจะเป็นของแต่ละ class

เพื่อใช้ในการคำนวณค่าความผิดพลาด ได้กำหนดฟังก์ชัน loss_fn โดยใช้ฟังก์ชัน tf.square เพื่อหาค่าต่างของค่าจริงกับค่าที่คำนวณได้ และนำไปหา mean เพื่อหาค่าความผิดพลาดเฉลี่ย

สำหรับ optimizer ได้ใช้ Stochastic Gradient Descent (SGD) ในการอัปเดตค่า weights และ biases โดยใช้ค่า learning_rate ที่กำหนดไว้

ในการฝึกโมเดล ได้ใช้ for loop โดยกำหนดจำนวน epoch ที่ต้องการฝึก และใช้ total_batch เพื่อกำหนดจำนวน mini-batch ที่ต้องใช้ในการฝึก โดย n_samples

ตัวอย่าง การใช้ Batch Gradient Descent (BGD) ในการฝึกโมเดล Deep Learning ด้วย TensorFlow

import tensorflow as tf

# กำหนดค่าคงที่
learning_rate = 0.01
training_epochs = 1000
display_step = 50

# กำหนดขนาดของข้อมูล
n_samples = train_x.shape[0]

# กำหนดตัวแปรในการฝึกโมเดล
X = tf.placeholder(tf.float32, [None, n_input])
Y = tf.placeholder(tf.float32, [None, n_classes])

# กำหนดตัวแปร weights และ biases
weights = tf.Variable(tf.zeros([n_input, n_classes]))
biases = tf.Variable(tf.zeros([n_classes]))

# สร้างโมเดล
pred = tf.nn.softmax(tf.matmul(X, weights) + biases)

# กำหนดฟังก์ชันความผิดพลาด
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(pred), reduction_indices=1))

# ใช้ Batch Gradient Descent ในการฝึกโมเดล
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# เริ่มการฝึกโมเดล
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

    # ฝึกโมเดล
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(n_samples/batch_size)
        for i in range(total_batch):
            batch_xs, batch_ys = next_batch(batch_size, train_x, train_y)
            _, c = sess.run([optimizer, cost], feed_dict={X: batch_xs, Y: batch_ys})
            avg_cost += c / total_batch

        # คำนวณค่าความผิดพลาด
        if (epoch+1) % display_step == 0:
            print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))

    # แสดงผลลัพธ์
    print("Optimization Finished!")
    correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(Y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    print("Accuracy:", accuracy.eval({X: test_x, Y: test_y}))

จากตัวอย่างการสร้างและฝึกโมเดล Neural Network ด้วยวิธีการ Batch Gradient Descent สำหรับงานจำแนกประเภท (classification) ซึ่งเป็นการพยายามจะคาดเดาว่าแต่ละตัวอยู่ในกลุ่มไหนในขณะที่รับข้อมูลส่งเข้ามา โดยโมเดลจะถูกสร้างขึ้นเพื่อให้มีความแม่นยำในการทำนายกลุ่มของข้อมูลที่ยังไม่เคยเห็น (unseen data) โดยใช้ข้อมูลที่เคยเห็น (training data) เป็นการฝึกโมเดล เป็นการฝึกโมเดลแบบ One-Hot Encoding ด้วย Logistic Regression ด้วย TensorFlow โดยมีรายละเอียดดังนี้

1. กำหนดค่าคงที่

   • learning_rate: ค่า learning rate ที่ใช้ในการปรับค่า weight และ bias ในแต่ละครั้ง
   • training_epochs: จำนวนรอบการฝึกโมเดล
   • display_step: จำนวนรอบการฝึกโมเดลที่แสดงผลลัพธ์

2. กำหนดขนาดของข้อมูล

   • n_samples: จำนวนข้อมูลทั้งหมดที่ใช้ในการฝึกโมเดล

3. กำหนดตัวแปรในการฝึกโมเดล

   • X: placeholder สำหรับรับ input ของโมเดล
   • Y: placeholder สำหรับรับ output ของโมเดล

4. กำหนดตัวแปร weights และ biases

   • weights: ตัวแปรที่ใช้เก็บค่า weight ของโมเดล
   • biases: ตัวแปรที่ใช้เก็บค่า bias ของโมเดล

5. pred สร้างโมเดล Neural Network แบบ Softmax Regression โดยใช้ X, weights, และ biases เป็นอินพุต และแสดงผลลัพธ์ที่ผ่านฟังก์ชัน softmax

6. cost กำหนดฟังก์ชันความผิดพลาดโดยใช้สูตร Cross-Entropy โดยใช้ Y และ pred เป็นอินพุต

7. ใช้ Batch Gradient Descent ในการฝึกโมเดล โดยใช้ optimizer เป็น GradientDescentOptimizer และใช้ minimize(cost) เพื่อลดค่า cost ในการฝึกโมเดล
8. ทำการเริ่มต้นการฝึกโมเดลโดยใช้ Global Variables Initializer และสร้าง Session ของ TensorFlow
9. ฝึกโมเดลโดยใช้ for loop และใช้ next_batch เพื่อดึงข้อมูลมาฝึก
10. คำนวณค่า cost และค่าเฉลี่ยของ cost จากการฝึกทั้งหมด
11. แสดงผลลัพธ์ cost เมื่อ epoch ถึง display_step
12. หยุดการฝึกโมเดลเมื่อ training_epochs ถึง
13. คำนวณค่าความแม่นยำของโมเดลจาก test_x และ test_y และแสดงผลลัพธ์

ในกระบวนการฝึกโมเดล ได้ใช้ Gradient Descent แบบ batch หมายความว่าจะนำข้อมูลมาทำคำนวณค่าความผิดพลาดและปรับ weights และ biases ทุกๆ batch_size

ตัวอย่าง การใช้งาน Stochastic Gradient Descent (SGD) ใน Deep Learning

import tensorflow as tf
import numpy as np

# กำหนดค่าคงที่
learning_rate = 0.01
training_epochs = 1000
batch_size = 100
display_step = 50

# สร้างฟังก์ชันสำหรับสร้าง Layer ใน Neural Network
def layer(x, output_dim):
    input_dim = x.get_shape().as_list()[1]
    W = tf.Variable(tf.random_normal([input_dim, output_dim]))
    b = tf.Variable(tf.random_normal([output_dim]))
    return tf.matmul(x, W) + b

# กำหนดตัวแปรในการฝึกโมเดล
X = tf.placeholder(tf.float32, [None, n_input])
Y = tf.placeholder(tf.float32, [None, n_classes])

# สร้างโมเดล Neural Network แบบ 2 Layer
hidden_layer = layer(X, n_hidden)
output_layer = layer(hidden_layer, n_classes)

# กำหนดฟังก์ชันความผิดพลาด
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=output_layer, labels=Y))

# ใช้ Stochastic Gradient Descent ในการฝึกโมเดล
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# เริ่มการฝึกโมเดล
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

    # ฝึกโมเดล
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(train_x.shape[0]/batch_size)

        # สุ่มข้อมูลแบบ Stochastic Gradient Descent
        indices = np.random.permutation(train_x.shape[0])
        train_x_sgd = train_x[indices]
        train_y_sgd = train_y[indices]

        # ฝึกโมเดลแต่ละ batch
        for i in range(total_batch):
            batch_x = train_x_sgd[i*batch_size:(i+1)*batch_size]
            batch_y = train_y_sgd[i*batch_size:(i+1)*batch_size]

            # ส่ง batch ในการฝึกโมเดล
            _, c = sess.run([optimizer, cost], feed_dict={X: batch_x, Y: batch_y})
            avg_cost += c / total_batch

        # คำนวณค่าความผิดพลาดและแสดงผลลัพธ์
        if (epoch+1) % display_step == 0:
            print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))

    # แสดงผลลัพธ์
    print("Optimization Finished!")
    correct_prediction = tf.equal(tf.argmax(output_layer, 1), tf.argmax(Y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    print("Accuracy:", accuracy.eval({X: test_x, Y: test_y}))

จากตัวอย่าง เป็นการสร้างโมเดล Neural Network แบบ 2 Layer และใช้ Stochastic Gradient Descent ในการฝึกโมเดล เพื่อจำแนกประเภทของข้อมูล โดยใช้ softmax_cross_entropy_with_logits เป็นฟังก์ชันความผิดพลาด และคำนวณค่าความผิดพลาดเฉลี่ยในแต่ละ epoch และแสดงผลลัพธ์ที่เกี่ยวข้อง เมื่อฝึกโมเดลเสร็จสิ้น จะแสดง Accuracy ของโมเดลที่ทำนายได้บนข้อมูลทดสอบ (test data)

การสร้างและฝึกโมเดล Neural Network แบบ 2 Layer สำหรับการจำแนกประเภทข้อมูลด้วย Stochastic Gradient Descent

โดยจะเริ่มจากการกำหนดค่าคงที่ดังนี้

• learning_rate: ค่า learning rate สำหรับใช้ในการฝึกโมเดล
• training_epochs: จำนวน epoch ที่ใช้ในการฝึกโมเดล
• batch_size: จำนวนตัวอย่างในแต่ละ batch
• display_step: ระยะห่างของ epoch ที่จะแสดงผลลัพธ์

จากนั้น โค้ดจะสร้างฟังก์ชัน layer สำหรับสร้าง Layer ใน Neural Network โดยฟังก์ชันนี้จะรับ input และ output dimension ของ Layer และสร้าง weight matrix และ bias vector สำหรับ Layer นั้น ๆ จากนั้นจะ return output จาก Layer นั้น ๆ

ต่อมากำหนดตัวแปร X และ Y สำหรับใช้ในการฝึกโมเดล โดย X จะเป็น placeholder สำหรับ input และ Y จะเป็น placeholder สำหรับ output ที่เป็น one-hot encoding

จากนั้นสร้างโมเดล Neural Network แบบ 2 Layer โดยใช้ฟังก์ชัน layer ที่สร้างไว้ก่อนหน้า โดยกำหนด hidden layer ขนาด n_hidden และ output layer ขนาด n_classes

ต่อมากำหนดฟังก์ชันความผิดพลาด โดยใช้ softmax cross entropy with logits เพื่อคำนวณค่าความผิดพลาดของโมเดล

จากนั้นจะใช้ Stochastic Gradient Descent ในการฝึกโมเดล โดยใช้ optimizer ของ GradientDescentOptimizer ที่กำหนดค่า learning rate ที่เรากำหนดไว้และ minimize ค่าความผิดพลาด

ตัวอย่าง โค้ด Python สำหรับการใช้ Mini-batch Gradient Descent (MBGD) ใน Deep Learning

import numpy as np
import tensorflow as tf

# กำหนดค่าคงที่
learning_rate = 0.01
training_epochs = 1000
batch_size = 100
display_step = 50

# กำหนดขนาดของข้อมูล
n_samples = train_x.shape[0]

# กำหนดตัวแปรในการฝึกโมเดล
X = tf.placeholder(tf.float32, [None, n_input])
Y = tf.placeholder(tf.float32, [None, n_classes])

# กำหนดตัวแปร weights และ biases
weights = tf.Variable(tf.zeros([n_input, n_classes]))
biases = tf.Variable(tf.zeros([n_classes]))

# สร้างโมเดล
pred = tf.nn.softmax(tf.matmul(X, weights) + biases)

# กำหนดฟังก์ชันความผิดพลาด
cost = tf.reduce_sum(tf.pow(pred-Y, 2))/(2*n_samples)

# ใช้ Mini-batch Gradient Descent ในการฝึกโมเดล
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# เริ่มการฝึกโมเดล
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

    # ฝึกโมเดล
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(n_samples/batch_size)
        for i in range(total_batch):
            batch_x, batch_y = get_random_batch(train_x, train_y, batch_size)
            _, c = sess.run([optimizer, cost], feed_dict={X: batch_x, Y: batch_y})
            avg_cost += c / total_batch

        # คำนวณค่าความผิดพลาด
        if (epoch+1) % display_step == 0:
            print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))

    # แสดงผลลัพธ์
    print("Optimization Finished!")
    training_cost = sess.run(cost, feed_dict={X: train_x, Y: train_y})
    print("Training cost=", training_cost, "W=", sess.run(weights), "b=", sess.run(biases))

จากตัวอย่าง เป็นการฝึกโมเดล neural network โดยใช้ Mini-batch Gradient Descent ในการเรียนรู้ โดยสร้างโมเดลที่มีหนึ่ง hidden layer และ output layer โดยใช้ activation function เป็น softmax

แปลงค่าคงที่ที่ใช้ในการฝึกโมเดล:

• อัตราการเรียนรู้ (learning rate) คือ 0.01
• จำนวนรอบการฝึก (training epochs) คือ 1000
• ขนาด batch (batch size) คือ 100
• จำนวนข้อมูลทั้งหมด (n_samples) ยังไม่ได้ระบุ

เริ่มต้นด้วยการ import numpy และ tensorflow และกำหนดค่าคงที่ เช่น learning_rate, training_epochs, batch_size และ display_step

ต่อมากำหนดขนาดของข้อมูล n_samples จากข้อมูล train_x และกำหนดตัวแปร X และ Y ในการรับค่า input และ output ตามลำดับ

จากนั้นกำหนดตัวแปร weights และ biases โดยให้ weights เป็น zero matrix ขนาด n_input x n_classes และ biases เป็น zero vector ขนาด n_classes

สร้างโมเดลโดยใช้ tf.nn.softmax และคำนวณค่าความผิดพลาดโดยใช้ MSE (mean squared error)

ใช้ Mini-batch Gradient Descent ในการฝึกโมเดลโดยกำหนด optimizer เป็น GradientDescentOptimizer โดยใช้ learning rate ที่กำหนดไว้

สุดท้ายเริ่มต้นการฝึกโมเดลโดยเริ่มต้นตัวแปรด้วยคำสั่ง tf.global_variables_initializer() และฝึกโมเดลโดยวนลูปตามจำนวนรอบการฝึก training_epochs โดยใช้ Mini-batch Gradient Descent และประมวลผลด้วยคำสั่ง sess.run() โดยใช้ optimizer และ cost เป็นตัวแปรที่ต้องการประมวลผล และ feed_dict เพื่อส่งค่าข้อมูล input และ output