Lära Hur man staplar transformerblock | Bygga Transformer-Komponenter

Svep för att visa menyn


              123456789101112131415161718192021222324252627282930313233343536373839404142434445
            
import torch
import torch.nn as nn

class EncoderBlock(nn.Module):
    def __init__(self, embed_dim, num_heads, ff_dim):
        super().__init__()
        self.attn = nn.MultiheadAttention(embed_dim, num_heads, batch_first=True)
        self.norm1 = nn.LayerNorm(embed_dim)
        self.ff = nn.Sequential(
            nn.Linear(embed_dim, ff_dim),
            nn.ReLU(),
            nn.Linear(ff_dim, embed_dim)
        )
        self.norm2 = nn.LayerNorm(embed_dim)
        
    def forward(self, x):
        attn_output, _ = self.attn(x, x, x)
        x = self.norm1(x + attn_output)
        ff_output = self.ff(x)
        x = self.norm2(x + ff_output)
        return x

class StackedEncoder(nn.Module):
    def __init__(self, num_layers, embed_dim, num_heads, ff_dim):
        super().__init__()
        self.layers = nn.ModuleList([
            EncoderBlock(embed_dim, num_heads, ff_dim) for _ in range(num_layers)
        ])
        
    def forward(self, x):
        for layer in self.layers:
            x = layer(x)
        return x

# Example usage: stack 4 encoder blocks for input text embeddings
embed_dim = 64
num_heads = 4
ff_dim = 256
num_layers = 4

stacked_encoder = StackedEncoder(num_layers, embed_dim, num_heads, ff_dim)
input_tensor = torch.rand(2, 10, embed_dim)  # batch_size=2, seq_len=10

output = stacked_encoder(input_tensor)
print("Stacked encoder output shape:", output.shape)

När du bearbetar text med en Transformer används ofta flera encoder- eller decoder-block staplade ovanpå varandra. I koden ovan visas hur man skapar en stapel av encoder-block med PyTorch. Varje EncoderBlock innehåller multi-head self-attention, ett feed-forward-nätverk och layer normalization. Klassen StackedEncoder bygger en sekvens av dessa block, där utdata från ett block blir indata till nästa. Denna stapling gör det möjligt för modellen att lära sig allt mer komplexa representationer av texten i varje lager. För NLP-uppgifter, såsom textklassificering eller översättning, hjälper staplade block till att fånga djupare relationer och kontext i datan. Den ursprungliga inmatningen – text omvandlad till inbäddningar – passerar genom varje encoder-block, där varje block förfinar representationen baserat på både indata och den kontext som lärts in i tidigare lager.

Transformer-arkitekturer kan delas in i tre huvudtyper, där varje typ är anpassad för olika NLP-uppgifter:

Endast encoder-modeller

Struktur: Består av en stapel encoder-block.
Typiska användningsområden: Dessa modeller är idealiska för att förstå eller analysera text. Vanliga tillämpningar inkluderar textklassificering, sentimentanalys och namngiven entityigenkänning. Ett välkänt exempel på denna typ är BERT.

Endast decoder-modeller

Struktur: Består av en stapel decoder-block.
Typiska användningsområden: Dessa modeller är utformade för att generera text, till exempel vid språkmodellering och kodkomplettering. GPT är ett framträdande exempel på en decoder-only-modell.

Encoder-decoder-modeller

Struktur: Kombinerar encoder-block som bearbetar indata och decoder-block som genererar utdata, där information flödar från encoder till decoder.
Typiska användningsområden: Dessa används för sekvens-till-sekvens-uppgifter där både indata och utdata är sekvenser. Tillämpningar inkluderar maskinöversättning, summering och frågesvar. T5 och den ursprungliga Transformer är exempel på encoder-decoder-arkitekturer.

Sammanfattningsvis avgör valet av arkitektur vilka typer av NLP-problem som kan lösas: endast encoder-modeller för analys, endast decoder-modeller för generering och encoder-decoder-modeller för uppgifter som kräver att en sekvens mappas till en annan.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 6

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Avsnitt 2. Kapitel 6