Mạng đối sinh (GAN) cho sinh văn bản

Deep Learning cho Văn bản với PyTorch

Shubham Jain

Instructor

GAN và vai trò trong sinh văn bản

GAN có thể sinh nội dung mới trông như gốc
- Giữ tương đồng thống kê
Bắt chước mẫu phức tạp mà RNN khó đạt được
Mô phỏng khuôn mẫu ngoài đời thực

Dữ liệu gốc sang dữ liệu tổng hợp

Cấu trúc của GAN

Một GAN gồm hai thành phần:
- Generator: tạo mẫu giả bằng cách thêm nhiễu
- Discriminator: phân biệt dữ liệu văn bản thật và sinh

Cấu trúc GAN

¹ https://www.sciencefocus.com/future-technology/how-do-machine-learning-gans-work/

Xây dựng GAN trong PyTorch: Generator

# Embedding reviews
# Convert reviews to tensors

class Generator(nn.Module):
    def __init__(self):
        super().__init__()

        self.model = nn.Sequential(
            nn.Linear(seq_length, seq_length),
            nn.Sigmoid()
        )

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

Xây dựng mạng phân biệt

class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()

        self.model = nn.Sequential(
            nn.Linear(seq_length, 1),
            nn.Sigmoid()
        )

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

Khởi tạo mạng và hàm mất mát

generator = Generator()

discriminator = Discriminator()


criterion = nn.BCELoss()


optimizer_gen = torch.optim.Adam(generator.parameters(), lr=0.001)
optimizer_disc = torch.optim.Adam(discriminator.parameters(), lr=0.001)

Huấn luyện bộ phân biệt (discriminator)

num_epochs = 50
for epoch in range(num_epochs):

    for real_data in data:
        real_data = real_data.unsqueeze(0)

        noise = torch.rand((1, seq_length))

        disc_real = discriminator(real_data)

        fake_data = generator(noise)
        disc_fake = discriminator(fake_data.detach())

        loss_disc = criterion(disc_real, torch.ones_like(disc_real)) + 
                    criterion(disc_fake, torch.zeros_like(disc_fake))

        optimizer_disc.zero_grad()

        loss_disc.backward()

        optimizer_disc.step()

Huấn luyện bộ sinh (generator)

       # ... (tiếp theo từ trang trước)
        disc_fake = discriminator(fake_data)

        loss_gen = criterion(disc_fake, torch.ones_like(disc_fake))

        optimizer_gen.zero_grad()

        loss_gen.backward()

        optimizer_gen.step()


    if (epoch+1) % 10 == 0:

        print(f"Epoch {epoch+1}/{num_epochs}:\t 
                Generator loss: {loss_gen.item()}\t 
                Discriminator loss: {loss_disc.item()}")

In dữ liệu thật và dữ liệu sinh ra

print("\nReal data: ")
print(data[:5])


print("\nGenerated data: ")
for _ in range(5):
    noise = torch.rand((1, seq_length))
    generated_data = generator(noise)
    print(torch.round(generated_data).detach())

GAN: dữ liệu tổng hợp được sinh ra

Epoch 10/50: Generator loss: 0.8992824673652 Discriminator loss: 1.37682652473
Epoch 20/50: Generator loss: 0.7347183227539 Discriminator loss: 1.390102505683
...
Epoch 50/50: Generator loss: 0.7019854784011 Discriminator loss: 1.3501529693603

Dữ liệu được sinh ra

Real data: 
tensor([[1., 0., 0., 1., 1.], 
        [0., 0., 1., 0., 0.], 
        [1., 0., 1., 1., 1.], 
        [1., 0., 1., 0., 0.], 
        [1., 1., 1., 1., 1.]])

Thước đo đánh giá: ma trận tương quan

Generated data: 
tensor([[0., 1., 1., 0., 0.]]), 
tensor([[0., 1., 1., 1., 1.]])
tensor([[1, 1., 1., 0., 0.]]), 
tensor([[1., 1., 1., 0., 0.]]) 
tensor([[0., 1., 1., 1., 1.]])

Ayo berlatih!

Deep Learning cho Văn bản với PyTorch