seq2seq
forkortelse for sequence-to-sequence
En modelarkitektur, der består af en encoder og en decoder, som begge typisk er rekursive neurale netværk (RNN'er), og som transformerer en inputsekvens til en outputsekvens af varierende længde.
Kort fortalt
En metode, hvor en encoder læser en sætning og komprimerer den til en kontekstvektor, som en decoder derefter bruger til at generere en ny sætning, f.eks. til oversættelse.
- Kategori
- arkitektur
- Niveau
- øvet
- Udtale
- /siːk tuː siːk/
Betydninger
1- 1
En modelarkitektur med en encoder, der læser inputsekvensen og producerer en fast kontekstvektor, og en decoder, der genererer outputsekvensen trin for trin baseret på kontekstvektoren og tidligere genererede output.
- Seq2seq-modellen blev trænet på en stor parallelkorpus til engelsk-tysk oversættelse. — Sutskever et al., 2014
- I en seq2seq-arkitektur kan encoder og decoder være LSTM'er eller GRU'er. — faglitteratur
Hvornår bruges det
seq2seq bruges primært til opgaver med sekvens-til-sekvens mapping som maskinoversættelse, tekstopsummering og talegenkendelse. Arkitekturen er grundlaget for senere modeller med attention-mekanismer og transformere.
Kodeeksempel
import torch
import torch.nn as nn
class Encoder(nn.Module):
def __init__(self, input_dim, emb_dim, hid_dim, n_layers):
super().__init__()
self.embedding = nn.Embedding(input_dim, emb_dim)
self.rnn = nn.LSTM(emb_dim, hid_dim, n_layers)
def forward(self, src):
embedded = self.embedding(src)
outputs, (hidden, cell) = self.rnn(embedded)
return hidden, cell
class Decoder(nn.Module):
def __init__(self, output_dim, emb_dim, hid_dim, n_layers):
super().__init__()
self.embedding = nn.Embedding(output_dim, emb_dim)
self.rnn = nn.LSTM(emb_dim, hid_dim, n_layers)
self.fc_out = nn.Linear(hid_dim, output_dim)
def forward(self, input, hidden, cell):
input = input.unsqueeze(0)
embedded = self.embedding(input)
output, (hidden, cell) = self.rnn(embedded, (hidden, cell))
prediction = self.fc_out(output.squeeze(0))
return prediction, hidden, cell
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder, device):
super().__init__()
self.encoder = encoder
self.decoder = decoder
self.device = device
def forward(self, src, trg, teacher_forcing_ratio=0.5):
trg_len = trg.shape[0]
batch_size = trg.shape[1]
trg_vocab_size = self.decoder.fc_out.out_features
outputs = torch.zeros(trg_len, batch_size, trg_vocab_size).to(self.device)
hidden, cell = self.encoder(src)
input = trg[0,:]
for t in range(1, trg_len):
output, hidden, cell = self.decoder(input, hidden, cell)
outputs[t] = output
teacher_force = random.random() < teacher_forcing_ratio
top1 = output.argmax(1)
input = trg[t] if teacher_force else top1
return outputsEn simpel seq2seq-model implementeret i PyTorch med LSTM-encoder og -decoder.
Oprindelse
Forkortelse af 'sequence-to-sequence' (sekvens-til-sekvens). Introduceret af Sutskever et al. i 2014.
Afledte ord
2Kilder
2- Sequence to Sequence Learning with Neural Networks (Sutskever et al., 2014)
- Neural Machine Translation by Jointly Learning to Align and Translate (Bahdanau et al., 2014)