Transformer encoder

Modelli Transformer con PyTorch

James Chapman

Curriculum Manager, DataCamp

Il transformer originale

L'architettura dei transformer come mostrata nell'articolo accademico, Attention Is All You Need.

Il transformer originale

Architettura del transformer originale

Transformer solo encoder

Architettura transformer solo encoder

Corpo del transformer: pila di encoder con N livelli encoder

Livello encoder

Self-attention multi-head

Sotto-livelli feed-forward

Normalizzazioni di livello, dropout

Testa del transformer

Transformer solo encoder

Architettura transformer solo encoder

Corpo del transformer: pila di encoder con N livelli encoder

Livello encoder

Self-attention multi-head

Sotto-livelli feed-forward

Normalizzazioni di livello, dropout

Testa del transformer: elabora gli input codificati per produrre la previsione in output

Task supervisionati: classificazione, regressione

Sotto-livello feed-forward nei livelli encoder

Sotto-livello feed-forward dopo l'attenzione

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 layer fully connected + attivazione ReLU

d_ff: dimensione tra i layer lineari
forward(): elabora gli output dell'attenzione per cogliere pattern complessi e non lineari

Livello 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

Livello encoder

Self-attention multi-head
Sotto-livello feed-forward
Normalizzazioni di livello e dropout

forward():

mask impedisce l'elaborazione dei token di padding

Mascherare il processo di attenzione

Padding delle sequenze

Maschera di padding nella self-attention

Corpo del transformer 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

Testa del transformer 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)

Classification head

Task: classificazione testuale, sentiment analysis, NER, QA estrattiva, ecc.
fc: layer lineare fully connected
- Trasforma gli stati nascosti dell'encoder in probabilità di num_classes classi

Regression head

Task: stima della leggibilità del testo, complessità linguistica, ecc.
- output_dim è 1 quando si predice un singolo valore numerico

Esercitiamoci!

Modelli Transformer con PyTorch