Redes generativas antagónicas para la generación de texto

Deep Learning para texto con PyTorch

Shubham Jain

Instructor

Las GAN y su papel en la generación de texto

"- Las GAN pueden generar contenido nuevo que parece original

Conserva similitudes estadísticas {{2}}
- Puede replicar patrones complejos inalcanzables para las RNN
- Puede emular patrones del mundo real

De datos originales a datos sintéticos {{1}}"

Estructura de una GAN

"- Una GAN tiene dos componentes:

Generador: crea muestras falsas añadiendo ruido
Discriminador: diferencia entre datos de texto reales y generados

Estructura de las GANs {{3}}"

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

"Crear un modelo GAN en PyTorch: Generador"

"`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}}"

Construcción de la red discriminadora

"`python class Discriminador(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}}"

Inicializando redes y función de pérdida

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)

Entrenamiento del discriminador

"`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}}"

Entrenamiento del generador

"`python

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


----CODE_GLUE----
```python
        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:

----CODE_GLUE---- python print(f\"Época {epoch+1}/{num_epochs}:\t Pérdida del generador: {loss_gen.item()}\t Pérdida del discriminador: {loss_disc.item()}\"){{7}}"

Impresión de datos reales y generados

"python print(\"\nDatos reales: \") print(data[:5])

----CODE_GLUE---- `python

print(\"\nDatos generados: \") for _ in range(5): noise = torch.rand((1, seq_length)) generated_data = generator(noise) print(torch.round(generated_data).detach()) `{{2}}"

"GANs: datos sintéticos generados"

"out Época 10/50: Pérdida del generador: 0.8992824673652 Pérdida del discriminador: 1.37682652473 Época 20/50: Pérdida del generador: 0.7347183227539 Pérdida del discriminador: 1.390102505683 ... Época 50/50: Pérdida del generador: 0.7019854784011 Pérdida del discriminador: 1.3501529693603"

Datos generados

"out Datos reales: 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étrica de evaluación: matriz de correlación {{1}}"

"out Datos generados: 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.]])"

Es hora de la práctica.

Deep Learning para texto con PyTorch