Cách Dễ Hiểu Về Mạng GAN trong PyTorch cho Người Mới Bắt Đầu

I. Giới thiệu về Mạng GAN (Generative Adversarial Networks) A. Định nghĩa và các thành phần chính của GAN

GAN là một lớp các mô hình học máy gồm hai mạng nơ-ron, một mạng sinh và một mạng phân biệt, được huấn luyện theo một quá trình cạnh tranh.
Mạng sinh có nhiệm vụ tạo ra các mẫu giống thực (ví dụ: hình ảnh, văn bản, âm thanh) từ không gian đầu vào ẩn.
Mạng phân biệt được huấn luyện để phân biệt giữa các mẫu thực từ tập dữ liệu và các mẫu giả do mạng sinh tạo ra.
Hai mạng được huấn luyện theo một quá trình cạnh tranh, với mạng sinh cố gắng đánh lừa mạng phân biệt và mạng phân biệt cố gắng phân loại đúng các mẫu thực và giả.

B. Lịch sử và sự phát triển của GAN

GAN được giới thiệu lần đầu vào năm 2014 bởi Ian Goodfellow và đồng nghiệp là một phương pháp độc đáo trong mô hình sinh.
Kể từ khi được giới thiệu, GAN đã trải qua những sự phát triển đáng kể và được áp dụng trong nhiều lĩnh vực khác nhau, chẳng hạn như sinh hình ảnh, sinh văn bản và thậm chí tổng hợp âm thanh.
Một số cột mốc quan trọng trong sự phát triển của GAN bao gồm việc giới thiệu các GAN có điều kiện (cGANs), GANs với các lớp tích chập sâu (DCGANs), GANs Wasserstein (WGANs) và GANs với quá trình mở rộng tiến bộ (PGGANs).

II. Thiết lập Môi trường PyTorch A. Cài đặt PyTorch

PyTorch là thư viện học máy mã nguồn mở phổ biến cung cấp một framework linh hoạt và hiệu quả cho việc xây dựng và huấn luyện các mô hình học sâu, bao gồm cả GAN.
Để cài đặt PyTorch, bạn có thể làm theo hướng dẫn cài đặt chính thức được cung cấp trên trang web của PyTorch (https://pytorch.org/get-started/locally/ (opens in a new tab)).
Quá trình cài đặt có thể khác nhau tuỳ thuộc vào hệ điều hành, phiên bản Python và phiên bản CUDA (nếu sử dụng GPU).

B. Nhập các thư viện và module cần thiết

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

III. Hiểu về Kiến trúc GAN A. Mạng Sinh

Cấu trúc đầu vào và đầu ra
- Mạng sinh nhận một vector đầu vào ẩn (ví dụ: vector nhiễu ngẫu nhiên) và xuất ra mẫu được tạo (ví dụ: một hình ảnh).
- Kích thước của vector đầu vào ẩn và mẫu đầu ra phụ thuộc vào vấn đề cụ thể và kết quả mong muốn.
Các lớp mạng và hàm kích hoạt
- Mạng sinh thường bao gồm một chuỗi các lớp kết nối hoàn toàn hoặc tích chập, phụ thuộc vào miền vấn đề cụ thể.
- Các hàm kích hoạt như ReLU, Leaky ReLU hoặc tanh thường được sử dụng trong mạng sinh.
Tối ưu hóa cho Mạng Sinh
- Mạng sinh được huấn luyện để tạo ra các mẫu có thể đánh lừa mạng phân biệt.
- Hàm mất mát cho mạng sinh được thiết kế để tối đa hóa xác suất mạng phân biệt phân loại nhầm các mẫu được tạo ra là thực tế.

B. Mạng Phân biệt

Cấu trúc đầu vào và đầu ra
- Mạng phân biệt nhận một mẫu (thực từ tập dữ liệu hoặc được tạo bởi mạng sinh) và xuất ra một xác suất cho mẫu đó là thực tế.
- Kích thước đầu vào của mạng phân biệt phụ thuộc vào kích thước của các mẫu (ví dụ: kích thước hình ảnh), và kết quả là một giá trị số từ 0 đến 1.
Các lớp mạng và hàm kích hoạt
- Mạng phân biệt thường bao gồm một chuỗi các lớp tích chập hoặc kết nối hoàn toàn, phụ thuộc vào miền vấn đề cụ thể.
- Các hàm kích hoạt như Leaky ReLU hoặc sigmoid thường được sử dụng trong mạng phân biệt.
Tối ưu hóa cho Mạng Phân biệt
- Mạng phân biệt được huấn luyện để phân loại chính xác các mẫu thực từ tập dữ liệu là thực và các mẫu được tạo ra là giả.
- Hàm mất mát cho mạng phân biệt được thiết kế để tối đa hóa xác suất phân loại chính xác các mẫu thực và giả.

C. Quá trình Huấn luyện Cạnh tranh Adversarial Training

Hàm mất mát cho Mạng Sinh và Mạng Phân biệt
- Hàm mất mát cho mạng sinh được thiết kế để tối đa hóa xác suất mạng phân biệt phân loại các mẫu được tạo ra là thực tế.
- Hàm mất mát cho mạng phân biệt được thiết kế để tối đa hóa xác suất phân loại chính xác các mẫu thực và giả.
Tối ưu hóa luân phiên giữa Mạng Sinh và Mạng Phân biệt
- Quá trình huấn luyện liên quan đến sự thay đổi luân phiên giữa việc cập nhật mạng sinh và mạng phân biệt.
- Trước tiên, mạng phân biệt được huấn luyện để cải thiện khả năng phân biệt các mẫu thực và giả.
- Sau đó, mạng sinh được huấn luyện để cải thiện khả năng tạo ra các mẫu có thể đánh lừa mạng phân biệt.
- Quá trình huấn luyện cạnh tranh này tiếp tục cho đến khi mạng sinh và mạng phân biệt đạt đến sự cân bằng.

IV. Thực thi một GAN Đơn giản trong PyTorch A. Xác định các mô hình Mạng Sinh và Mạng Phân biệt

Xây dựng Mạng Sinh

class Generator(nn.Module):
    def __init__(self, latent_dim, img_shape):
        super(Generator, self).__init__()
        self.latent_dim = latent_dim
        self.img_shape = img_shape
 
        self.model = nn.Sequential(
            nn.Linear(self.latent_dim, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, np.prod(self.img_shape)),
            nn.Tanh()
        )
 
    def forward(self, z):
        img = self.model(z)
        img = img.view(img.size(0), *self.img_shape)
        return img

Xây dựng Mạng Phân biệt

class Discriminator(nn.Module):
    def __init__(self, img_shape):
        super(Discriminator, self).__init__()
        self.img_shape = img_shape
 
        self.model = nn.Sequential(
            nn.Linear(np.prod(self.img_shape), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
 
    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        validity = self.model(img_flat)
        return validity

B. Thiết lập vòng lặp huấn luyện

Khởi tạo các Mạng Sinh và Mạng Phân biệt

latent_dim = 100
img_shape = (1, 28, 28)  # Ví dụ cho tập dữ liệu MNIST
 
generator = Generator(latent_dim, img_shape)
discriminator = Discriminator(img_shape)

Xác định các hàm mất mát

adversarial_loss = nn.BCELoss()
 
def generator_loss(fake_output):
    return adversarial_loss(fake_output, torch.ones_like(fake_output))
 
def discriminator_loss(real_output, fake_output):
    real_loss = adversarial_loss(real_output, torch.ones_like(real_output))
    fake_loss = adversarial_loss(fake_output, torch.zeros_like(fake_output))
    return (real_loss + fake_loss) / 2

Luân phiên tối ưu hóa của Mạng Sinh và Mạng Phân biệt

num_epochs = 200
batch_size = 64
 
# Bộ tối ưu hóa
generator_optimizer = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
discriminator_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))
 
for epoch in range(num_epochs):
    # Huấn luyện mạng phân biệt
    discriminator.zero_grad()
    real_samples = next(iter(dataloader))[0]
    real_output = discriminator(real_samples)
    fake_noise = torch.randn(batch_size, latent_dim)
    fake_samples = generator(fake_noise)
    fake_output = discriminator(fake_samples.detach())
    d_loss = discriminator_loss(real_output, fake_output)
    d_loss.backward()
    discriminator_optimizer.step()
 
    # Huấn luyện mạng sinh
    generator.zero_grad()
    fake_noise = torch.randn(batch_size, latent_dim)
    fake_samples = generator(fake_noise)
    fake_output = discriminator(fake_samples)
    g_loss = generator_loss(fake_output)
    g_loss.backward()
    generator_optimizer.step()

C. Theo dõi tiến trình huấn luyện

Trực quan hóa các mẫu được tạo ra

# Tạo các mẫu và vẽ chúng
fake_noise = torch.randn(64, latent_dim)
fake_samples = generator(fake_noise)
plt.figure(figsize=(8, 8))
plt.axis("off")
plt.imshow(np.transpose(vutils.make_grid(fake_samples.detach()[:64], padding=2, normalize=True), (1, 2, 0)))
plt.show()

Đánh giá hiệu suất của GAN
- Đánh giá hiệu suất của một GAN có thể khó khăn, vì không có một số liệu duy nhất nào mô tả tất cả các khía cạnh của các mẫu được tạo ra.
- Các độ đo thông thường bao gồm Inception Score (IS) và Fréchet Inception Distance (FID), đo lường chất lượng và đa dạng của các mẫu được tạo ra.

V. GAN có Điều kiện (cGANs) A. Động cơ và ứng dụng của cGANs- Các mạng cGAN (Conditional GANs) là một phần mở rộng của framework GAN tiêu chuẩn cho phép tạo ra các mẫu được điều kiện trên thông tin đầu vào cụ thể, chẳng hạn như nhãn lớp, mô tả văn bản hoặc dữ liệu phụ khác.

cGANs có thể hữu ích trong các ứng dụng khi bạn muốn tạo ra các mẫu với thuộc tính hoặc đặc điểm cụ thể, chẳng hạn như tạo ra hình ảnh của một đối tượng lớp cụ thể hoặc tạo ra các bản dịch từ văn bản sang hình ảnh.

B. Sửa đổi kiến trúc GAN để tạo ra theo điều kiện

Kết hợp thông tin nhãn vào Bộ tạo và Bộ phân biệt
- Trong cGAN, các mạng tạo và phân biệt được sửa đổi để nhận một đầu vào bổ sung, đó là thông tin điều kiện (ví dụ: nhãn lớp, mô tả văn bản).
- Điều này có thể được đạt được bằng cách nối đầu vào điều kiện với đầu vào tiềm tàng cho bộ tạo và với mẫu thực/giả cho bộ phân biệt.
Xác định hàm mất mát cho cGANs
- Các hàm mất mát cho bộ tạo và bộ phân biệt trong cGANs tương tự như GAN tiêu chuẩn, nhưng chúng cũng xem xét thông tin điều kiện.
- Ví dụ, hàm mất mát của bộ phân biệt sẽ nhằm mục đích phân loại chính xác các mẫu thực và mẫu giả, dựa vào thông tin nhãn đã cung cấp.

C. Thực hiện một cGAN trong PyTorch

Xác định các mô hình cGAN

lớp ConditionalGenerator(nn.Module):
    def __init__(self, latent_dim, num_classes, img_shape):
        super(ConditionalGenerator, self).__init__()
        self.latent_dim = latent_dim
        self.num_classes = num_classes
        self.img_shape = img_shape
 
        self.model = nn.Sequential(
            nn.Linear(self.latent_dim + self.num_classes, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, np.prod(self.img_shape)),
            nn.Tanh()
        )
 
    def forward(self, z, labelsTrong hướng dẫn này, bạn đã tìm hiểu về các thành phần chính trong quá trình huấn luyện mô hình học sâu, bao gồm bộ tối ưu hóa (optimizers), hàm mất mát (loss functions), chỉ số đánh giá (evaluation metrics), kỹ thuật chính quy hóa (regularization techniques) và lưu và tải mô hình (model saving and loading). Bằng cách hiểu những khái niệm này và áp dụng chúng vào các dự án học sâu của riêng bạn, bạn sẽ có khả năng xây dựng và huấn luyện những mô hình hiệu suất cao có khả năng giải quyết nhiều vấn đề khác nhau.

Hãy nhớ rằng học sâu là một lĩnh vực luôn thay đổi, luôn cập nhật. Hãy tiếp tục khám phá, thử nghiệm và cập nhật những tiến bộ mới nhất trong lĩnh vực này. Chúc bạn may mắn trong những công việc học sâu trong tương lai!

Cách Tinh chỉnh LLaMA2 Nhanh chóng và Dễ dàng Cách nhanh chóng chọn GPU cho Deep Learning