Machine Learning Academy · Leçon

Architecture Transformer : attention, jetons et contexte

Vous suivrez le mécanisme d’auto-attention, comprendrez comment BERT lit toute la phrase en une seule fois plutôt que de gauche à droite, et interpréterez les jetons spéciaux CLS et SEP.

Leçon 1 sur 413 étapes

Architecture Transformer : attention, jetons et contexte est une leçon Machine Learning Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Machine Learning Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Machine Learning Academy comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

What Is a Transformer?

The Transformer is a neural network architecture introduced in 2017 that replaced recurrent networks for most NLP tasks. Unlike RNNs that process tokens one at a time, Transformers process the entire sequence in parallel using a mechanism called self-attention. This parallel processing makes training much faster and allows the model to capture long-range dependencies more effectively.

Self-Attention: Relating Every Token

Self-attention allows each token in a sequence to attend to every other token simultaneously. For the sentence 'The bank by the river was steep', the word 'bank' can attend strongly to 'river' to resolve its meaning. Each token produces three vectors: Query (Q), Key (K), and Value (V), which are used to compute weighted relationships between all token pairs.

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)

Scaled Dot-Product Attention

The attention score between token i and token j is computed as the dot product of Q_i and K_j, divided by the square root of the key dimension to prevent vanishingly small gradients. The formula is: Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) * V. The scaling factor sqrt(d_k) keeps gradients stable for large embedding dimensions.

Multi-Head Attention

Instead of one set of Q, K, V projections, Transformers use multi-head attention: h parallel attention heads, each learning different aspects of token relationships. One head might learn syntactic dependencies (subject-verb), another semantic ones (synonyms). The outputs of all heads are concatenated and projected to produce the final representation.

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: Bidirectional Context

BERT (Bidirectional Encoder Representations from Transformers) reads the entire sequence at once, attending to both left and right context simultaneously. Earlier models like GPT read left-to-right only. This bidirectionality lets BERT understand that 'bank' in 'river bank' differs from 'bank' in 'bank account' by seeing all surrounding words at once.

Special Tokens: CLS and SEP

BERT introduces two special tokens. The [CLS] (classification) token is prepended to every input; after processing, its final hidden state aggregates sentence-level information and is used for classification tasks. The [SEP] token separates two sentences in tasks like question answering or next-sentence prediction. Understanding these tokens is essential when building 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)

Positional Encoding: Order Without Recurrence

Because Transformers process all tokens in parallel, they have no inherent sense of token order. Positional encodings are added to each token embedding to inject position information. BERT uses learned positional embeddings while the original Transformer used sinusoidal functions. Without positional encoding, 'cat bites dog' and 'dog bites cat' would produce identical representations.

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 layers

Encoder Architecture: Layers and Feed-Forward

Each BERT encoder layer consists of two sub-layers: multi-head self-attention followed by a position-wise feed-forward network (two linear layers with a GELU activation). Each sub-layer has a residual connection and layer normalisation. BERT-base stacks 12 such layers; BERT-large uses 24. Deeper stacks capture more abstract linguistic structure.

Token Embeddings: WordPiece Vocabulary

BERT tokenises text using WordPiece subword tokenisation. Rare words are split into frequent sub-units: 'unbelievable' might become ['un', '##believe', '##able']. The ## prefix indicates a continuation subword. This approach handles out-of-vocabulary words gracefully and uses a vocabulary of ~30,000 tokens, balancing coverage and embedding table size.

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: Handling Padding

When processing batches of variable-length sentences, shorter sentences are padded with [PAD] tokens to match the longest sequence. The attention mask is a binary tensor (1 for real tokens, 0 for padding) that tells the model to ignore padding positions in the attention computation. Without this mask, the model would attend to meaningless padding tokens and corrupt its representations.

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 positions

Pre-Training BERT: MLM and NSP

BERT was pre-trained on two tasks. Masked Language Modelling (MLM) randomly masks 15% of tokens and trains BERT to predict the original token from context, forcing bidirectional understanding. Next Sentence Prediction (NSP) trains BERT to determine whether two sentences are consecutive, helping sentence-pair tasks. Fine-tuning then adapts these rich representations to downstream tasks with minimal additional training.

Quick Check

Test your understanding of Machine Learning with Python concepts from this lesson.

Lesson Recap

In this lesson you learned: Transformers use parallel self-attention instead of sequential recurrence, BERT reads bidirectional context using masked language modelling pre-training, and special tokens [CLS] and [SEP] structure BERT's inputs for classification and sentence-pair tasks. Next up we explore how Hugging Face tokenizers encode raw text into the tensor format BERT expects.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
30
Leçons
120

Questions Fréquemment Posées

La leçon « Architecture Transformer : attention, jetons et contexte » est-elle gratuite ?

Oui — le texte complet de « Architecture Transformer : attention, jetons et contexte » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Machine Learning Academy, passe à CoddyKit PRO. Le cours Machine Learning Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Architecture Transformer : attention, jetons et contexte » ?

Vous suivrez le mécanisme d’auto-attention, comprendrez comment BERT lit toute la phrase en une seule fois plutôt que de gauche à droite, et interpréterez les jetons spéciaux CLS et SEP. Tu pratiques Machine Learning Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Machine Learning Academy ?

Aucune expérience préalable n'est requise. Machine Learning Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Architecture Transformer : attention, jetons et contexte » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Machine Learning Academy ?

Oui. Chaque leçon Machine Learning Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Architecture Transformer : attention, jetons et contexte
  2. Tokeniseurs Hugging Face : encoder des textes pour BERT
  3. Ajustement fin de BertForSequenceClassification
  4. Évaluation et inférence : des logits aux étiquettes prédites
← Retour à Machine Learning Academy