Lære Hvordan Man Stabler Transformerblokke | Opbygning af Transformer-Komponenter

Stryg for at vise menuen


              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 tekst behandles med en Transformer, anvendes ofte flere encoder- eller decoder-blokke stablet oven på hinanden. I koden ovenfor vises, hvordan man opretter en stak af encoder-blokke ved hjælp af PyTorch. Hver EncoderBlock indeholder multi-head self-attention, et feed-forward netværk og lag-normalisering. Klassen StackedEncoder opbygger en sekvens af disse blokke, hvor outputtet fra én blok bruges som input til den næste. Denne stakning gør det muligt for modellen at lære stadig mere komplekse repræsentationer af teksten i hvert lag. Til NLP-opgaver som tekstklassificering eller oversættelse hjælper stakning af blokke med at opfange dybere relationer og kontekst i dataene. Det oprindelige input – tekst konverteret til embeddings – føres gennem hver encoder-blok, hvor hver blok forfiner repræsentationen baseret på både inputtet og den kontekst, der er lært i de foregående lag.

Transformer-arkitekturer kan opdeles i tre hovedtyper, som hver især egner sig til forskellige NLP-opgaver:

Kun-Encoder Modeller

Struktur: Består af en stak encoder-blokke.
Typiske anvendelser: Disse modeller er ideelle til forståelse eller analyse af tekst. Almindelige anvendelser omfatter tekstklassificering, sentimentanalyse og navngiven entitetsgenkendelse. Et velkendt eksempel på denne type er BERT.

Kun-Decoder Modeller

Struktur: Består af en stak decoder-blokke.
Typiske anvendelser: Disse modeller er designet til generering af tekst, såsom sprogmodellering og kodefuldførelse. GPT er et fremtrædende eksempel på en kun-decoder model.

Encoder-Decoder Modeller

Struktur: Kombinerer encoder-blokke, der behandler inputtet, og decoder-blokke, der genererer outputtet, hvor informationen flyder fra encoder til decoder.
Typiske anvendelser: Disse bruges til sekvens-til-sekvens-opgaver, hvor både input og output er sekvenser. Anvendelser inkluderer maskinoversættelse, opsummering og spørgsmål-svar. T5 og den oprindelige Transformer er eksempler på encoder-decoder arkitekturer.

Sammenfattende afgør valget af arkitektur, hvilke typer NLP-problemer der kan løses: kun-encoder modeller til analyse, kun-decoder modeller til generering og encoder-decoder modeller til opgaver, der kræver mapping fra én sekvens til en anden.

Var alt klart?

Tak for dine kommentarer!

Sektion 2. Kapitel 6

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Sektion 2. Kapitel 6