एन्कोडर-डिकोडर ट्रांसफॉर्मर

PyTorch के साथ Transformer Models

James Chapman

Curriculum Manager, DataCamp

एन्कोडर और डिकोडर का मिलन

मूल ट्रांसफॉर्मर आर्किटेक्चर

एन्कोडर और डिकोडर का मिलन

एन्कोडर और डिकोडर साथ में

क्रॉस-अटेंशन मैकेनिज़्म

पूरी decoder में संसाधित जानकारी
encoder ब्लॉक की अंतिम hidden states

क्रॉस-अटेंशन उदाहरण

क्रॉस-अटेंशन वाला डिकोडर

DecoderLayer में बदलाव

पूरी decoder में संसाधित जानकारी
encoder ब्लॉक की अंतिम hidden states

x: decoder information flow, क्रॉस-अटेंशन की query बनता है
y: encoder output, क्रॉस-अटेंशन की key और values बनता है

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))
        ...

DecoderTransformer में बदलाव

केवल डिकोडर

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)

एन्कोडर-डिकोडर

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)

एन्कोडर और डिकोडर का मिलन

एन्कोडर और डिकोडर साथ में

ट्रांसफॉर्मर हेड

अनुवाद के लिए आउटपुट उदाहरण

jugar (खेलना): 0.03
viajar (यात्रा करना): 0.96
dormir (सोना): 0.01

अन्य कार्यों के लिए अलग-अलग activations चाहिए हो सकते हैं

ट्रांसफॉर्मर हेड वाला डिकोडर

सब कुछ एक साथ!

समग्र एन्कोडर-डिकोडर ट्रांसफॉर्मर

सब कुछ एक साथ!

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

अभ्यास करते हैं!

PyTorch के साथ Transformer Models