Transformers encodeur-décodeur

Modèles Transformer avec PyTorch

James Chapman

Curriculum Manager, DataCamp

Quand l'encodeur rencontre le décodeur

Architecture originale du transformer

Quand l'encodeur rencontre le décodeur

Encodeur et décodeur assemblés

Mécanisme d'attention croisée

Information traitée dans le décodeur
États cachés finaux du bloc encodeur

Exemple d'attention croisée

Décodeur avec attention croisée

Modifier DecoderLayer

Information traitée dans le décodeur
États cachés finaux du bloc encodeur

x : flux d'information du décodeur, devient la requête de l'attention croisée
y : sortie de l'encodeur, devient la clé et les valeurs de l'attention croisée

class DecoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout):
        super().__init__()
        self.self_attn = MultiHeadAttention(
                          d_model, num_heads)
        self.cross_attn = MultiHeadAttention(
                          d_model, num_heads)
        ...


    def forward(self, x, y, tgt_mask, cross_mask):
        self_attn_output = self.self_attn(x, x, x,             
                                          tgt_mask)
        x = self.norm1(x + self.dropout(self_attn_output))

        cross_attn_output = self.cross_attn(x, y, y,     
                                            cross_mask)
        x = self.norm2(x + self.dropout(cross_attn_output))
        ...

Modifier DecoderTransformer

Décodeur seul

class TransformerDecoder(nn.Module):
...
def forward(self, x, tgt_mask):
    x = self.embedding(x)
    x = self.positional_encoding(x)
    for layer in self.layers:
        x = layer(x, tgt_mask)
    x = self.fc(x)
    return F.log_softmax(x, dim=-1)

Encodeur-décodeur

class TransformerDecoder(nn.Module):
...

def forward(self, x, y, tgt_mask, cross_mask):
    x = self.embedding(x)
    x = self.positional_encoding(x)
    for layer in self.layers:
        x = layer(x, y, tgt_mask, cross_mask)
    x = self.fc(x)
    return F.log_softmax(x, dim=-1)

Quand l'encodeur rencontre le décodeur

Encodeur et décodeur assemblés

Tête de transformer

Exemple de sorties pour la traduction

jugar (jouer) : 0,03
viajar (voyager) : 0,96
dormir (dormir) : 0,01

Pour d'autres tâches, d'autres activations peuvent être nécessaires

Décodeur avec tête de transformer

Tout rassembler !

Transformer encodeur-décodeur global

Tout rassembler !

class InputEmbeddings(nn.Module):
  ...  
class PositionalEncoding(nn.Module):
  ...  
class MultiHeadAttention(nn.Module):
  ...
class FeedForwardSubLayer(nn.Module):
  ...  
class EncoderLayer(nn.Module):
  ...
class DecoderLayer(nn.Module):
  ...

class TransformerEncoder(nn.Module):
  ...
class TransformerDecoder(nn.Module):
  ...
class ClassificationHead(nn.Module):
  ...

class Transformer(nn.Module):
    def __init__(self, vocab_size, d_model, num_heads, 
                 num_layers, d_ff, max_seq_len, dropout):
        super().__init__()


        self.encoder = TransformerEncoder(vocab_size, 
            d_model, num_heads, num_layers,
            d_ff, dropout, max_seq_len)
        self.decoder = TransformerDecoder(vocab_size, 
            d_model, num_heads, num_layers,
            d_ff, dropout, max_seq_len)


    def forward(self, x, src_mask, tgt_mask, cross_mask):
        encoder_output = self.encoder(x, src_mask)
        decoder_output = self.decoder(x, encoder_output,
                                      tgt_mask, cross_mask)
        return decoder_output

Passons à la pratique !

Modèles Transformer avec PyTorch