wevia-brain/knowledge/deep/llm-engineering-complete.md

LLM Engineering — Guide Complet

Prompt Engineering Avancé

Technique 1: Chain-of-Thought (CoT)

Force le modèle à raisonner étape par étape. Augmente la précision de 20-40% sur les tâches de raisonnement.

Zero-shot CoT : Ajouter "Réfléchis étape par étape." à la fin du prompt. Few-shot CoT : Donner 2-3 exemples avec le raisonnement détaillé.

Q: Un magasin vend 50 pommes le lundi, 30% de plus le mardi. Combien au total?
Réfléchissons étape par étape:
1. Lundi: 50 pommes
2. Mardi: 50 × 1.30 = 65 pommes
3. Total: 50 + 65 = 115 pommes
Réponse: 115 pommes

Technique 2: Tree-of-Thoughts (ToT)

Explorer plusieurs chemins de raisonnement en parallèle, évaluer chacun, garder le meilleur.

Le problème est: [X]

Approche A:
- Étape 1: ...
- Évaluation: Score 7/10 — bon mais [limitation]

Approche B:  
- Étape 1: ...
- Évaluation: Score 9/10 — meilleur car [raison]

→ Je choisis l'approche B.

Technique 3: ReAct (Reasoning + Acting)

Alterner entre réflexion et action (appel d'outil).

Thought: Je dois trouver le prix actuel de l'action Apple.
Action: web_search("Apple stock price today")
Observation: $185.42
Thought: Maintenant je calcule la capitalisation.
Action: calculator("185.42 * 15.7e9")
Observation: 2,911,094,000,000
Answer: La capitalisation d'Apple est d'environ $2.91T.

Technique 4: Self-Consistency

Générer N réponses indépendantes, voter pour la plus fréquente. Réduit les erreurs de 15-25%.

Technique 5: Role Prompting

Tu es un [rôle] avec [X] ans d'expérience. Tu as travaillé sur [contexte spécifique].
Ton approche est [style]. Tu ne fais JAMAIS [anti-pattern].

RAG Architecture Complète

Pipeline RAG optimal

Document → Chunking → Embedding → Vector Store → Retrieval → Re-ranking → Generation

Chunking Strategies

1. Fixed-size : 512 tokens avec 64 tokens d'overlap. Simple, prévisible.
2. Recursive : Découpe par paragraphes → phrases → mots. Respecte la structure.
3. Semantic : Utilise les embeddings pour détecter les changements de sujet.
4. Document-based : 1 chunk = 1 section/chapitre. Pour les docs structurés.

Best practice : Chunks de 256-512 tokens pour la recherche, avec overlap de 10-15%.

Embedding Models (comparaison)

Modèle	Dim	Performance	Vitesse	Coût
nomic-embed-text	768	Très bon	Rapide (local)	Gratuit
BGE-large	1024	Excellent	Moyen	Gratuit
GTE-large	1024	Excellent	Moyen	Gratuit
E5-large-v2	1024	Très bon	Moyen	Gratuit
text-embedding-3-large	3072	Top	API	$0.13/1M tokens

Retrieval Strategies

• Naive : Top-K par similarité cosinus
• MMR (Maximal Marginal Relevance) : Diversifie les résultats
• Hybrid : BM25 (keyword) + vector search, combiner les scores
• Re-ranking : Cross-encoder pour re-scorer les top-50 → retourner top-5
• HyDE : Générer un document hypothétique, l'embedder, chercher les similaires

Re-ranking (critique pour la qualité)

from sentence_transformers import CrossEncoder
reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-12-v2')
pairs = [(query, doc.text) for doc in candidates]
scores = reranker.predict(pairs)
# Trier par score et garder le top-5

Fine-tuning Local

LoRA (Low-Rank Adaptation)

Modifie ~0.1-1% des paramètres. Réduit la mémoire GPU de 10-50x.

from peft import LoraConfig, get_peft_model
config = LoraConfig(
    r=16,                    # Rang (8-64, plus = plus de capacité)
    lora_alpha=32,           # Scaling factor (typiquement 2*r)
    target_modules=["q_proj", "v_proj"],  # Modules à adapter
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(base_model, config)
# Paramètres entraînables: ~0.5% du total

QLoRA (Quantized LoRA)

LoRA sur un modèle 4-bit. Permet de fine-tuner 70B sur une seule GPU 24GB.

from transformers import BitsAndBytesConfig
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True
)

Data Format pour fine-tuning

Instruction format (Alpaca):

{
  "instruction": "Explique ce qu'est le SPF en email",
  "input": "",
  "output": "Le SPF (Sender Policy Framework) est un mécanisme d'authentification email qui permet au propriétaire d'un domaine de spécifier quels serveurs sont autorisés à envoyer des emails en son nom..."
}

Conversation format (ShareGPT):

{
  "conversations": [
    {"from": "human", "value": "Comment configurer DKIM dans PowerMTA?"},
    {"from": "gpt", "value": "Pour configurer DKIM dans PowerMTA:\n\n1. Générer la clé..."}
  ]
}

Inference Optimization

Quantization formats

Format	Bits	Qualité	Vitesse	Usage
FP16	16	Référence	Baseline	Training, best quality
GPTQ	4	~95% FP16	2-3x faster	Production GPU
AWQ	4	~96% FP16	2-3x faster	Production GPU
GGUF Q4_K_M	4	~93% FP16	Variable	CPU + GPU offload
GGUF Q5_K_M	5	~97% FP16	Slightly slower	Meilleur compromis
GGUF Q8_0	8	~99% FP16	Baseline	Quand VRAM suffisante

Ollama specifics

# Modèle avec quantization spécifique
FROM llama3.1:70b-q4_K_M  # 4-bit quantized, ~40GB

# Modelfile custom
FROM deepseek-r1:32b
PARAMETER temperature 0.7
PARAMETER num_predict 4096
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.1
SYSTEM "Tu es WEVIA, l'IA de WEVAL Consulting..."

# Build et run
ollama create wevia-custom -f Modelfile
ollama run wevia-custom

vLLM (haute performance)

# Serveur vLLM avec PagedAttention
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --tensor-parallel-size 1 \
    --gpu-memory-utilization 0.9 \
    --max-model-len 8192 \
    --quantization awq \
    --port 8000

Évaluation de modèles

Métriques

• Perplexity : Mesure la qualité du langage (plus bas = mieux)
• BLEU : Comparaison avec référence (traduction, résumé)
• ROUGE : Recall-oriented, bon pour les résumés
• BERTScore : Similarité sémantique via embeddings
• Human eval : Le gold standard — juges humains

Benchmarks courants

• MMLU : Connaissances générales (57 sujets)
• HumanEval : Génération de code (Python)
• GSM8K : Raisonnement mathématique
• ARC : Raisonnement scientifique
• TruthfulQA : Résistance aux hallucinations
• MT-Bench : Qualité conversationnelle