Transformerarkitektur: Attention, tokens och kontext
Ni kommer att följa mekanismen för self-attention, förstå hur BERT läser hela meningen på en gång i stället för från vänster till höger och tolka specialtoken CLS och SEP.
Transformerarkitektur: Attention, tokens och kontext är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad är en Transformer?
Transformer är en neuronnätsarkitektur som introducerades 2017 och som har ersatt rekurrenta nätverk i de flesta NLP-uppgifter. Till skillnad från RNN-modeller, som bearbetar token för token, bearbetar Transformers hela sekvensen parallellt med hjälp av en mekanism som kallas self-attention. Denna parallella bearbetning gör träningen mycket snabbare och gör att modellen effektivare kan fånga beroenden över långa avstånd.
Self-attention: relatera varje token
Self-attention gör att varje token i en sekvens samtidigt kan fokusera på alla andra tokens. I meningen ”The bank by the river was steep” kan ordet ”bank” starkt fokusera på ”river” för att fastställa dess betydelse. Varje token producerar tre vektorer: Query (Q), Key (K) och Value (V), som används för att beräkna viktade relationer mellan alla tokenpar.
import torch
import torch.nn.functional as F
# Simplified self-attention for 3 tokens, d_model=4
Q = torch.randn(3, 4) # queries
K = torch.randn(3, 4) # keys
V = torch.randn(3, 4) # values
d_k = Q.shape[-1]
scores = torch.matmul(Q, K.T) / (d_k ** 0.5) # scaled dot product
weights = F.softmax(scores, dim=-1) # attention weights
output = torch.matmul(weights, V) # weighted values
print('Attention weights:', weights)Skalad dotprodukt-attention
Attention-poängen mellan token i och token j beräknas som skalärprodukten av Q_i och K_j, dividerad med kvadratroten ur nyckeldimensionen för att förhindra att gradienterna blir försvinnande små. Formeln är: Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) * V. Skalningsfaktorn sqrt(d_k) håller gradienterna stabila för stora embeddingdimensioner.
Multi-Head Attention
Istället för en enda uppsättning projektioner för Q, K och V använder Transformers multi-head attention: h parallella uppmärksamhetshuvuden som vart och ett lär sig olika aspekter av relationerna mellan token. Ett huvud kan lära sig syntaktiska beroenden (subjekt–verb), medan ett annat lär sig semantiska relationer (synonymer). Alla huvudens utdata konkateneras och projiceras för att skapa den slutliga representationen.
import torch.nn as nn
multihead_attn = nn.MultiheadAttention(
embed_dim=512,
num_heads=8, # 8 heads, each with dim 64
dropout=0.1,
batch_first=True
)
# x shape: (batch, seq_len, 512)
# output shape: (batch, seq_len, 512)
output, attn_weights = multihead_attn(x, x, x)BERT: dubbelriktat sammanhang
BERT (Bidirectional Encoder Representations from Transformers) läser hela sekvensen på en gång och tar samtidigt hänsyn till både vänster- och högerkontext. Tidigare modeller som GPT läste endast från vänster till höger. Denna dubbelriktning gör att BERT kan förstå att ”bank” i ”river bank” skiljer sig från ”bank” i ”bank account”, eftersom modellen ser alla omgivande ord samtidigt.
Specialtoken: CLS och SEP
BERT introducerar två specialtoken. Token [CLS] (classification) placeras först i varje indata; efter bearbetningen sammanfattar dess slutliga dolda tillstånd information på meningsnivå och används för klassificeringsuppgifter. Token [SEP] separerar två meningar i uppgifter som frågebesvarande eller förutsägelse av nästa mening. Det är viktigt att förstå dessa token när Ni bygger BERT-pipelines.
# Example tokenised input for BERT sentence-pair
# [CLS] I love Python [SEP] Python is great [SEP]
# token_ids: [101, 1045, 2293, 18750, 102, 18750, 2003, 2307, 102]
# segment_ids: [0, 0, 0, 0, 0, 1, 1, 1, 1 ]
print('CLS token id:', 101)
print('SEP token id:', 102)Positionskodning: ordning utan rekurrens
Eftersom Transformers bearbetar alla token parallellt har de ingen inbyggd uppfattning om tokenordning. Positionskodningar läggs till i varje tokeninbäddning för att tillföra positionsinformation. BERT använder inlärda positionsinbäddningar, medan den ursprungliga Transformern använde sinusfunktioner. Utan positionskodning skulle ”cat bites dog” och ”dog bites cat” ge identiska representationer.
import torch.nn as nn
# BERT-style learned positional embedding
pos_embedding = nn.Embedding(512, 768) # max 512 positions, d_model=768
positions = torch.arange(seq_len).unsqueeze(0) # (1, seq_len)
pos_enc = pos_embedding(positions) # (1, seq_len, 768)
# Added to token embeddings before feeding to transformer layersEncoderarkitektur: lager och feed-forward
Varje BERT-encoderlager består av två underlager: multi-head self-attention följt av ett position-wise feed-forward network (två linjära lager med en GELU-aktivering). Varje underlager har en residualanslutning och lagernormalisering. BERT-base staplar 12 sådana lager, medan BERT-large använder 24. Djupare staplar fångar mer abstrakta språkliga strukturer.
Tokeninbäddningar: WordPiece-ordförråd
BERT tokeniserar text med WordPiece-tokenisering av delord. Ovanliga ord delas upp i vanliga underenheter: ”unbelievable” kan bli ['un', '##believe', '##able']. Prefixet ## anger en fortsättning på ett delord. Denna metod hanterar ord utanför ordlistan på ett smidigt sätt och använder ett ordförråd på cirka 30 000 token, vilket balanserar täckning och storleken på inbäddningstabellen.
from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
text = 'unbelievable achievements'
tokens = tokenizer.tokenize(text)
print(tokens) # ['un', '##believ', '##able', 'achievements']
encoded = tokenizer(text, return_tensors='pt')
print('input_ids:', encoded['input_ids'])
print('attention_mask:', encoded['attention_mask'])Attention-mask: hantering av utfyllnad
När batchar med meningar av varierande längd bearbetas fylls kortare meningar ut med token [PAD] så att de får samma längd som den längsta sekvensen. En attention-mask är en binär tensor (1 för riktiga token, 0 för utfyllnad) som talar om för modellen att ignorera utfyllnadspositioner i attention-beräkningen. Utan denna mask skulle modellen ta hänsyn till meningslösa utfyllnadstoken och förstöra sina representationer.
from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
batch = ['Short text.', 'This sentence is longer than the first one.']
encoded = tokenizer(batch, padding=True, truncation=True, return_tensors='pt')
print('input_ids shape:', encoded['input_ids'].shape)
print('attention_mask:\n', encoded['attention_mask'])
# Zeros mark padding positionsFörträning av BERT: MLM och NSP
BERT förtränades på två uppgifter. Masked Language Modelling (MLM) maskerar slumpmässigt 15 % av token och tränar BERT att förutsäga den ursprungliga token utifrån kontexten, vilket tvingar fram en dubbelriktad förståelse. Next Sentence Prediction (NSP) tränar BERT att avgöra om två meningar följer direkt på varandra, vilket underlättar uppgifter med meningspar. Finjustering anpassar sedan dessa informationsrika representationer till efterföljande uppgifter med mycket lite ytterligare träning.
Snabbtest
Testa Er förståelse av begreppen inom Machine Learning with Python från den här lektionen.
Lektionssammanfattning
I den här lektionen har Ni lärt Er att Transformers använder parallell self-attention i stället för sekventiell rekurrens, att BERT läser dubbelriktad kontext med hjälp av förträning med masked language modelling, samt att specialtoken [CLS] och [SEP] strukturerar BERT:s indata för klassificeringsuppgifter och uppgifter med meningspar. Härnäst undersöker vi hur Hugging Face-tokeniserare kodar råtext till det tensorformat som BERT förväntar sig.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Transformerarkitektur: Attention, tokens och kontext” gratis?
Ja – hela texten till ”Transformerarkitektur: Attention, tokens och kontext” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Transformerarkitektur: Attention, tokens och kontext”?
Ni kommer att följa mekanismen för self-attention, förstå hur BERT läser hela meningen på en gång i stället för från vänster till höger och tolka specialtoken CLS och SEP. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Transformerarkitektur: Attention, tokens och kontext”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Transformerarkitektur: Attention, tokens och kontext
- Hugging Face-tokeniserare: Koda text för BERT
- Finjustera BertForSequenceClassification
- Utvärdering och inferens: Från logits till predikterade etiketter