Aufmerksamkeitsmechanismen für die Textgenerierung

Deep Learning für Text mit PyTorch

Shubham Jain

Instructor

Die Mehrdeutigkeit in der Textverarbeitung

"- \"Der Affe aß diese Banane, weil er zu hungrig war\"

Worauf bezieht sich das Wort \"er\"?

MenschVsMaschine "

Aufmerksamkeitsmechanismen

"- Weist Wörtern Bedeutung zu

Stellt sicher, dass die Interpretation der Maschine mit dem menschlichen Verständnis übereinstimmt {{2}}"

" Aufmerksamkeitsdiagramm {{2}}"

¹ Xie, Huiqiang & Qin, Zhijin & Li, Geoffrey & Juang, Biing-Hwang. (2020). Durch Deep Learning ermöglichte semantische Kommunikationssysteme

Self- und Multi-Head-Attention

"- Self-Attention: weist Wörtern innerhalb eines Satzes Bedeutung zu {{1}} - Die Katze, die auf dem Dach war, hatte Angst\" {{2}} - Verknüpfung von \"hatte Angst\" mit \"Die Katze\"

Multi-Head Attention: wie mehrere Scheinwerfer, die verschiedene Aspekte erfassen {{3}} - Das Verständnis von \"hatte Angst\" kann sich auf {{4}} - \"Die Katze\", \"das Dach\" oder \"war auf\" beziehen {{4}}"

Aufmerksamkeitsmechanismus – Festlegung von Vokabular und Daten

"`python data = [\"the cat sat on the mat\", ...]


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

Modelldefinition

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

Vorwärtsausbreitung mit Attention

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

Trainingsvorbereitung

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

Modellevaluierung

"`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\"\nInput: {' '.join([ix_to_word[ix] for ix in input_seq])}\")
    print(f\"Target: {ix_to_word[target]}\")
    print(f\"RNN with Attention prediction: {attention_prediction}\")

out Input: the cat sat on the Target: mat RNN with Attention prediction: mat{{5}}"

Nun kannst du wieder etwas üben!

Deep Learning für Text mit PyTorch