Context window : De 2K à 2M tokens - l'évolution de la mémoire des LLMs

Prompt : Lis ce PDF de 50 pages et résume-le
Résultat : ❌ "Le document est trop long, veuillez le découper"

Prompt : Lis ce PDF de 50 pages et résume-le
Résultat : ✅ "Voici le résumé en 5 points clés : 1) ..."

100 tokens ≈ 75 mots ≈ 3-4 phrases
1 000 tokens ≈ 750 mots ≈ 1 page A4
4 000 tokens ≈ 3 000 mots ≈ 5-6 pages
100 000 tokens ≈ 75 000 mots ≈ 150 pages = petit roman

# Exemple : Calculer tokens
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")

text = """
Ceci est un exemple de texte assez long pour illustrer
le comptage de tokens. Plus le texte est long, plus
il consomme de tokens dans la fenêtre de contexte.
"""

tokens = tokenizer.encode(text)
print(f"Nombre de tokens : {len(tokens)}")
# Output : Nombre de tokens : 45

# Vérifier si ça rentre dans le context
max_context = 8192  # Llama 3.1 : 8K context
if len(tokens) < max_context:
    print("✅ Rentre dans le context")
else:
    print("❌ Trop long, sera tronqué")

[System prompt] + [User messages] + [Assistant responses] + [New generation]
     100 tokens        500 tokens           300 tokens             ? tokens
|_______________________________________________________________________|
                    Total : < Max context window

# Devoir découper le document
chunks = split_document(book, chunk_size=3000)  # Perte de contexte global
summaries = [summarize(chunk) for chunk in chunks]
final_summary = summarize(summaries)  # Approximation

# Traiter d'un coup
full_text = read_book()  # 100K tokens
summary = llm.complete(f"Résume ce livre :\n\n{full_text}")
# ✅ Comprend l'œuvre dans sa globalité

from anthropic import Anthropic

client = Anthropic(api_key="your-api-key")

# Charger livre complet (ex: 150K tokens)
with open("Les_Miserables.txt") as f:
    book_content = f.read()

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",  # 200K context
    max_tokens=2000,
    messages=[{
        "role": "user",
        "content": f"""Analyse ce roman complet :

{book_content}

Réponds :
1. Thèmes principaux
2. Évolution des personnages
3. Symbolisme récurrent
4. Structure narrative
5. Conclusion de l'auteur"""
    }]
)

print(message.content[0].text)

# Conversation de 50 tours (10K tokens d'historique)
conversation_history = [
    {"role": "user", "content": "Parle-moi de la Révolution française"},
    {"role": "assistant", "content": "La Révolution française (1789-1799)..."},
    # ... 48 tours supplémentaires ...
    {"role": "user", "content": "Reviens sur ce que tu as dit au début sur les causes économiques"}
]

# Avec 4K context : ❌ Historique tronqué, perd le début
# Avec 128K context : ✅ Se souvient de tout

import os
from pathlib import Path

def load_codebase(root_dir, extensions=[".py", ".js", ".ts"]):
    """Charger tous les fichiers de code"""
    files_content = []

    for path in Path(root_dir).rglob("*"):
        if path.suffix in extensions:
            with open(path) as f:
                files_content.append(f"# File: {path}\n{f.read()}\n\n")

    return "".join(files_content)

# Charger projet complet
codebase = load_codebase("./my_project")  # Ex: 80K tokens

# Analyse avec Gemini 1.5 (1M context)
import google.generativeai as genai

genai.configure(api_key="your-api-key")
model = genai.GenerativeModel("gemini-1.5-pro")

response = model.generate_content(f"""Analyse ce codebase :

{codebase}

Tâches :
1. Architecture générale
2. Identifier patterns et anti-patterns
3. Dépendances entre modules
4. Suggestions d'amélioration
5. Bugs potentiels""")

print(response.text)

# Charger 5 articles scientifiques (total 120K tokens)
papers = [
    load_pdf("paper1.pdf"),  # 25K tokens
    load_pdf("paper2.pdf"),  # 30K tokens
    load_pdf("paper3.pdf"),  # 28K tokens
    load_pdf("paper4.pdf"),  # 20K tokens
    load_pdf("paper5.pdf")   # 17K tokens
]

combined = "\n\n---\n\n".join([f"Paper {i+1}:\n{p}" for i, p in enumerate(papers)])

# Analyse comparative
prompt = f"""Voici 5 papers sur l'attention dans les Transformers :

{combined}

Compare leurs approches :
1. Points communs
2. Différences méthodologiques
3. Résultats contradictoires
4. Synthèse des meilleures pratiques"""

response = client.chat.completions.create(
    model="gpt-4-turbo",  # 128K context
    messages=[{"role": "user", "content": prompt}]
)

# Traduire livre technique (100 pages, 75K tokens)
book_en = load_document("technical_manual_EN.pdf")

translation = client.messages.create(
    model="claude-3-opus-20240229",  # 200K context
    messages=[{
        "role": "user",
        "content": f"""Traduis ce manuel technique en français :

{book_en}

Consignes :
- Cohérence terminologique (glossaire unifié)
- Préserver numérotation et structure
- Adapter idiomes culturellement"""
    }],
    max_tokens=100000
)

# ✅ Terminologie cohérente sur tout le document
# ❌ Avec petit context : Termes techniques traduits différemment selon les chunks

Coût attention = n × n = n²
Où n = nombre de tokens

# Pseudo-code attention naïve
def attention(Q, K, V):
    # Q, K, V : (batch, seq_len, dim)
    scores = Q @ K.T  # (seq_len × seq_len) ← QUADRATIQUE
    # Ex: 100K tokens → 10 milliards d'opérations

    weights = softmax(scores)
    output = weights @ V
    return output

Mémoire attention ≈ batch_size × num_heads × seq_len² × 2 bytes (FP16)

Mémoire = 1 × 96 × (128K)² × 2 bytes
        = 1 × 96 × 16.4B × 2
        = 3.1 TB (!!)

Placer information clé à différentes positions dans 32K context :

Position 0-10% (début) : 95% recall
Position 40-60% (milieu) : 65% recall  ← PROBLÈME
Position 90-100% (fin) : 90% recall

# Illustration du problème
long_context = f"""
{'Texte de remplissage ' * 5000}  # 10K tokens de bruit

INFORMATION CRUCIALE : Le code secret est XYZ-789.

{'Texte de remplissage ' * 5000}  # 10K tokens de bruit

Question : Quel est le code secret ?
"""

# Résultat fréquent : "Je ne trouve pas cette information"
# Même si elle est techniquement dans le context !

# Comparaison coûts (GPT-4 Turbo : $10/M tokens input)

# Requête 1K tokens
cost_1k = 1000 / 1_000_000 * 10 = $0.01

# Requête 100K tokens
cost_100k = 100000 / 1_000_000 * 10 = $1.00  # 100x plus cher

# Requête 1M tokens (Gemini : $1.25/M)
cost_1m = 1000000 / 1_000_000 * 1.25 = $1.25

# Flash Attention intégré nativement dans transformers récents
from transformers import AutoModelForCausalLM
import torch

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    torch_dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",  # ← Flash Attention
    device_map="auto"
)

# Context 128K possible sur RTX 4090 grâce à Flash Attention

# Exemple : Longformer (local + global attention)
from transformers import LongformerModel

model = LongformerModel.from_pretrained("allenai/longformer-base-4096")

# Context 4K avec coût linéaire O(n) au lieu de O(n²)

# Pseudo-code Ring Attention
def ring_attention(tokens, num_gpus=8):
    # Découper séquence
    segments = split(tokens, num_gpus)

    # Distribuer sur GPUs
    for gpu_id in range(num_gpus):
        gpu_outputs[gpu_id] = process_segment(
            segments[gpu_id],
            previous_gpu_context=gpu_outputs[gpu_id - 1]
        )

    # Agréger
    return concatenate(gpu_outputs)

Couche 1 : Regarde [token-2K, token+2K]
Couche 2 : Regarde [token-2K, token+2K] des embeddings de couche 1
...
Couche 32 : Portée effective ~100K tokens

# Mistral Large avec 128K context
from mistralai.client import MistralClient

client = MistralClient(api_key="your-api-key")

# Traite 128K tokens avec coût linéaire
response = client.chat(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": very_long_document}]
)

# Étendre RoPE sans réentraînement
rope_scaling = {
    "type": "linear",  # ou "dynamic"
    "factor": 8.0  # 4K × 8 = 32K context
}

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b",
    rope_scaling=rope_scaling,  # ← Étend context
    torch_dtype=torch.bfloat16
)

# Context effectif : 32K au lieu de 4K

import google.generativeai as genai

genai.configure(api_key="your-api-key")

# Analyser film complet (1h30 = ~500K tokens audio/video)
video_file = genai.upload_file("movie.mp4")

model = genai.GenerativeModel("gemini-1.5-pro")
response = model.generate_content([
    video_file,
    """Analyse ce film :
    1. Résumé par acte
    2. Évolution des personnages
    3. Symbolisme visuel
    4. Thèmes principaux
    5. Critique constructive

    Inclus timestamps pour moments clés."""
])

print(response.text)

Test : Cacher information dans 200K tokens, demander de la retrouver

Claude 3 Opus : 95% recall à n'importe quelle position
GPT-4 Turbo : 87% recall (baisse au milieu)
Gemini 1.5 : 92% recall

from anthropic import Anthropic

client = Anthropic(api_key="your-api-key")

# 10 articles scientifiques (total 180K tokens)
papers = load_multiple_pdfs(["paper1.pdf", ..., "paper10.pdf"])

message = client.messages.create(
    model="claude-3-opus-20240229",
    max_tokens=4000,
    messages=[{
        "role": "user",
        "content": f"""Voici 10 papers sur l'IA en médecine :

{papers}

Méta-analyse :
1. Consensus scientifique
2. Méthodologies dominantes
3. Lacunes de recherche
4. Recommandations futures
5. Tableau comparatif résultats"""
    }]
)

from openai import OpenAI

client = OpenAI(api_key="your-api-key")

# Analyse codebase (100K tokens)
codebase = load_all_code_files("./project")

response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {
            "role": "system",
            "content": "Tu es un expert en revue de code et architecture logicielle."
        },
        {
            "role": "user",
            "content": f"""Voici le codebase complet :

{codebase}

Audit complet :
1. Vulnérabilités de sécurité
2. Performance bottlenecks
3. Code smells et refactoring
4. Architecture suggestions
5. Priorité des améliorations"""
        }
    ],
    max_tokens=3000
)

print(response.choices[0].message.content)

# Approche combinée : RAG + Long Context
def hybrid_qa(question, knowledge_base):
    # 1. RAG : Retriever top 10 documents pertinents
    relevant_docs = retrieve_top_k(question, knowledge_base, k=10)
    # Total : ~80K tokens

    # 2. Long Context : Analyser tous ces docs ensemble
    combined = "\n\n---\n\n".join(relevant_docs)

    response = client.chat.completions.create(
        model="gpt-4-turbo",  # 128K context
        messages=[{
            "role": "user",
            "content": f"""Contexte (10 documents les plus pertinents) :

{combined}

Question : {question}

Réponds en citant tes sources (numéro du document)."""
        }]
    )

    return response.choices[0].message.content

# Avantages :
# - Coût réduit (seulement 10 docs au lieu de 10K)
# - Contexte riche (10 docs entiers, pas juste chunks)
# - Cohérence (LLM voit relations entre les 10 docs)

Modèle ↔ [Context Window 128K] ↔ [Mémoire externe 10M tokens]
                                        ↓
                                Retrieval automatique

# Exemple : LongLLMLingua
from llmlingua import PromptCompressor

compressor = PromptCompressor()

# Document 50K tokens
long_doc = load_document("report.pdf")  # 50K tokens

# Compresser à 10K tokens (5x)
compressed = compressor.compress_prompt(
    long_doc,
    target_token=10000,
    condition_in_question="Résume les points clés"
)

# Utiliser compressed au lieu de long_doc
# ✅ Coût divisé par 5
# ✅ Latence divisée par 5
# ⚠️ Perte d'information minime (~2%)