Réseaux antagonistes génératifs pour la génération de texte

Deep Learning pour le texte avec PyTorch

Shubham Jain

Instructor

Les GAN et leur rôle dans la génération de texte

"- Les GANs peuvent générer de nouveaux contenus qui semblent originaux

Préservent les similarités statistiques {{2}}
- Peuvent reproduire des motifs complexes impossibles à atteindre avec les RNN
- Peuvent émuler des schémas du monde réel

Données originales vers données synthétiques {{1}}"

Structure d’un GAN

"- Un GAN comporte deux composants :

Générateur : crée des échantillons factices en ajoutant du bruit
Discriminateur : différencie les données textuelles réelles des données générées

Structure des GAN {{3}}"

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

"Créer un modèle GAN avec PyTorch : Générateur"

"`python

Embedding reviews

Convert reviews to tensors


----CODE_GLUE----
```python
class Generator(nn.Module):
    def __init__(self):
        super().__init__()

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

----CODE_GLUE---- python def forward(self, x): return self.model(x){{4}}"

Construction du réseau discriminateur

"`python class Discriminateur(nn.Module): def init(self): super().init()


----CODE_GLUE----
```python
        self.model = nn.Sequential(
            nn.Linear(seq_length, 1),
            nn.Sigmoid()
        )

----CODE_GLUE---- python def forward(self, x): return self.model(x){{3}}"

Initialisation des réseaux et de la fonction de perte

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)

Entraînement du discriminateur

"`python num_epochs = 50 for epoch in range(num_epochs):


----CODE_GLUE----
```python
    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()

----CODE_GLUE---- python optimizer_disc.step(){{9}}"

Entraînement du générateur

"`python

   # ... (continued from last slide)
    disc_fake = discriminateur(fake_data)


----CODE_GLUE----
```python
        loss_gen = critère(disc_fake, torch.ones_like(disc_fake))

        optimiseur_gen.zero_grad()

        loss_gen.backward()

        optimiseur_gen.step()


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

----CODE_GLUE---- python print(f\"Époque {epoch+1}/{num_epochs}:\t Perte du générateur : {loss_gen.item()}\t Perte du discriminateur : {loss_disc.item()}\"){{7}}"

Impression des données réelles et générées

"python print(\"\nDonnées réelles : \") print(data[:5])

----CODE_GLUE---- `python

print(\"\nDonnées générées : \") for _ in range(5): noise = torch.rand((1, seq_length)) generated_data = generator(noise) print(torch.round(generated_data).detach()) `{{2}}"

"GANs : données synthétiques générées"

"out Époque 10/50 : Perte du générateur : 0.8992824673652 Perte du discriminateur : 1.37682652473 Époque 20/50 : Perte du générateur : 0,7347183227539 Perte du discriminateur : 1.390102505683 ... Époque 50/50 : Perte du générateur : 0,7019854784011 Perte du discriminateur : 1.3501529693603"

Données générées

"out Données réelles : 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.]])

Métrique d'évaluation : matrice de corrélation {{1}}"

"out Données générées : 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.]])"

Passons à la pratique !

Deep Learning pour le texte avec PyTorch