encoderblok

1. 1

   Den primære anvendelse: en komponent i transformer-arkitekturen, der består af et multi-head self-attention-lag, et position-wise feed-forward neuralt netværk, residualforbindelser og lag-normalisering. Input og output har samme dimension.

   • BERTs grundlæggende byggesten er en encoderblok, der anvender 12 attention-hoveder. — Devlin et al., 2018
   • Ved at stable 6 encoderblokke opnår modellen en dyb forståelse af sætningens struktur.
2. 2

   I autoencoder-modeller: en del af netværket, der komprimerer input til en latent repræsentation. Kan bestå af konvolutionelle eller fuldt forbundne lag.

   • Autoencoderens encoderblok reducerer et 28x28 billede til en 32-dimensional latent vektor.

Encoderblokke anvendes i transformer-modeller som BERT og GPT til at forstå kontekst i tekst. De stables oven på hinanden for at skabe dybe repræsentationer. I computer vision anvendes lignende blokke i ViT.

import torch.nn as nn

class EncoderBlock(nn.Module):
    def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
        super().__init__()
        self.attention = nn.MultiheadAttention(d_model, n_heads, dropout=dropout)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Linear(d_ff, d_model)
        )
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        attn_out, _ = self.attention(x, x, x)
        x = self.norm1(x + self.dropout(attn_out))
        ffn_out = self.ffn(x)
        x = self.norm2(x + self.dropout(ffn_out))
        return x

En simpel implementering af en transformer encoderblok i PyTorch med multi-head attention og feed-forward lag.

Sammensat af 'encoder' (fra engelsk, 'indkoder') og 'blok', en grundlæggende enhed. Termen opstod med transformer-arkitekturen i 2017.

• Attention Is All You Need (Vaswani et al., 2017)