텍스트 생성을 위한 적대적 생성 신경망(GAN)

PyTorch로 배우는 텍스트 딥러닝

Shubham Jain

Instructor

텍스트 생성에서 GAN의 역할

GAN은 그럴듯한 새로운 콘텐츠를 생성합니다
- 통계적 유사성 보존
RNN으로는 어려운 복잡한 패턴을 학습합니다
현실 세계의 패턴을 모사할 수 있습니다

원본 데이터에서 합성 데이터로

GAN의 구조

GAN은 두 구성요소로 이루어집니다:
- 생성자: 노이즈로 가짜 샘플 생성
- 판별자: 실제와 생성 텍스트를 구분

GAN의 구조

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

PyTorch로 GAN 구성: 생성자

# 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)

판별자 네트워크 구성

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)

네트워크와 손실 함수 초기화

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)

판별자 학습

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()

생성자 학습

       # ... (continued from last slide)
        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()}")

실제 데이터와 생성 데이터 출력

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: 합성 데이터 생성 결과

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

생성된 데이터

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.]])

평가 지표: 상관행렬

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.]])

Lass uns üben!

PyTorch로 배우는 텍스트 딥러닝