Everyone have heard about Google Translation and DeepL engines that enable you to translate a text from a language to another without any human intervention and you’re probably asking yourself how are they doing it.

The two most known systems that were successful throughout the years are :

Statistical Machine Translation (SMT)

These systems do not use any linguistic rules to carry out the translation. They instead translate using statistical models constructed automatically from corpora. The machine translation software analyses a different database for each language, which enables the production of relatively fluid but not always very logical translations.

Neural Machine Translation (NMT)

These systems use neural networks to predict the probability distribution of words in the sequence. They enable better quality translations that are the current state of the art. The majority of models are based on the Seq2Seq paradigm where an encoder resumes the information contained in the source sentence into a hidden vector passed to the decoder to generate predictions.

In this article, we will talk about the Seq2Seq model using RNNs and particularly GRU architecture.

So how does a Seq2Seq architecture work ?

Each word of the input sentence is encoded into hidden states through a recurrent neural cell in our case and then this information is exploited to generate a single hidden “context” vector used as an input to the decoder which receives also the target sentence. The purpose of the decoder is to generate a hidden vector enabling us through a softmax layer to predict the correct sequence of words.

The part below is intended for advanced readers who are comfortable with Python and particularly PyTorch.

In this tutorial, we focus on the German-English translation. The language used is Python and the deep learning library is Pytorch. It is inspired by the Pytorch Seq2Seq tutorial on GitHub.

Preparation of data

First we import the required modules.

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

from torchtext.datasets import TranslationDataset, Multi30k
from torchtext.data import Field, BucketIterator

import spacy

import random
import math
import time

All the text processing will be done using spaCy and Torchtext. Field objects enable to store all the pre-processing and post-processing operations intended and are used to build the Dataset objects used by the Iterators.

We load the German and English spaCy models.

spacy_de = spacy.load('de')
spacy_en = spacy.load('en')

We create the tokenizers and the Field objects.

def tokenize_de(text):
    Tokenizes German text from a string into a list of strings
    return [tok.text for tok in spacy_de.tokenizer(text)]

def tokenize_en(text):
    Tokenizes English text from a string into a list of strings
    return [tok.text for tok in spacy_en.tokenizer(text)]

SRC = Field(tokenize = tokenize_de, 
            init_token = '<sos>', 
            eos_token = '<eos>', 
            lower = True)

TRG = Field(tokenize = tokenize_en, 
            init_token = '<sos>', 
            eos_token = '<eos>', 
            lower = True)

We load the Multi30k dataset and use the training dataset to build the vocabulary.

train_data, valid_data, test_data = Multi30k.splits(exts = ('.de', '.en'), 
                                                    fields = (SRC, TRG))

SRC.build_vocab(train_data, min_freq = 2)
TRG.build_vocab(train_data, min_freq = 2)

Then we define the device and create the iterators that will be used in the training loop.

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')


train_iterator, valid_iterator, test_iterator = BucketIterator.splits(
    (train_data, valid_data, test_data), 
    batch_size = BATCH_SIZE,
    device = device)

Seq2Seq model

In our architecture, the encoder is a bidirectional GRU (Gated Recurrent Unit) while the decoder is a simple forward GRU. Attention is incorporated into the model to reduce the information loss : the encoded source sentence is shared with the decoder.

The encoder

Here we initialize the layers of the encoder and the different parameters. We need to specify the input dimension, embedding dimension to transform words into vectors, encoder hidden dimension, decoder hidden dimension as the input of the decoder is the output of the encoder and eventually the dropout rate.

class Encoder(nn.Module):
    def __init__(self, input_dim, emb_dim, enc_hid_dim, dec_hid_dim, dropout):
        self.input_dim = input_dim
        self.emb_dim = emb_dim
        self.enc_hid_dim = enc_hid_dim
        self.dec_hid_dim = dec_hid_dim
        self.dropout = dropout
        self.embedding = nn.Embedding(input_dim, emb_dim)
        self.rnn = nn.GRU(emb_dim, enc_hid_dim, bidirectional = True)
        self.fc = nn.Linear(enc_hid_dim * 2, dec_hid_dim)
        self.dropout = nn.Dropout(dropout)

Now we implement the forward function that will be called when the encoder is used.

def forward(self, src):
     embedded = self.dropout(self.embedding(src))
     outputs, hidden = self.rnn(embedded)
     #initial decoder hidden is final hidden state of the forwards and backwards 
     # encoder RNNs fed through a linear layer
     hidden = torch.tanh(self.fc(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim = 1)))
     return outputs, hidden

Next up is the attention layer. This will take in the previous hidden state of the decoder, and all of the stacked forward and backward hidden states from the encoder. The layer will output an attention vector that is the length of the source sentence, each element is between 0 and 1 and the entire vector sums to 1.

We need to initialize the attention layer which is a fully connected network receiving the encoder outputs concatenated to the decoder’s previous hidden state and outputting a vector of the right dimension.

class Attention(nn.Module):
    def __init__(self, enc_hid_dim, dec_hid_dim):
        self.enc_hid_dim = enc_hid_dim
        self.dec_hid_dim = dec_hid_dim
        self.attn = nn.Linear((enc_hid_dim * 2) + dec_hid_dim, dec_hid_dim)
        self.v = nn.Parameter(torch.rand(dec_hid_dim))

Now we implement the forward function to produce a vector that represents which words in the source sentence we should pay the most attention to in order to correctly predict the next word to decode.

    def forward(self, hidden, encoder_outputs):
        #hidden = [batch size, dec hid dim]
        #encoder_outputs = [src sent len, batch size, enc hid dim * 2]
        batch_size = encoder_outputs.shape[1]
        src_len = encoder_outputs.shape[0]
        #repeat encoder hidden state src_len times
        hidden = hidden.unsqueeze(1).repeat(1, src_len, 1)
        encoder_outputs = encoder_outputs.permute(1, 0, 2)
        #hidden = [batch size, src sent len, dec hid dim]
        #encoder_outputs = [batch size, src sent len, enc hid dim * 2]
        energy = torch.tanh(self.attn(torch.cat((hidden, encoder_outputs), dim = 2))) 
        #energy = [batch size, src sent len, dec hid dim]
        energy = energy.permute(0, 2, 1)
        #energy = [batch size, dec hid dim, src sent len]
        #v = [dec hid dim]
        v = self.v.repeat(batch_size, 1).unsqueeze(1)
        #v = [batch size, 1, dec hid dim]
        attention = torch.bmm(v, energy).squeeze(1)
        #attention= [batch size, src len]
        return F.softmax(attention, dim=1)

The decoder receives at each step a word (At T = 0, it is the <sos> token), the attention vector and the previous hidden state.

We initialize the multiple parameters, particularly the GRU layer and the last layer producing a vector of the shape output_dim. Each value of this vector is associate to a word of the vocabulary.

class Decoder(nn.Module):
    def __init__(self, output_dim, emb_dim, enc_hid_dim, dec_hid_dim, dropout, attention):

        self.emb_dim = emb_dim
        self.enc_hid_dim = enc_hid_dim
        self.dec_hid_dim = dec_hid_dim
        self.output_dim = output_dim
        self.dropout = dropout
        self.attention = attention
        self.embedding = nn.Embedding(output_dim, emb_dim)
        self.rnn = nn.GRU((enc_hid_dim * 2) + emb_dim, dec_hid_dim)
        self.out = nn.Linear((enc_hid_dim * 2) + dec_hid_dim + emb_dim, output_dim)
        self.dropout = nn.Dropout(dropout)

Now the forward function.

    def forward(self, input, hidden, encoder_outputs):
        #input = [batch size]
        #hidden = [batch size, dec hid dim]
        #encoder_outputs = [src sent len, batch size, enc hid dim * 2]
        input = input.unsqueeze(0)
        embedded = self.dropout(self.embedding(input))
        a = self.attention(hidden, encoder_outputs)
        a = a.unsqueeze(1)
        encoder_outputs = encoder_outputs.permute(1, 0, 2)
        weighted = torch.bmm(a, encoder_outputs)
        weighted = weighted.permute(1, 0, 2)

        rnn_input = torch.cat((embedded, weighted), dim = 2)
        output, hidden = self.rnn(rnn_input, hidden.unsqueeze(0))
        embedded = embedded.squeeze(0)
        output = output.squeeze(0)
        weighted = weighted.squeeze(0)
        output = self.out(torch.cat((output, weighted, embedded), dim = 1))
        #output = [bsz, output dim]
        return output, hidden.squeeze(0)

Now we need to join all these bricks together.

class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder, device):
        self.encoder = encoder
        self.decoder = decoder
        self.device = device
    def forward(self, src, trg, teacher_forcing_ratio = 0.5):
        #src = [src sent len, batch size]
        #trg = [trg sent len, batch size]
        #teacher_forcing_ratio is probability to use teacher forcing
        #e.g. if teacher_forcing_ratio is 0.75 we use teacher forcing 75% of the time
        batch_size = src.shape[1]
        max_len = trg.shape[0]
        trg_vocab_size = self.decoder.output_dim
        #tensor to store decoder outputs
        outputs = torch.zeros(max_len, batch_size, trg_vocab_size).to(self.device)
        #encoder_outputs is all hidden states of the input sequence, back and forwards
        #hidden is the final forward and backward hidden states, passed through a linear layer
        encoder_outputs, hidden = self.encoder(src)
        #first input to the decoder is the <sos> tokens
        output = trg[0,:]
        for t in range(1, max_len):
            output, hidden = self.decoder(output, hidden, encoder_outputs)
            outputs[t] = output
            teacher_force = random.random() < teacher_forcing_ratio
            top1 = output.max(1)[1]
            output = (trg[t] if teacher_force else top1)

        return outputs

You can notice that we introduced the notion of teacher forcing above. When used, the previous predicted word isn’t anymore an input to the decoder, it is replaced by the real word.

We initialize our parameters, encoder, decoder and seq2seq model.

INPUT_DIM = len(SRC.vocab)
OUTPUT_DIM = len(TRG.vocab)

attn = Attention(ENC_HID_DIM, DEC_HID_DIM)

model = Seq2Seq(enc, dec, device).to(device)

optimizer = optim.Adam(model.parameters())

PAD_IDX = TRG.vocab.stoi['<pad>']

criterion = nn.CrossEntropyLoss(ignore_index = PAD_IDX)

We implement our training loop.

def train(model, iterator, optimizer, criterion, clip):
    epoch_loss = 0
    for i, batch in enumerate(iterator):
        src = batch.src
        trg = batch.trg
        output = model(src, trg)
        #trg = [trg sent len, batch size]
        #output = [trg sent len, batch size, output dim]
        output = output[1:].view(-1, output.shape[-1])
        trg = trg[1:].view(-1)
        #trg = [(trg sent len - 1) * batch size]
        #output = [(trg sent len - 1) * batch size, output dim]
        loss = criterion(output, trg)
        torch.nn.utils.clip_grad_norm_(model.parameters(), clip)
        epoch_loss += loss.item()
    return epoch_loss / len(iterator)

Then, we specify the number of epochs and we launch the training.

CLIP = 1

best_valid_loss = float('inf')

for epoch in range(N_EPOCHS):
    start_time = time.time()
    train_loss = train(model, train_iterator, optimizer, criterion, CLIP)
    end_time = time.time()
    epoch_mins, epoch_secs = epoch_time(start_time, end_time)
    print(f'Epoch: {epoch+1:02} | Time: {epoch_mins}m {epoch_secs}s')
    print(f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}')

I hope that this tutorial was helpful. Please let me know if you have any remarks.


Please enter your comment!
Please enter your name here