Lære Hvordan Stable Transformerblokker | Bygge transformer-komponenter

Sveip for å vise menyen


              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 behandler tekst med en Transformer, brukes ofte flere encoder- eller decoder-blokker stablet oppå hverandre. I koden over ser du hvordan du kan opprette en stabel av encoder-blokker ved hjelp av PyTorch. Hver EncoderBlock inneholder multi-head self-attention, et feed-forward-nettverk og lag-normalisering. Klassen StackedEncoder bygger en sekvens av disse blokkene, der utdataene fra én blokk sendes som inndata til den neste. Denne stablingen gjør det mulig for modellen å lære stadig mer komplekse representasjoner av teksten i hvert lag. For NLP-oppgaver, som tekstklassifisering eller oversettelse, hjelper stabling av blokker med å fange opp dypere relasjoner og kontekst i dataene. Den opprinnelige inndataen – tekst konvertert til embedding-vektorer – flyter gjennom hver encoder-blokk, hvor hver blokk forbedrer representasjonen basert på både inndata og konteksten lært i tidligere lag.

Transformer-arkitekturer kan grupperes i tre hovedtyper, hver tilpasset ulike NLP-oppgaver:

Kun encoder-modeller

Struktur: Består av en stabel med encoder-blokker.
Typiske bruksområder: Disse modellene er ideelle for å forstå eller analysere tekst. Vanlige applikasjoner inkluderer tekstklassifisering, sentimentanalyse og navngitt enhetsgjenkjenning. Et kjent eksempel på denne typen er BERT.

Kun decoder-modeller

Struktur: Består av en stabel med decoder-blokker.
Typiske bruksområder: Disse modellene er laget for å generere tekst, slik som i språkmodellering og kodefullføring. GPT er et fremtredende eksempel på en kun decoder-modell.

Encoder-decoder-modeller

Struktur: Kombinerer encoder-blokker som prosesserer inndata og decoder-blokker som genererer utdata, med informasjonsflyt fra encoder til decoder.
Typiske bruksområder: Disse brukes til sekvens-til-sekvens-oppgaver der både inndata og utdata er sekvenser. Applikasjoner inkluderer maskinoversettelse, oppsummering og spørsmål-besvarelse. T5 og den originale Transformer er eksempler på encoder-decoder-arkitekturer.

Oppsummert avgjør valget av arkitektur hvilke typer NLP-problemer du kan løse: kun encoder-modeller for analyse, kun decoder-modeller for generering, og encoder-decoder-modeller for oppgaver som krever å mappe én sekvens til en annen.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 2. Kapittel 6

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Seksjon 2. Kapittel 6