decoder stack

1. 1

   Stakken af decoderlag i en encoder-decoder-transformer, hvor hvert lag består af maskeret selvopmærksomhed, krydsopmærksomhed over encoder-output og et position-vis feedforward-netværk. Lagene stables og normaliseres, og stakken genererer output autoregressivt.

   • I den originale Transformer består decoder-stakken af 6 identiske lag. — Attention Is All You Need, 2017
   • Krydsopmærksomhedsmekanismen i decoder-stakken gør det muligt for modellen at fokusere på relevante dele af inputsekvensen under generering.
2. 2

   I autoregressive sprogmodeller (f.eks. GPT) refererer 'decoder stack' ofte til stakken af decoderlag uden krydsopmærksomhed, da modellen kun er baseret på decoderarkitektur. Her består hvert lag af maskeret selvopmærksomhed og feedforward-netværk.

   • GPT-3's decoder-stak har 96 lag med maskeret selvopmærksomhed.
   • I GPT-modeller erstatter encoder-stakken, og decoder-stakken alene udgør hele modellen.

Decoder-stakken anvendes i sekvens-til-sekvens-modeller som den originale Transformer til opgaver som maskinoversættelse og tekstopsummering. Den er også grundlaget for autoregressive sprogmodeller, der kun bruger decoder-stakken (f.eks. GPT).

import torch
import torch.nn as nn
import torch.nn.functional as F

class DecoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(d_model, num_heads, dropout=dropout)
        self.cross_attn = nn.MultiheadAttention(d_model, num_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.norm3 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, encoder_output, src_mask=None, tgt_mask=None):
        # Self-attention (masked)
        x = self.norm1(x + self.dropout(self.self_attn(x, x, x, attn_mask=tgt_mask)[0]))
        # Cross-attention
        x = self.norm2(x + self.dropout(self.cross_attn(x, encoder_output, encoder_output, key_padding_mask=src_mask)[0]))
        # FFN
        x = self.norm3(x + self.dropout(self.ffn(x)))
        return x

Forenklet PyTorch-implementering af et enkelt decoderlag med selvopmærksomhed, krydsopmærksomhed og feedforward-netværk. Laget inkluderer residualforbindelser og lag-normalisering.

Termen stammer fra transformerarkitekturen introduceret i Vaswani et al. (2017), hvor modellen er opdelt i en encoder-stak og en decoder-stak.

• Attention Is All You Need (Vaswani et al., 2017)
• The Annotated Transformer (Harvard NLP)