Generative adversarial networks voor tekstgeneratie

Deep Learning voor tekst met PyTorch

Shubham Jain

Instructor

GAN's en hun rol in tekstgeneratie

GAN's kunnen nieuwe, origineel lijkende content genereren
- Behoudt statistische overeenkomsten
Kan complexe patronen repliceren die RNN's niet aankunnen
Kan patronen uit de echte wereld emuleren

Originele data naar synthetische data

Structuur van een GAN

Een GAN heeft twee componenten:
- Generator: maakt fakesamples met ruis
- Discriminator: onderscheidt echte en gegenereerde tekstdata

Structuur van GAN's

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

Een GAN-model bouwen in PyTorch: generator

# Embedding van reviews
# Reviews omzetten naar 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)

De discriminator bouwen

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)

Netwerken en verliesfunctie initialiseren

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)

De discriminator trainen

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

De generator trainen

       # ... (vervolg van vorige 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 
                Generatorverlies: {loss_gen.item()}\t 
                Discriminatorverlies: {loss_disc.item()}")

Echte en gegenereerde data afdrukken

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


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

GAN's: synthetische data genereren

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

Gegenereerde data

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

Evaluatiemaatstaf: correlatiematrix

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

Laten we oefenen!

Deep Learning voor tekst met PyTorch