In-Context Learning : LLMs qui Apprennent Sans Fine-Tuning

# Sans ICL (zero-shot)
prompt = "Traduis en anglais : Le chat dort."
response = llm(prompt)
# → "The cat sleeps." (OK, mais parfois imprécis)

# Avec ICL (few-shot)
prompt = """
Traduis en anglais :

Français : Le chien court.
Anglais : The dog runs.

Français : La maison est grande.
Anglais : The house is big.

Français : Je mange une pomme.
Anglais : I eat an apple.

Français : Le chat dort.
Anglais :"""

response = llm(prompt)
# → "The cat sleeps." (Plus fiable, pattern appris)

prompt = "Traduis en anglais : Le chat dort."

# Pas d'exemples, le modèle doit comprendre de l'instruction seule

# Zero-shot sentiment analysis
prompt = "Classifie le sentiment de cette phrase : 'Ce film était génial !'"

response = llm(prompt)
# → "Positif" ✅ (tâche connue)

# Zero-shot tâche obscure
prompt = "Convertis ce nom en notation IPA phonétique : 'Beauchamp'"

response = llm(prompt)
# → Peut échouer sans exemples ❌

prompt = """
Classifie le sentiment (Positif/Négatif/Neutre) :

Phrase : "J'adore ce produit !"
Sentiment : Positif

Phrase : "C'est vraiment nul."
Sentiment : Négatif

Phrase : "Le ciel est bleu."
Sentiment : Neutre

Phrase : "Ce restaurant est incroyable !"
Sentiment :"""

response = llm(prompt)
# → "Positif" ✅

prompt = """
Transforme le nom en version féminine :

Exemple : Julien → Julienne

Question : François → ?
"""

response = llm(prompt)
# → "Françoise" ✅

# Gemini 1.5 Pro (2M context)
prompt = """
Voici 500 exemples de résumés d'articles scientifiques :

Article 1 : [...]
Résumé 1 : [...]

Article 2 : [...]
Résumé 2 : [...]

... (498 autres exemples)

Article 501 : [nouveau texte]
Résumé 501 :
"""

# Modèle apprend style précis de résumé sur 500 exemples
# Performance proche fine-tuning !

1. Détectent patterns dans le contexte
2. "Mémorisent" associations
3. Appliquent à nouveaux cas

Exemple :
  Contexte : "cat → animal, rose → flower"
  Nouveau : "oak → ?"
  Induction head : "oak est comme cat/rose → type de chose → tree"

Prompt avec exemples :
  [cat] → [animal]
      ↓ Induction head détecte pattern
  [rose] → [flower]
      ↓ Généralise : "X → catégorie de X"
  [oak] → [?]
      ↓ Applique pattern appris
  [oak] → [tree] ✅

Query : "oak → ?"

Attention sur :
  "cat → animal" : 0.35  (pattern similaire)
  "rose → flower" : 0.40  (pattern similaire)
  "Le ciel est bleu" : 0.05  (non-pertinent)
  Instruction initiale : 0.20

→ Modèle "regarde" surtout les exemples pertinents
→ Infère : "oak → [type/catégorie]" → "tree"

Pré-entraînement :
  Millions de documents avec patterns variés
  → Modèle apprend : "Si je vois A→B, C→D, alors E→?"
  → Développe capacité de méta-apprentissage

Inférence (ICL) :
  Nouveau pattern dans prompt
  → Modèle reconnaît : "Ah, c'est un problème d'apprentissage de pattern"
  → Active circuits méta-apprentissage
  → Généralise

GPT-4o : 128K tokens
  Exemple avg : 100 tokens (input + output)
  → Max ~1,000 exemples
  Mais prompt système + instructions = -10K
  → Réaliste : 500-800 exemples max

GPT-4o mini : 128K tokens
  Même calcul, mais moins cher

Gemini 1.5 Pro : 2M tokens
  → 10,000-15,000 exemples possibles ! ✅

# ✅ FORMAT COHÉRENT
prompt = """
Q: What is 2+2?
A: 4

Q: What is 5+3?
A: 8

Q: What is 10+7?
A:"""
# → "17" ✅

# ❌ FORMAT INCOHÉRENT
prompt = """
Question: What is 2+2?
Réponse: 4

Q: What is 5+3?
A: 8

What is 10+7?
"""
# → Peut confondre le modèle ❌

import random

examples = [
    ("cat", "animal"),
    ("rose", "flower"),
    ("oak", "tree"),
    ("gold", "metal"),
    ("water", "liquid")
]

# Test 10 ordres aléatoires
accuracies = []
for _ in range(10):
    random.shuffle(examples)
    prompt = create_prompt(examples)
    acc = evaluate(prompt)
    accuracies.append(acc)

print(f"Mean: {np.mean(accuracies):.1%}")
print(f"Std: {np.std(accuracies):.1%}")

# Résultat typique :
# Mean: 82.3%
# Std: 8.7%  ← Variance significative !

# ❌ EXEMPLES INCORRECTS
prompt = """
Traduire :
"Hello" → "Bonjour"
"Goodbye" → "Au revoir"
"Cat" → "Chien"  ← ERREUR !

"Dog" → ?
"""
# → "Chat" (apprend le mauvais pattern) ❌

# ✅ EXEMPLES CORRECTS
prompt = """
"Cat" → "Chat"
"Dog" → ?
"""
# → "Chien" ✅

                Performance requise
                    ↑
                    |
    FINE-TUNING     |     FINE-TUNING
    (prod critique) |  (si budget data)
                    |
  ──────────────────┼──────────────────→
                    |            Rapidité
    ICL             |     ICL      requise
    (prototypage)   |  (itération rapide)
                    |
                    ↓

# Phase 1 : Prototyper avec ICL
few_shot_prompt = """
Exemples :
[5 exemples]

Nouvelle requête :
"""

# Tester, itérer sur prompt
# Identifier ce qui marche

# Phase 2 : Collecter données
# Utiliser ICL en prod
# Logger toutes les entrées/sorties
# → Dataset de 10K exemples

# Phase 3 : Fine-tuner
# Entraîner modèle custom sur 10K exemples
# → Performance +15-25%
# → Coût runtime -70% (pas de tokens examples)

# Phase 4 : Production
# Modèle fine-tuné pour 95% cas
# ICL pour edge cases / nouvelles catégories

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

def select_diverse_examples(examples, embeddings, k=5):
    """Sélectionne k exemples les plus divers"""

    selected = []
    selected_embeddings = []

    # Premier exemple : aléatoire
    idx = np.random.randint(len(examples))
    selected.append(examples[idx])
    selected_embeddings.append(embeddings[idx])

    # Sélectionner k-1 suivants
    while len(selected) < k:
        # Calculer similarité avec déjà sélectionnés
        sims = cosine_similarity(embeddings, selected_embeddings)
        avg_sim = sims.mean(axis=1)

        # Choisir le MOINS similaire
        idx = avg_sim.argmin()

        selected.append(examples[idx])
        selected_embeddings.append(embeddings[idx])

    return selected

# Usage
diverse_examples = select_diverse_examples(all_examples, embeddings, k=10)
prompt = create_prompt(diverse_examples)

from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# Indexer tous les exemples possibles
examples_db = Chroma.from_texts(
    [ex["input"] for ex in all_examples],
    OpenAIEmbeddings(),
    metadatas=all_examples
)

def dynamic_few_shot(query: str, k: int = 5):
    """Récupère k exemples les plus similaires à la query"""

    # Rechercher exemples similaires
    similar = examples_db.similarity_search(query, k=k)

    # Construire prompt
    prompt = "Voici des exemples :\n\n"
    for ex in similar:
        prompt += f"Input: {ex.metadata['input']}\n"
        prompt += f"Output: {ex.metadata['output']}\n\n"

    prompt += f"Input: {query}\nOutput:"

    return prompt

# Utilisation
query = "Traduire : The cat sleeps"
prompt = dynamic_few_shot(query, k=5)
# → Récupère 5 exemples de traduction similaires

prompt = """
Résous le problème étape par étape :

Q: Si j'ai 5 pommes et j'en achète 3 de plus, puis j'en donne 2, combien en ai-je ?
Raisonnement :
  1. Départ : 5 pommes
  2. J'achète 3 : 5 + 3 = 8 pommes
  3. Je donne 2 : 8 - 2 = 6 pommes
Réponse : 6

Q: Si j'ai 10 euros et je dépense 3.50, puis je gagne 5, combien ai-je ?
Raisonnement :
  1. Départ : 10 euros
  2. Je dépense 3.50 : 10 - 3.50 = 6.50 euros
  3. Je gagne 5 : 6.50 + 5 = 11.50 euros
Réponse : 11.50

Q: Si un train va à 120 km/h pendant 30 min, quelle distance parcourt-il ?
Raisonnement :
"""

# LLM va suivre le pattern CoT appris

TEMPLATE = """
{instruction}

Exemples :

{examples}

Question :
{query}

Réponse :
"""

def create_prompt(instruction, examples, query):
    examples_str = "\n\n".join([
        f"Input: {ex['input']}\nOutput: {ex['output']}"
        for ex in examples
    ])

    return TEMPLATE.format(
        instruction=instruction,
        examples=examples_str,
        query=query
    )

configurations = [
    {"num_examples": 3, "order": "random"},
    {"num_examples": 5, "order": "random"},
    {"num_examples": 10, "order": "random"},
    {"num_examples": 5, "order": "diverse"},
    {"num_examples": 5, "order": "retrieved"},
]

results = []
for config in configurations:
    prompt = create_prompt_with_config(config)
    accuracy = evaluate(prompt, test_set)
    results.append({"config": config, "accuracy": accuracy})

# Choisir meilleure config
best = max(results, key=lambda x: x["accuracy"])
print(f"Best: {best['config']} → {best['accuracy']:.1%}")

# Classifier tickets support en catégories
prompt = """
Classifie le ticket support :

Ticket : "Mon mot de passe ne fonctionne plus"
Catégorie : Compte

Ticket : "Le paiement a échoué"
Catégorie : Facturation

Ticket : "Comment utiliser la fonctionnalité X ?"
Catégorie : Question produit

Ticket : "L'app crash au démarrage"
Catégorie : Bug technique

Ticket : "Je veux annuler mon abonnement"
Catégorie : Abonnement

Ticket : "La page ne charge pas"
Catégorie :"""

# → "Bug technique" ✅

# Extraire infos structurées de texte libre
prompt = """
Extrait nom, email, téléphone :

Texte : "Je m'appelle Marie Dubois, contactez-moi au 06.12.34.56.78 ou [email protected]"
Résultat : {"nom": "Marie Dubois", "email": "[email protected]", "tel": "06.12.34.56.78"}

Texte : "Paul Martin - [email protected] - 01 23 45 67 89"
Résultat : {"nom": "Paul Martin", "email": "[email protected]", "tel": "01 23 45 67 89"}

Texte : "Appelez Sophie au 0678901234, email: [email protected]"
Résultat :"""

# → {"nom": "Sophie", "email": "[email protected]", "tel": "0678901234"} ✅

# Convertir formats de données
prompt = """
Transforme CSV en JSON :

CSV : name,age,city
      Alice,30,Paris
JSON : [{"name": "Alice", "age": 30, "city": "Paris"}]

CSV : product,price,stock
      Laptop,999,5
JSON : [{"product": "Laptop", "price": 999, "stock": 5}]

CSV : title,author,year
      1984,Orwell,1949
JSON :"""

# → [{"title": "1984", "author": "Orwell", "year": 1949}] ✅

# 1. Indexer 1000 exemples dans Chroma
# 2. Pour chaque query, récupérer 5 plus similaires
# 3. Construire prompt avec ces 5
# 4. Comparer vs 5 exemples fixes aléatoires