Mecanismos de atención para la generación de texto

Deep Learning para texto con PyTorch

Shubham Jain

Instructor

La ambigüedad en el procesamiento de texto

"- \"El mono se comió ese plátano porque tenía demasiada hambre\"

¿A qué se refiere la palabra \"él\"?

HumanoVsMáquina "

Mecanismos de atención

"- Asigna importancia a las palabras

Garantiza que la interpretación de la máquina se alinee con la comprensión humana {{2}}"

" Gráfico de atención {{2}}"

¹ Xie, Huiqiang y Qin, Zhijin y Li, Geoffrey y Juang, Biing-Hwang. (2020). Sistemas de comunicación semántica habilitados por aprendizaje profundo

Autoatención y Multi-Head Attention

"- Autoatención: asigna importancia a las palabras dentro de una frase {{1}} - El gato, que estaba en el tejado, se asustó\" {{2}} - Vinculando \"se asustó\" con \"el gato\"

Atención multi-cabeza: como tener varios focos, capturando diferentes facetas {{3}} - Entender \"se asustó\" puede relacionarse con {{4}} - \"el gato\", \"el tejado\" o \"estaba en\" {{4}}"

"Mecanismo de atención: configuración del vocabulario y los datos"

"`python data = [\"el gato se sentó en la alfombra\", ...]


----CODE_GLUE----
```python
vocab = set(' '.join(data).split())

word_to_ix = {word: i for i, word in enumerate(vocab)}
ix_to_word = {i: word for word, i in word_to_ix.items()}

----CODE_GLUE---- python pairs = [sentence.split() for sentence in data] input_data = [[word_to_ix[word] for word in sentence[:-1]] for sentence in pairs] target_data = [word_to_ix[sentence[-1]] for sentence in pairs] inputs = [torch.tensor(seq, dtype=torch.long) for seq in input_data] targets = torch.tensor(target_data, dtype=torch.long){{4}}"

Definición del modelo

"`python embedding_dim = 10 hidden_dim = 16


----CODE_GLUE----
```python

class RNNWithAttentionModel(nn.Module):
    def __init__(self):
        super(RNNWithAttentionModel, self).__init__()

        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.rnn = nn.RNN(embedding_dim, hidden_dim, batch_first=True)

        self.attention = nn.Linear(hidden_dim, 1)

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

Propagación hacia adelante con atención

"python def forward(self, x): x = self.embeddings(x) out, _ = self.rnn(x)

Preparación del entrenamiento

"`python criterion = nn.CrossEntropyLoss()


----CODE_GLUE----
```python
attention_model = RNNWithAttentionModel()
optimizer = torch.optim.Adam(attention_model.parameters(), lr=0.01)

for epoch in range(300):
    attention_model.train()
    optimizer.zero_grad()

    padded_inputs = pad_sequences(inputs)
    outputs = attention_model(padded_inputs)

----CODE_GLUE---- python loss = criterion(outputs, targets) loss.backward() optimizer.step(){{5}}"

Evaluación del modelo

"`python for input_seq, target in zip(input_data, target_data): input_test = torch.tensor(input_seq, dtype=torch.long).unsqueeze(0)


----CODE_GLUE----
```python
    attention_model.eval()
    attention_output = attention_model(input_test)

    attention_prediction = ix_to_word[torch.argmax(attention_output).item()]

    print(f\"\nEntrada: {' '.join([ix_to_word[ix] for ix in input_seq])}\")
    print(f\"Objetivo: {ix_to_word[target]}\")
    print(f\"Predicción de RNN con Atención: {attention_prediction}\")

out Entrada: the cat sat on the Objetivo: mat Predicción de RNN con Atención: mat{{5}}"

Es hora de la práctica.

Deep Learning para texto con PyTorch