Transformeri encoder

Modele Transformer cu PyTorch

James Chapman

Curriculum Manager, DataCamp

Transformerul original

Arhitectura transformerului, prezentată în lucrarea academică „Attention Is All You Need".

Transformerul original

Arhitectura transformerului original

Transformeri encoder-only

Arhitectură transformer encoder-only

Corpul transformerului: stivă encoder cu N straturi encoder

Strat encoder

Auto-atenție multi-cap

Substraturi feed-forward

Normalizări de strat, dropout

Capul transformerului

Transformeri encoder-only

Arhitectură transformer encoder-only

Corpul transformerului: stivă encoder cu N straturi encoder

Strat encoder

Auto-atenție multi-cap

Substraturi feed-forward

Normalizări de strat, dropout

Capul transformerului: procesează intrările codificate pentru a produce predicții

Sarcini supervizate: clasificare, regresie

Substrat feed-forward în straturile encoder

Subsrat feed-forward după atenție

class FeedForwardSubLayer(nn.Module):
    def __init__(self, d_model, d_ff):
        super().__init__()
        self.fc1 = nn.Linear(d_model, d_ff)
        self.fc2 = nn.Linear(d_ff, d_model)
        self.relu = nn.ReLU()


    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

2 x fully connected + activare ReLU

d_ff: dimensiunea dintre straturile liniare
forward(): procesează ieșirile atenției pentru a captura tipare complexe, neliniare

Stratul encoder

class EncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout):
        super().__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)
        self.ff_sublayer = FeedForwardSubLayer(d_model, d_ff)

        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)


    def forward(self, x, src_mask):
        attn_output = self.self_attn(x, x, x, src_mask)
        x = self.norm1(x + self.dropout(attn_output))
        ff_output = self.ff_sublayer(x)
        x = self.norm2(x + self.dropout(ff_output))
        return x

Strat encoder

Auto-atenție multi-cap
Substrat feed-forward
Normalizări de strat și dropout

forward():

mask previne procesarea token-urilor de umplutură

Mascarea procesului de atenție

Secvențe cu umplutură

Mască de umplutură în auto-atenție

Corpul transformerului encoder

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

        self.embedding = InputEmbeddings(vocab_size, d_model)

        self.positional_encoding = PositionalEncoding(d_model, max_seq_length)

        self.layers = nn.ModuleList(
          [EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)]
        )


    def forward(self, x, src_mask):
        x = self.embedding(x)
        x = self.positional_encoding(x)
        for layer in self.layers:
            x = layer(x, src_mask)
        return x

Capul transformerului encoder

class ClassifierHead(nn.Module):
    def __init__(self, d_model, num_classes):
        super().__init__()
        self.fc = nn.Linear(d_model, num_classes)

    def forward(self, x):
        logits = self.fc(x)
        return F.log_softmax(logits, dim=-1)

class RegressionHead(nn.Module):
    def __init__(self, d_model, output_dim):
        super().__init__()
        self.fc = nn.Linear(d_model, output_dim)

    def forward(self, x):
        return self.fc(x)

Cap de clasificare

Sarcini: clasificare text, analiză sentiment, NER, QA extractiv etc.
fc: strat liniar fully connected
- Transformă stările ascunse ale encoderului în num_classes probabilități de clasă

Cap de regresie

Sarcini: estimare lizibilitate text, complexitate lingvistică etc.
- output_dim este 1 la predicția unei singure valori numerice

Să exersăm!

Modele Transformer cu PyTorch