Gradient Descent: ວິທີທີ່ Neural Networks ຊອກຫາຄຳຕອບທີ່ດີທີ່ສຸດ

ລອງຈິນຕະນາການວ່າ ທ່ານກຳລັງຢືນຢູ່ເທິງຈອມ ພູເບ້ຍ (ຈຸດທີ່ສູງທີ່ສຸດໃນລາວ) ໃນຍາມກາງຄືນທີ່ມີໝອກໜາທຶບ ແລະ ບໍ່ມີໄຟສາຍ. ເປົ້າໝາຍຂອງທ່ານຄືການຍ່າງລົງໄປຫາຮ່ອມພູທີ່ຕໍ່າທີ່ສຸດເພື່ອຕັ້ງແຄັມ. ຍ້ອນທ່ານເບິ່ງບໍ່ເຫັນທາງ, ວິທີດຽວທີ່ເຮັດໄດ້ຄືການໃຊ້ຕີນສຳຜັດກັບຄວາມຄ້ອຍຊັນຂອງໜ້າດິນ ແລ້ວກ້າວໄປໃນທິດທາງທີ່ຊັນລົງທີ່ສຸດ. ທ່ານເຮັດແບບນີ້ຊ້ຳໆຈົນກວ່າໜ້າດິນຈະພຽງນັ້ນຄືຈຸດທີ່ຕໍ່າທີ່ສຸດແລ້ວ.

ໃນໂລກຂອງ Artificial Intelligence (AI) ແລະ Deep Learning, ຂະບວນການນີ້ຖືກເອີ້ນວ່າ Gradient Descent. ມັນຄືອັນກໍຣິທຶມການເພີ່ມປະສິດທິພາບ (Optimization Algorithm) ທີ່ເປັນຫົວໃຈສຳຄັນໃນການຝຶກຝົນ (Training) Neural Networks ທຸກຮູບແບບ, ຕັ້ງແຕ່ໂມເດວງ່າຍໆ ຈົນເຖິງ Large Language Models (LLMs) ຂະໜາດໃຫຍ່.

ໃນບົດຄວາມນີ້, ເຮົາຈະມາລົງເລິກເຖິງຄະນິດສາດ (Mathematics), ຂັ້ນຕອນການເຮັດວຽກຂອງ Neural Network Architecture, ແລະ ການຂຽນໂຄດດ້ວຍ PyTorch ຜ່ານສະຖານະການຈຳລອງ: ການພະຍາກອນລະດັບນ້ຳຂອງ.

2. ຄະນິດສາດທີ່ຢູ່ເບື້ອງຫຼັງ Gradient (The Math Behind Gradient)

ໃນຕົວຢ່າງພູເບ້ຍ, “ຄວາມສູງ” ຂອງພູ ແມ່ນເປັນຕົວແທນໃຫ້ກັບ Loss Function (ຫຼື Cost Function) $J(\theta)$ ເຊິ່ງວັດແທກວ່າການທຳນາຍຂອງໂມເດວເຮົາຜິດພາດສໍ່າໃດ. ເປົ້າໝາຍຂອງເຮົາຄືການຊອກຫາຄ່າຂອງ Parameters $\theta$ (Weights ແລະ Biases) ທີ່ເຮັດໃຫ້ຄ່າ $J(\theta)$ ໜ້ອຍທີ່ສຸດ.

ສົມຜົນຫຼັກຂອງໂລກ Gradient Descent ທີ່ນັກພັດທະນາ AI ທຸກຄົນຕ້ອງຮູ້:

$\theta_{j} := \theta_{j} - \alpha \frac{\partial}{\partial \theta_{j}} J(\theta)$

• $\theta_{j}$: Parameter (ເຊັ່ນ Weight ທີ່ເຊື່ອມຕໍ່ Node ໃນ Neural Network).
• $\alpha$ (Learning Rate): ຂະໜາດຂອງບາດກ້າວ. ຖ້າ $\alpha$ ໃຫຍ່ເກີນໄປ ເຮົາອາດຈະກ້າວຂ້າມຮ່ອມພູແລ້ວປີນຂຶ້ນພູລູກໃໝ່ໂດຍບໍ່ຮູ້ຕົວ (Overshooting). ແຕ່ຖ້າ $\alpha$ ນ້ອຍເກີນໄປ, ໂມເດວຈະໃຊ້ເວລາ Training ດົນຫຼາຍ.
• $\frac{\partial}{\partial \theta_{j}} J(\theta)$ (Gradient): ຄ່າຜົນຕຳລາບາງສ່ວນ (Partial Derivative) ຂອງ Loss Function. ມັນບອກເຖິງ ຄວາມຄ້ອຍຊັນ ແລະ ທິດທາງ ທີ່ເຮັດໃຫ້ Loss ເພີ່ມຂຶ້ນ. ເຮົາຈຶ່ງຕ້ອງໃສ່ເຄື່ອງໝາຍລົບ ($-$) ເພື່ອໃຫ້ຍ່າງສວນທາງກັບຄວາມຊັນ (ລົງພູ).

3. ວິວັດທະນາການຂອງ Gradient Descent ໃນສະພາບແວດລ້ອມແບບຊັບຊ້ອນ

ໃນການພັດທະນາໂມເດວໂຕຈິງ, “ໜ້າພູ” (Loss Landscape) ບໍ່ໄດ້ລຽບງ່າຍ, ມັນເຕັມໄປດ້ວຍຫຼຸມ, ໜອງນ້ຳ ແລະ ຈຸດຫຼອກລວງ (Local Minima). ດັ່ງນັ້ນ, ວິທີການລົງພູ ຈຶ່ງຖືກພັດທະນາອອກເປັນຫຼາຍຮູບແບບ:

1. Batch Gradient Descent: ຄິດໄລ່ Gradient ຈາກຂໍ້ມູນທັງໝົດໃນ Dataset ກ່ອນຈະກ້າວ 1 ກ້າວ (ປອດໄພແຕ່ຊ້າຫຼາຍ).
2. Stochastic Gradient Descent (SGD): ອັບເດດ Parameters ທັງໝົດທຸກໆການຮຽນຮູ້ຈາກຂໍ້ມູນ ‘ພຽງ 1 ຕົວຢ່າງ’ (ໄວ, ແຕ່ທິດທາງການຍ່າງຈະສະເປັະສະປະຄືຄົນເມົາ).
3. Mini-batch Gradient Descent: ເປັນການປະສົມປະສານທີ່ລົງຕົວທີ່ສຸດ ໂດຍການດຶງຂໍ້ມູນມາເປັນກຸ່ມນ້ອຍໆ (ເຊັ່ນ 32, 64 ຫຼື 128 data points).
4. Adam Optimizer (Adaptive Moment Estimation): ນີ້ຄືການອັບເດດລະດັບ Advanced ທີ່ເພີ່ມແນວຄວາມຄິດເລື່ອງ “Momentum” ແລະການປັບ Learning rate ອັດຕະໂນມັດສຳລັບແຕ່ລະ Parameter.
   • ສູດຄິດໄລ່ຂອງ Adam ຈະເກັບຄ່າສະເລ່ຍຂອງ Gradient ໃນອະດີດ ($m_t$) ແລະ ຄ່າຄວາມຜັນຜວນ ($v_t$) ປຽບເໝືອນການໃສ່ເກີບຕິດລໍ້ (Rollerblades) ທີ່ມີລະບົບເບຣກອັດຕະໂນມັດ, ເຮັດໃຫ້ແລ່ນຜ່ານທາງລຽບໄດ້ໄວ ແລະ ຫຼຸດຄວາມໄວເມື່ອຮອດທາງໂຄ້ງ.

4. ຕົວຢ່າງການຂຽນໂຄດດ້ວຍ PyTorch: ພະຍາກອນລະດັບນ້ຳຂອງ

ລອງມາເບິ່ງການນຳໃຊ້ Gradient Descent ໃນການສ້າງໂມເດວ Neural Network ງ່າຍໆເພື່ອພະຍາກອນ ລະດັບນ້ຳຂອງທີ່ນະຄອນຫຼວງວຽງຈັນ ໂດຍອ້າງອີງຈາກປະລິມານນ້ຳຝົນຢູ່ທາງພາກເໜືອ (ເຊັ່ນ: ຫຼວງພະບາງ ຫຼື ໄຊຍະບູລີ).

ໃນຕົວຢ່າງນີ້ເຮົາຈະໃຊ້ Framework ຍອດນິຍົມຄື PyTorch.

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 1. ຈຳລອງຂໍ້ມູນ (Simulated Data)
# X: ປະລິມານນ້ຳຝົນຢູ່ຫຼວງພະບາງ (mm), y: ລະດັບນ້ຳຂອງຢູ່ວຽງຈັນ (m)
np.random.seed(42)
X_data = np.random.rand(100, 1) * 10 
# ສົມມຸດຕິຖານສົມຜົນແທ້ຈິງຄື y = 2.5X + 1.2 ແຕ່ມີ Noise
y_data = 2.5 * X_data + 1.2 + np.random.randn(100, 1) * 0.5 

# ປ່ຽນຂໍ້ມູນ Numpy ໃຫ້ເປັນ PyTorch Tensors
X = torch.tensor(X_data, dtype=torch.float32)
y = torch.tensor(y_data, dtype=torch.float32)

# 2. ສ້າງ Neural Network Architecture ນ້ອຍໆ
class MekongWaterForecast(nn.Module):
    def __init__(self):
        super(MekongWaterForecast, self).__init__()
        # ເນື່ອງຈາກຄວາມສຳພັນງ່າຍດາຍ, ໃຊ້ພຽງ 1 Linear Layer
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        return self.linear(x)

model = MekongWaterForecast()

# 3. ກຳນົດ Loss Function ແລະ Optimizer
# ໃຊ້ Mean Squared Error (MSE) ເພື່ອວັດແທກຄວາມຜິດພາດ
criterion = nn.MSELoss()

# ໃຊ້ Adam Optimizer ທີ່ເປັນ Advanced Gradient Descent
# ນຳໃຊ້ Learning Rate (alpha) = 0.1
optimizer = optim.Adam(model.parameters(), lr=0.1)

# 4. Training Loop (ຂະບວນການລົງພູເບ້ຍ)
epochs = 100
for epoch in range(epochs):
    # a. ລ້າງຄ່າ gradients ເກົ່າອອກກ່ອນ (Clear previous gradients)
    optimizer.zero_grad() 
    
    # b. Forward Pass: ໃຫ້ໂມເດວລອງທຳນາຍລະດັບນ້ຳ
    outputs = model(X)    
    
    # c. ຄິດໄລ່ຄ່າ Loss (ປຽບທຽບການທຳນາຍ ກັບ ລະດັບນ້ຳໂຕຈິງ)
    loss = criterion(outputs, y) 
    
    # d. Backward Pass: ຄິດໄລ່ Partial Derivatives ດ້ວຍ Backpropagation
    loss.backward()       
    
    # e. Optimization: ກ້າວລົງພູ (ອັບເດດ Weights ແລະ Biases ຕາມສູດຄະນິດສາດ)
    optimizer.step()      

    # ສະແດງຜົນທຸກໆ 20 ບາດກ້າວ
    if (epoch+1) % 20 == 0:
        print(f'Epoch [{epoch+1}/{epochs}], Loss ຄວາມຜິດພາດ: {loss.item():.4f}')

# ພິມຄ່າ Weight ທີ່ໂມເດວຮຽນຮູ້ໄດ້ ເຊິ່ງຄວນຈະໃກ້ຄຽງກັບທິດສະດີ (W~2.5, b~1.2)
[w, b] = model.parameters()
print(f"Learned Weight: {w[0][0].item():.4f}, Learned Bias: {b[0].item():.4f}")

ສິ່ງທີ່ເກີດຂຶ້ນໃນໂຄດຂ້າງເທິງ: ຟັງຊັນ loss.backward() ແມ່ນໂຕທີ່ເຮັດໜ້າທີ່ສ້າງ Chain Rule Derivatives ຜ່ານເຕັກນິກທີ່ເອີ້ນວ່າ Backpropagation ໂດຍອັດຕະໂນມັດ, ແລະ optimizer.step() ແມ່ນການນຳໃຊ້ສູດ Gradient Descent ທີ່ເຮົາໄດ້ກ່າວມາຂ້າງເທິງເພື່ອປັບປຸງຄ່າປາຣາມິເຕີຂອງການພະຍາກອນນ້ຳ.

5. Key Takeaways (ສິ່ງສຳຄັນທີ່ຄວນຈື່)

• Gradient Descent ຄືກົນໄກທີ່ຂັບເຄື່ອນໃຫ້ AI ສາມາດຮຽນຮູ້ໄດ້ຈາກຄຳຕອບທີ່ຜິດພາດ.
• Partial Derivatives ຊ່ວຍບອກທິດທາງ (ຄວາມຊັນ) ແລະ Learning Rate ບອກເຖິງຂະໜາດບາດກ້າວ.
• Loss Landscape ຂອງ Deep Neural Networks ແມ່ນສະລັບຊັບຊ້ອນຫຼາຍ. Optimizer ຂັ້ນສູງເຊັ່ນ Adam ຫຼື RMSprop ຈຶ່ງຖືກນຳໃຊ້ແທນ SGD ແບບທຳມະດາ ເພື່ອຫຼີກລ້ຽງການຕິດຢູ່ໃນດັກ Local Minima ໄດ້ດີກວ່າ.
• ການຕັ້ງຄ່າ Hyperparameter (ເຊັ່ນ ຈຳນວນ Batch Size ແລະ Learning rate) ຍັງຄົງເປັນສິລະປະທີ່ຮຽກຮ້ອງປະສົບການຂອງ Machine Learning Engineer.

ສະຫຼຸບແລ້ວ, Neural Networks ບໍ່ແມ່ນກ່ອງດຳ (Black box) ທີ່ເຮັດວຽກດ້ວຍເວດມົນຄາຖາ. ແຕ່ພັດເປັນກຸ່ມກ້ອນຂອງຕົວເລກມະຫາສານທີ່ຖືກປັບແຕ່ງເທື່ອລະເລັກເທື່ອລະນ້ອຍດ້ວຍຄະນິດສາດຊັ້ນສູງແຫ່ງສະຖິຕິ ແລະ ແຄລຄູລັດ (Calculus). ເມື່ອເຮົາເຂົ້າໃຈຫຼັກການຂອງ Gradient Descent ຢ່າງເລິກເຊິ່ງແລ້ວ, ບໍ່ວ່າຈະເປັນການພະຍາກອນປະລິມານຜົນຜະລິດກະສິກຳຢູ່ປາກຊ່ອງ ຫຼື ວິເຄາະຮູບແບບລົດຕິດໃນວຽງຈັນ ເຮົາກໍ່ສາມາດຈູນ (Tune) ໂມເດວໃຫ້ແກ້ໄຂບັນຫາເຫຼົ່ານັ້ນໄດ້ຢ່າງມີປະສິດທິຜົນ.