Fondations LLM

"Bonjour, je cherche un contrat d'electricite"

["Bon", "jour", ",", " je", " cherche", " un", " contrat", " d", "'", "elect", "ric", "ite"]

import tiktoken  # tokenizer d'OpenAI (pip install tiktoken)

enc = tiktoken.encoding_for_model("gpt-4o")
tokens = enc.encode("Bonjour, je cherche un contrat d'electricite")
print(f"{len(tokens)} tokens")  # → 12 tokens
print(enc.decode_single_token_bytes(t) for t in tokens])

# Avec Hugging Face Transformers (PyTorch)
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
result = tokenizer("Bonjour, je cherche un contrat d'electricite")
print(result["input_ids"])        # → [1, 9038, 28725, ...]
print(len(result["input_ids"]))   # → 13 tokens (different ! chaque modele a son tokenizer)

import torch
from transformers import AutoTokenizer, AutoModel

# Charger un modele d'embeddings (sentence-transformers)
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")

# Embedder des mots
phrases = ["roi", "reine", "banane"]
inputs = tokenizer(phrases, padding=True, return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs)
    # Mean pooling sur les tokens → un vecteur par phrase
    embeddings = outputs.last_hidden_state.mean(dim=1)

print(embeddings.shape)  # → torch.Size([3, 384])  (3 phrases, 384 dimensions)

# Similarite cosinus
from torch.nn.functional import cosine_similarity
print(cosine_similarity(embeddings[0], embeddings[1], dim=0))  # roi↔reine  → 0.72 (proche !)
print(cosine_similarity(embeddings[0], embeddings[2], dim=0))  # roi↔banane → 0.11 (loin)

roi - homme + femme ≈ reine

"Le chat dort sur le canape car il est fatigue"

Attention(Q, K, V) = softmax(Q * K^T / sqrt(d_k)) * V

Q = Query   → "Qu'est-ce que je cherche ?" (le token actuel)
K = Key     → "Qu'est-ce que je contiens ?" (chaque autre token)
V = Value   → "Quelle information je donne ?" (le contenu a transmettre)

Le softmax normalise les poids pour qu'ils somment a 1.
sqrt(d_k) empeche les valeurs de devenir trop grandes.

import numpy as np

def attention(Q, K, V):
    """Self-attention en 4 lignes de NumPy."""
    d_k = Q.shape[-1]
    scores = Q @ K.T / np.sqrt(d_k)    # similarite entre Q et K
    weights = np.exp(scores) / np.exp(scores).sum(axis=-1, keepdims=True)  # softmax
    return weights @ V                   # moyenne ponderee des valeurs

# Exemple : 4 tokens, dimension 8
np.random.seed(42)
Q = np.random.randn(4, 8)  # 4 tokens, chacun un vecteur de dim 8
K = np.random.randn(4, 8)
V = np.random.randn(4, 8)

output = attention(Q, K, V)
print(output.shape)  # → (4, 8)  — chaque token recoit un vecteur "enrichi"

# En PyTorch, c'est une seule ligne :
import torch
import torch.nn.functional as F
attn_output = F.scaled_dot_product_attention(
    torch.randn(4, 8), torch.randn(4, 8), torch.randn(4, 8)
)  # PyTorch gere le scaling et le softmax pour toi

Temperature = 0.0 → "Le chat est sur le tapis."
                       Toujours la meme reponse. Factuel.

Temperature = 0.7 → "Le chat somnole paisiblement sur le tapis."
                       Un peu de variete. Bon equilibre.

Temperature = 1.5 → "Le chat cosmique danse sur un tapis de nebuleuses."
                       Creatif mais peut delirer.

import torch
import torch.nn.functional as F

# Logits bruts du modele (scores avant softmax)
logits = torch.tensor([2.0, 1.5, 0.8, 0.3, -0.5])  # 5 tokens candidats
labels = ["chat", "chien", "oiseau", "dragon", "dinosaure"]

# Temperature = 1.0 (distribution naturelle)
probs_t1 = F.softmax(logits / 1.0, dim=0)
print(dict(zip(labels, probs_t1.tolist())))
# → {'chat': 0.42, 'chien': 0.25, 'oiseau': 0.13, 'dragon': 0.08, 'dinosaure': 0.03}

# Temperature = 0.3 (quasi-deterministe)
probs_t03 = F.softmax(logits / 0.3, dim=0)
# → {'chat': 0.89, 'chien': 0.09, ...}  ← "chat" domine

# Temperature = 2.0 (tres aleatoire)
probs_t2 = F.softmax(logits / 2.0, dim=0)
# → {'chat': 0.28, 'chien': 0.23, ...}  ← distribution aplatie

# Top-p sampling (nucleus)
def top_p_sample(logits, p=0.9):
    probs = F.softmax(logits, dim=0)
    sorted_probs, sorted_idx = torch.sort(probs, descending=True)
    cumsum = torch.cumsum(sorted_probs, dim=0)
    mask = cumsum - sorted_probs < p    # garder jusqu'a cumsum >= p
    filtered = sorted_probs * mask
    return torch.multinomial(filtered / filtered.sum(), 1)  # echantillonner