Sequence to Sequence (seq2seq): differenze tra le versioni

Versione attuale delle 12:19, 10 set 2024

Sequence to Sequence (seq2seq)
Nome Inglese	Sequence to Sequence Model
Sigla	seq2seq
Anno Di Creazione	2014
Pubblicazione	Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation
URL	https://arxiv.org/abs/1406.1078
Topic	Sequenze, Reti neurali, traduzione, Generazione

Classe di approcci e metodi utilizzati nel campo del deep learning, soprattutto nei task di traduzione automatica ma anche, per esempio, per la creazione di didascalie di immagini. Essi fondano le basi concettuali per le architetture transformer.

Sono basati su un modello encoder-decoder in cui:

l'encoder processa la sequenza di input creando una rappresentazione semantica dell'input, che catturi le informazioni essenziali
il decoder utilizza gli stati nascosti dell'encoder, in cui viene rappresentazione l'informazione per creare una sequenza di output

Esempio di utilizzo nel task di traduzione automatica

La pubblicazione Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation del 2014 dimostra il concetto perfettamente. Si può seguire il codice nell'implementazione in Pytorch a questo URL (che contiene un errore però nel padding delle sequenze di output) o a questo URL, più complesso ma aderente alla pubblicazione: usa anche la tecnica di teacher forcing e fa una valutazione BLEU alla fine.

Concettualmente, il modello Seq2Seq viene rappresentato come due RNN. Durante il forward pass:

la prima RNN, l'encoder, prende l'input, con token di padding a lunghezza predefinita, e lo processa, finendo con l'avere uno stato nascosto
questo stato nascosto dell'encoder viene passato come stato nascosto della RNN decoder (contesto), e la RNN viene eseguita per tanti step quanti i token nella sequenza attesa. A ogni step, viene passato il contesto concatenato all'input corrente e il layer nascosto corrente del decoder.
Un layer lineare connette poi lo stato nascosto del decoder all'output, spesso con rappresentazione one-hot

Durante la fase di addestramento, la perdita viene calcolata confrontando l'output con il target, codificato con un token di fine sequenza. La backpropagation in questo caso cercherà di far sì che le sequenze di output assomiglino a quelle di input il più possibile.

Durante la fase di inferenza, il token di inizio frase (anche detto sequenza di priming) fa sì che la rete cominci a elaborare e emettere i token.

Rappresentazione Grafica

Qui sotto si veda la rappresentazione dell'elaborazione in "Learning Phrase Representations using RNN Encoder–Decoder

for Statistical Machine Translation"

Collegamenti

https://machinecurve.com/index.php/2020/12/21/from-vanilla-rnns-to-transformers-a-history-of-seq2seq-learning

https://arxiv.org/abs/1406.1078

https://github.com/bentrevett/pytorch-seq2seq

@@ Riga 1: / Riga 1: @@
+{{template architettura
+|NomeInglese=Sequence to Sequence Model
+|Sigla=seq2seq
+|AnnoDiCreazione=2014
+|Pubblicazione=Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation
+|URLHomePage=https://arxiv.org/abs/1406.1078
+|Topic=Sequenze, Reti neurali, traduzione, Generazione
+}}
 Classe di approcci e metodi utilizzati nel campo del deep learning, soprattutto nei task di traduzione automatica ma anche, per esempio, per la creazione di didascalie di immagini. Essi fondano le basi concettuali per le architetture [[Transformer (Architettura di Deep Learning)|transformer]].
@@ Riga 7: / Riga 15: @@
 === Esempio di utilizzo nel task di traduzione automatica ===
-La pubblicazione [https://arxiv.org/abs/1406.1078 Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation] del 2014 dimostra il concetto perfettamente. Si può seguire il codice nell'implementazione in Pytorch a [https://github.com/graykode/nlp-tutorial/blob/d05e31ec81d56d70c1db89b99ab07e948f7ebc11/4-1.Seq2Seq/Seq2Seq.py#L56 questo URL].
+La pubblicazione [https://arxiv.org/abs/1406.1078 Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation] del 2014 dimostra il concetto perfettamente. Si può seguire il codice nell'implementazione in Pytorch a [https://github.com/graykode/nlp-tutorial/blob/d05e31ec81d56d70c1db89b99ab07e948f7ebc11/4-1.Seq2Seq/Seq2Seq.py#L56 questo URL] (che contiene un errore però nel padding delle sequenze di output) o a [https://github.com/bentrevett/pytorch-seq2seq/blob/main/2%20-%20Learning%20Phrase%20Representations%20using%20RNN%20Encoder-Decoder%20for%20Statistical%20Machine%20Translation.ipynb questo URL], più complesso ma aderente alla pubblicazione: usa anche la tecnica di [[Teacher Forcing (Reti Neurali)|teacher forcing]] e fa una valutazione [[Bilingual Evaluation Understudy (BLEU)|BLEU]] alla fine.
-Seguendo l'esempio, si vuole addestrare la rete a tradurre solo le seguenti sequenze di parole "contrarie", notare che sono stati anche appositamente introdotti degli errori.
+Concettualmente, il modello Seq2Seq viene rappresentato come due RNN. Durante il [[forward pass]]:
- ['man', 'women'], ['black', 'white'], ['king', 'queen'], ['girl', 'boy'], ['up', 'down'], ['high', 'low']
+* la prima RNN, l'encoder, prende l'input, con token di padding a lunghezza predefinita, e lo processa, finendo con l'avere uno stato nascosto
+* questo '''stato nascosto''' dell'encoder viene passato come stato nascosto della RNN decoder (contesto), e la RNN viene eseguita per tanti step quanti i token nella sequenza attesa. A ogni step, viene passato il '''contesto concatenato all'input corrente''' e il layer nascosto corrente del decoder.
+* Un layer lineare connette poi lo stato nascosto del decoder all'output, spesso con rappresentazione [[One-hot encodings|one-hot]]
+Durante la fase di addestramento, la perdita viene calcolata confrontando l'output con il target, codificato con un token di fine sequenza. La backpropagation in questo caso cercherà di far sì che le sequenze di output assomiglino a quelle di input il più possibile.
-Concettualmente, il modello Seq2Seq viene rappresentato come due RNN. Durante il [[forward pass]]:
+Durante la fase di inferenza, il token di inizio frase (anche detto [[sequenza di priming]]) fa sì che la rete cominci a elaborare e emettere i token.
-* la prima RNN, l'encoder, prende l'input, '''man''' (in realtà '''manPP''' con padding a lunghezza 5), e lo processa, finendo con l'avere uno stato nascosto
+=== Rappresentazione Grafica ===
-* questo '''stato nascosto''' dell'encoder viene passato come '''stato nascosto''' della RNN decoder, e come input viene data la sequenza di '''output''' (Swoman in quanto viene introdotto sempre un token di start della sequenza)'''.''' Durante la fase di training, questa sequenza corrisponde effettivamente all'output atteso. Dopo il processamento della RNN, l'hidden layer conterrà, concettualmente, <u>la rappresentazione dell'intero processo di traduzione</u> della sequenza "'''man'''PP'''Swoman"'''
+Qui sotto si veda la rappresentazione dell'elaborazione in "Learning Phrase Representations using RNN Encoder–Decoder
-* Un layer lineare connette poi lo stato nascosto del decoder all'output, in questo caso con rappresentazione [[One-hot encodings|one-hot]]
-Durante la fase di addestramento, la loss viene calcolata confrontando l'output con il target,
+for Statistical Machine Translation"
-<source lang="python">
+[[File:Seq2seq.png|senza_cornice|600x600px]]
-class Seq2Seq(nn.Module):
+=== Collegamenti ===
-    def __init__(self):
+https://machinecurve.com/index.php/2020/12/21/from-vanilla-rnns-to-transformers-a-history-of-seq2seq-learning
-        super(Seq2Seq, self).__init__()
-        # Definizione della cella dell'encoder RNN con dropout per ridurre l'overfitting
+https://arxiv.org/abs/1406.1078
-        self.enc_cell = nn.RNN(input_size=n_class, hidden_size=n_hidden, dropout=0.5)
-        # Definizione della cella del decoder RNN, simile all'encoder
-        self.dec_cell = nn.RNN(input_size=n_class, hidden_size=n_hidden, dropout=0.5)
-        # Un layer lineare che mappa l'output del decoder alla dimensione della classe di output
-        self.fc = nn.Linear(n_hidden, n_class)
-    def forward(self, enc_input, enc_hidden, dec_input):
+https://github.com/bentrevett/pytorch-seq2seq
-        # ...
-        # Esecuzione dell'encoder con l'input e lo stato nascosto iniziale, ottenendo lo stato nascosto finale
+[[Category:architettura]]
-        _, enc_states = self.enc_cell(enc_input, enc_hidden)
-        # Esecuzione del decoder con l'input e lo stato nascosto dell'encoder come stato iniziale
-        outputs, _ = self.dec_cell(dec_input, enc_states)
-        # Applicazione del layer lineare per ottenere le previsioni finali
+{{#seo:
-        model = self.fc(outputs)
+            |title=Sequence to Sequence Model
-        return model
+            |title_mode=append
+            |keywords=reti neurali, deep learning, traduzione automatica, sequenze, encoder-decoder, NLP, elaborazione del linguaggio naturale, intelligenza artificiale, apprendimento automatico, modello linguistico
-</source>La cosa più importante è che
+            |description=Il modello Sequence to Sequence (seq2seq) è un approccio di deep learning basato su un'architettura encoder-decoder, utilizzato principalmente per la traduzione automatica e la generazione di didascalie di immagini. L'encoder elabora la sequenza di input e ne crea una rappresentazione semantica, mentre il decoder utilizza questa rappresentazione per generare una sequenza di output. Questo modello ha gettato le basi per architetture più avanzate come i Transformer.
+            |image=Seq2seq.png
+            }}