ອະທິບາຍ Generative Adversarial Networks (GANs): ເມື່ອສອງ Neural Networks ແຂ່ງຂັນກັນສ້າງຂໍ້ມູນສະເໝືອນຈິງ

ໂພສເມື່ອ 2025-03-27 # Deep Learning # Generative AI # Neural Networks —

ອະທິບາຍ Generative Adversarial Networks (GANs): ເມື່ອສອງ Neural Networks ແຂ່ງຂັນກັນສ້າງຂໍ້ມູນສະເໝືອນຈິງ

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

ນັ້ນຄືຫຼັກການພື້ນຖານຂອງ Generative Adversarial Networks (GANs). ໃນຖານະນັກພັດທະນາ ຫຼື ນັກສຶກສາທີ່ມີພື້ນຖານດ້ານ Deep Learning ມາແລ້ວ, ມື້ນີ້ພວກເຮົາຈະມາເຈາະເລິກເຖິງສະຖາປັດຕະຍະກຳ, ສົມຜົນທາງຄະນິດສາດ, ແລະ ການຂຽນໂຄດດ້ວຍ PyTorch ເພື່ອສ້າງ GANs ດ້ວຍຕົວເອງ.

ຫຼັກການເຮັດວຽກຂອງ GANs ແລະ ສົມຜົນ Minimax

GANs ປະກອບດ້ວຍ 2 ໂຄງຂ່າຍປະສາດທຽມ (Neural Networks) ທີ່ເຮັດວຽກແບບປໍລະປັກ (Adversarial) ຕໍ່ກັນ:

Generator ( $G$ ): ຮັບເອົາຂໍ້ມູນສັນຍານລົບກວນແບບສຸ່ມ (Random Noise ຈາກ Latent Space) ໂດຍປົກກະຕິຈະແທນດ້ວຍ $z$ , ຈາກນັ້ນປ່ຽນໃຫ້ກາຍເປັນຂໍ້ມູນທີ່ຄ້າຍຄືກັບຂໍ້ມູນຈິງ $G(z)$ .
Discriminator ( $D$ ): ເຮັດໜ້າທີ່ເປັນ Binary Classifier ທີ່ຮັບເອົາຂໍ້ມູນເຂົ້າ (ມີທັງຂໍ້ມູນຈິງ $x$ ແລະ ຂໍ້ມູນທີ່ $G$ ສ້າງຂຶ້ນ), ແລ້ວທຳນາຍຄ່າຄວາມໜ້າຈະເປັນ (Probability) ທີ່ຂໍ້ມູນນັ້ນຈະເປັນ “ຂອງຈິງ”.

ສົມຜົນທາງຄະນິດສາດ (The Minimax Game)

ການຝຶກອົບຮົມ (Training) GANs ຖືກກຳນົດດ້ວຍສົມຜົນ Value Function $V(G, D)$ :

$\min_G \max_D V(D, G) = \mathbb{E}_{x \sim p_{data}(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log(1 - D(G(z)))]$

$\mathbb{E}_{x \sim p_{data}(x)}$ : ຄ່າຄາດໝາຍ (Expected value) ຂອງຂໍ້ມູນຈິງ.
$D(x)$ : ຄວາມໜ້າຈະເປັນທີ່ $D$ ປະເມີນວ່າ $x$ ແມ່ນຂໍ້ມູນຈິງ (ຕ້ອງການໃຫ້ເຂົ້າໃກ້ 1).
$G(z)$ : ຂໍ້ມູນທີ່ Generator ສ້າງຂຶ້ນຈາກ Noise $z$ .
$D(G(z))$ : ຄວາມໜ້າຈະເປັນທີ່ $D$ ຈະທຳນາຍວ່າຮູບທີ່ສ້າງຂຶ້ນມາເປັນຂອງຈິງ.
ເປົ້າໝາຍຂອງ D ຄືການ Maximize ສົມຜົນນີ້ (ຈັບຜິດໃຫ້ໄດ້).
ເປົ້າໝາຍຂອງ G ຄືການ Minimize $\log(1 - D(G(z)))$ (ຫຼອກ D ໃຫ້ສຳເລັດ).

ບໍລິບົດການນຳໃຊ້ GANs ໃນປະເທດລາວ: ຂໍ້ມູນສຳລັບກະສິກຳປາກຊ່ອງ

ໜຶ່ງໃນອຸປະສັກໃຫຍ່ຂອງ AI ໃນລາວຄື “ການຂາດແຄນຂໍ້ມູນ (Data Scarcity)“. ສົມມຸດວ່າທີມນັກວິໄຈລາວກຳລັງພັດທະນາ AI ສຳລັບກວດຈັບພະຍາດໃບກາເຟຢູ່ເມືອງປາກຊ່ອງ ແຕ່ມີຮູບພາບໃບກາເຟທີ່ເປັນພະຍາດ (ເຊັ່ນ: ເຊື້ອຣາໃບດ່າງ) ໜ້ອຍຫຼາຍ (Imbalanced Dataset).

ໃນກໍລະນີແບບນີ້, ເຮົາສາມາດໃຊ້ GANs ເພື່ອຮຽນຮູ້ຮູບແບບຂອງໃບກາເຟທີ່ເປັນພະຍາດ, ແລ້ວ “ສ້າງຮູບພາບໃບກາເຟທີ່ເປັນພະຍາດແບບສະເໝືອນຈິງ (Synthetic images)” ອອກມາອີກຫຼາຍພັນຮູບ ເພື່ອໃຊ້ສອນ (Train) ໂມເດລ Computer Vision (CNN) ໃຫ້ມີຄວາມແມ່ນຍໍາຂຶ້ນ ໂດຍບໍ່ຕ້ອງລໍຖ້າລົງເກັບຂໍ້ມູນຕົວຈິງເພີ່ມຕື່ມ.

ການສ້າງ GAN ດ້ວຍ PyTorch (Step-by-Step)

ເຮົາມາເບິ່ງໂຄງສ້າງລະດັບ Advanced ຂອງການສ້າງ GAN ແບບພື້ນຖານ (Multilayer Perceptrons - MLP) ໂດຍໃຊ້ PyTorch.

1. ສ້າງ Generator ແລະ Discriminator

import torch
import torch.nn as nn

# ກຳນົດຂະໜາດຂອງ Latent space (Noise) ແລະ ຂໍ້ມູນ (Image)
latent_dim = 100
img_size = 28 * 28 # ສົມມຸດວ່າສ້າງຮູບຂະໜາດ 28x28 pixels

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm1d(256),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm1d(512),
            nn.Linear(512, img_size),
            nn.Tanh() # ຜົນໄດ້ຮັບຢູ່ລະຫວ່າງ [-1, 1]
        )

    def forward(self, z):
        return self.model(z)

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(img_size, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid() # ອອກເປັນຄ່າຄວາມໜ້າຈະເປັນ (0 ຫາ 1)
        )

    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        return self.model(img_flat)

2. ການອັບເດດໂມເດລ (Training Loop)

ເຕັກນິກທີ່ສຳຄັນແມ່ນເຮົາຕ້ອງແຍກການອັບເດດ (Backpropagation) ລະຫວ່າງ $D$ ແລະ $G$ . ເຮົາຈະໃຊ້ Binary Cross Entropy Loss (BCELoss) ແທນຄະນິດສາດຂ້າງເທິງ.

# ສ້າງ Instances ແລະ Optimizers
generator = Generator()
discriminator = Discriminator()
criterion = nn.BCELoss()
optimizer_G = torch.optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))

# ຕົວຢ່າງການ Train ໃນ 1 Batch
def train_step(real_imgs):
    batch_size = real_imgs.size(0)
    
    # Label ສຳລັບຂໍ້ມູນຈິງ (1) ແລະ ປອມ (0)
    real_labels = torch.ones(batch_size, 1)
    fake_labels = torch.zeros(batch_size, 1)

    # ==========================
    # 1. ຝຶກອົບຮົມ Discriminator
    # ==========================
    optimizer_D.zero_grad()
    
    # Loss ຈາກຂໍ້ມູນຈິງ
    outputs_real = discriminator(real_imgs)
    d_loss_real = criterion(outputs_real, real_labels)
    
    # Loss ຈາກຂໍ້ມູນປອມ
    z = torch.randn(batch_size, latent_dim)
    fake_imgs = generator(z)
    outputs_fake = discriminator(fake_imgs.detach()) # ຕັດ gradient ຂອງ generator ອອກ
    d_loss_fake = criterion(outputs_fake, fake_labels)
    
    # ລວມ Loss ແລະ ອັບເດດ D
    d_loss = d_loss_real + d_loss_fake
    d_loss.backward()
    optimizer_D.step()

    # ==========================
    # 2. ຝຶກອົບຮົມ Generator
    # ==========================
    optimizer_G.zero_grad()
    
    # Generator ພະຍາຍາມຫລອກໃຫ້ D ຕອບວ່າ fake_imgs ຄືຂອງຈິງ (1)
    outputs = discriminator(fake_imgs)
    g_loss = criterion(outputs, real_labels) 
    
    g_loss.backward()
    optimizer_G.step()
    
    return d_loss.item(), g_loss.item()

ສິ່ງທີ່ຄວນລະວັງ ແລະ ຂໍ້ຈໍາກັດຂອງ GANs

ການ Train GANs ເປັນເລື່ອງທີ່ທ້າທາຍ (Notoriously unstable) ໂດຍມີບັນຫາຫຼັກໆຄື:

Mode Collapse: ເກີດຂຶ້ນເມື່ອ Generator ຄົ້ນພົບຊ່ອງໂຫວ່ຂອງ Discriminator ໂດຍການສ້າງຮູບແບບດຽວຊໍ້າໆກັນ. ເຊັ່ນ: ຖ້າໃຫ້ສ້າງລາຍສິ້ນ, ມັນຈະອອກແບບແຕ່ຮູບ “ລາຍນາກ” ແບບດຽວ ບໍ່ມີຄວາມຫຼາກຫຼາຍ (Lack of diversity).
Vanishing Gradients: ຖ້າ Discriminator ເກັ່ງໄວເກີນໄປ ແລະ ຈັບຜິດໄດ້ 100%, ມັນຈະບໍ່ມີ Gradient ສົ່ງກັບໄປໃຫ້ Generator ປັບປຸງຕົວເອງ ເຮັດໃຫ້ການ Train ຢຸດຊະງັກທັນທີ. (ປັດຈຸບັນມັກແກ້ດ້ວຍການໃຊ້ Wasserstein GAN ຫຼື WGAN).

ຈຸດສຳຄັນທີ່ຄວນຈື່ (Key Takeaways)

GANs ສາມາດປະຕິວັດການສ້າງຂໍ້ມູນກຸ່ມ Data Augmentation, ຊ່ວຍແກ້ບັນຫາການຂາດແຄນຂໍ້ມູນໃນການພັດທະນາ AI ໃນລາວ ໂດຍສະເພາະວຽກງານສະເພາະທາງເຊັ່ນ: ກະສິກຳ, ການແພດ ແລະ ສິນລະປະວັດທະນະທຳ.
ຫົວໃຈຫຼັກແມ່ນ “Minimax Game” ລະຫວ່າງການ Optimize G ແລະ D.
ການຮັກສາຄວາມສົມດຸນ (Equilibrium) ຂອງ Loss ລະຫວ່າງສອງເຄືອຂ່າຍແມ່ນກຸນແຈສຳຄັນທີ່ສຸດໃນການ Train GANs ໃຫ້ສຳເລັດ.

ສະຫຼຸບແລ້ວ, GANs ແມ່ນໜຶ່ງໃນສະຖາປັດຕະຍະກຳທີ່ສະຫຼາດທີ່ສຸດໃນໂລກຂອງ Deep Learning. ເຖິງແມ່ນວ່າປັດຈຸບັນ Diffusion Models ຈະເລີ່ມເຂົ້າມາແທນທີ່ໃນວຽກງານການສ້າງຮູບພາບ, ແຕ່ຄວາມເຂົ້າໃຈກ່ຽວກັບ Adversarial Training ຍັງຄົງເປັນພື້ນຖານທີ່ຈຳເປັນທີ່ສຸດສຳລັບນັກວິໄຈ AI ທຸກຄົນທີ່ຕ້ອງການຍົກລະດັບຂີດຄວາມສາມາດຂອງເຕັກໂນໂລຊີພາຍໃນປະເທດລາວ.