Introduction à la génération de texte

Deep Learning pour le texte avec PyTorch

Shubham Jain

Instructor

Génération de texte et TAL

"- Applications clés : chatbots, traduction automatique, rédaction technique

RNN, LSTM, GRU : mémorisation des informations passées pour un meilleur traitement des données séquentielles
Entrée : Le chat est sur le m
Output: Le chat est sur le tapis {{4}}"

" Image de chatbot {{1}}"

¹ Image par vectorjuice sur Freepik

Créer un RNN pour la génération de texte

"`python import torch import torch.nn as nn


----CODE_GLUE----
```python
data = \"Bonjour comment ça va ?\"
chars = list(set(data))  
char_to_ix = {char: i for i, char in enumerate(chars)}
ix_to_char = {i: char for i, char in enumerate(chars)}

class RNNModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNNModel, self).__init__()
        self.hidden_size = hidden_size

        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)

----CODE_GLUE---- python self.fc = nn.Linear(hidden_size, output_size){{5}}"

Propagation avant et création du modèle

"`python def forward(self, x):


----CODE_GLUE----
```python
        h0 = torch.zeros(1, x.size(0), self.hidden_size)

        out, _ = self.rnn(x, h0)

        out = self.fc(out[:, -1, :])

        return out


model = RNNmodel(1, 16, 1)


criterion = nn.CrossEntropyLoss()

----CODE_GLUE---- python optimizer = torch.optim.Adam(model.parameters(), lr=0.01){{8}}"

Préparation des données d'entrée et des données cibles

inputs = [char_to_ix[ch] for ch in data[:-1]]
targets = [char_to_ix[ch] for ch in data[1:]]



inputs = torch.tensor(inputs, dtype=torch.long)
              .view(-1, 1)



inputs = nn.functional.one_hot(
       inputs, num_classes=len(chars)).float()



targets = torch.tensor(targets, dtype=torch.long)

"- Création d’index

Conversion en tenseur
Encodage One-Hot
Préparation des cibles {{3}}"

Entraînement du modèle RNN

"`python for epoch in range(100):


----CODE_GLUE----
```python
    model.train()

    outputs = model(inputs)

    loss = criterion(outputs, targets)

    optimizer.zero_grad()

    loss.backward()

    optimizer.step()

----CODE_GLUE---- `python

if (epoch+1) % 10 == 0:
    print(f'Époque {epoch+1}/100, Perte : {loss.item()}')

`{{10}}"

Tester le modèle

"`python model.eval()


----CODE_GLUE----
```python
test_input = char_to_ix['h']

test_input = nn.functional.one_hot(torch.tensor(test_input)
                               .view(-1, 1), num_classes=len(chars)).float()

predicted_output = model(test_input)
predicted_char_ix = torch.argmax(predicted_output, 1).item()

print(f'Entrée de test : 10, Sortie prédite : {model(test_input).item()}')

Époque 10/100, Perte : 3090.861572265625
Époque 20/100, Perte : 2935.4580078125
...
Époque 100/100, Perte : 1922.44140625

out Entrée de test : h, Sortie prédite : e{{5}}"

Passons à la pratique !

Deep Learning pour le texte avec PyTorch