📚 Cheatsheet Phase 2

1. Panorama des Modèles Open Source 2026

2. Licences Open Source - Comparatif

3. Hugging Face Hub - Téléchargement de Modèles

Installation

pip install huggingface_hub

Recherche de Modèles

from huggingface_hub import HfApi, list_models

# Lister les modèles
api = HfApi()
models = list_models(
    filter="text-generation",
    sort="downloads",
    direction=-1,
    limit=10
)

for model in models:
    print(f"{model.id} - {model.downloads} téléchargements")

Téléchargement Complet

from huggingface_hub import snapshot_download

# Télécharger un modèle complet
model_path = snapshot_download(
    repo_id="mistralai/Mistral-7B-Instruct-v0.3",
    cache_dir="./models",
    local_dir="./models/mistral-7b",
    local_dir_use_symlinks=False
)

Téléchargement Fichier Spécifique

from huggingface_hub import hf_hub_download

# Télécharger un fichier spécifique (ex: GGUF)
file_path = hf_hub_download(
    repo_id="TheBloke/Mistral-7B-Instruct-v0.3-GGUF",
    filename="mistral-7b-instruct-v0.3.Q4_K_M.gguf",
    cache_dir="./models"
)

Authentification

# Via CLI
huggingface-cli login

# Via code
from huggingface_hub import login
login(token="hf_xxxxxxxxxxxxx")

# Variables d'environnement
export HF_TOKEN="hf_xxxxxxxxxxxxx"

4. Transformers Pipeline - API Simplifiée

Installation

pip install transformers torch accelerate

Text Generation

from transformers import pipeline

generator = pipeline(
    "text-generation",
    model="mistralai/Mistral-7B-Instruct-v0.3",
    device_map="auto"
)

result = generator(
    "Explique l'IA en 3 phrases:",
    max_new_tokens=100,
    temperature=0.7,
    do_sample=True
)
print(result[0]['generated_text'])

Sentiment Analysis

sentiment = pipeline(
    "sentiment-analysis",
    model="nlptown/bert-base-multilingual-uncased-sentiment"
)

result = sentiment("Ce produit est excellent !")
# [{'label': '5 stars', 'score': 0.89}]

Named Entity Recognition (NER)

ner = pipeline(
    "ner",
    model="Jean-Baptiste/camembert-ner",
    aggregation_strategy="simple"
)

text = "Emmanuel Macron visite Paris demain."
entities = ner(text)
# [{'entity_group': 'PER', 'word': 'Emmanuel Macron', ...}]

Translation

translator = pipeline(
    "translation",
    model="Helsinki-NLP/opus-mt-fr-en"
)

result = translator("Bonjour le monde")
# [{'translation_text': 'Hello world'}]

Summarization

summarizer = pipeline(
    "summarization",
    model="facebook/bart-large-cnn"
)

long_text = "..."
summary = summarizer(
    long_text,
    max_length=130,
    min_length=30,
    do_sample=False
)

Question Answering

qa = pipeline(
    "question-answering",
    model="deepset/roberta-base-squad2"
)

result = qa(
    question="Qui a inventé Python ?",
    context="Python a été créé par Guido van Rossum en 1991."
)
# {'answer': 'Guido van Rossum', 'score': 0.97}

5. AutoModel & Tokenizer - Contrôle Avancé

Chargement Modèle et Tokenizer

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    GenerationConfig
)
import torch

model_name = "mistralai/Mistral-7B-Instruct-v0.3"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

Génération de Texte

prompt = "Explique la théorie de la relativité:"

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=200,
    temperature=0.7,
    top_p=0.9,
    top_k=50,
    repetition_penalty=1.1,
    do_sample=True,
    pad_token_id=tokenizer.eos_token_id
)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

Configuration de Génération

generation_config = GenerationConfig(
    max_new_tokens=500,
    temperature=0.8,
    top_p=0.95,
    top_k=50,
    repetition_penalty=1.15,
    do_sample=True,
    num_beams=1,
    early_stopping=False
)

# Utilisation
outputs = model.generate(
    **inputs,
    generation_config=generation_config
)

Batch Processing

prompts = [
    "Question 1: ...",
    "Question 2: ...",
    "Question 3: ..."
]

# Padding pour batch
tokenizer.pad_token = tokenizer.eos_token
inputs = tokenizer(
    prompts,
    return_tensors="pt",
    padding=True,
    truncation=True,
    max_length=512
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=100)
responses = tokenizer.batch_decode(outputs, skip_special_tokens=True)

Optimisation Mémoire

# 8-bit quantization
from transformers import BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0
)

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto"
)

# 4-bit quantization (encore plus compact)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True
)

6. Datasets Library - Manipulation de Données

Installation

pip install datasets

Chargement Dataset

from datasets import load_dataset

# Dataset public
dataset = load_dataset("squad")
print(dataset)
# DatasetDict({
#     train: Dataset({features: ['id', 'title', 'context', 'question', 'answers']})
#     validation: Dataset(...)
# })

# Sous-ensemble de données
dataset = load_dataset("squad", split="train[:1000]")

# Streaming pour gros datasets
dataset = load_dataset("squad", streaming=True)

Manipulation de Données

# Map - Appliquer une fonction
def preprocess(example):
    example['text_length'] = len(example['text'])
    return example

dataset = dataset.map(preprocess)

# Filter - Filtrer les exemples
dataset = dataset.filter(lambda x: x['text_length'] > 100)

# Select - Sélectionner colonnes
dataset = dataset.select_columns(['text', 'label'])

# Shuffle - Mélanger
dataset = dataset.shuffle(seed=42)

Train/Test Split

from datasets import DatasetDict

# Split simple
split_dataset = dataset.train_test_split(test_size=0.2, seed=42)
train_data = split_dataset['train']
test_data = split_dataset['test']

# Split train/val/test
train_test = dataset.train_test_split(test_size=0.3, seed=42)
test_val = train_test['test'].train_test_split(test_size=0.5, seed=42)

final_dataset = DatasetDict({
    'train': train_test['train'],
    'validation': test_val['train'],
    'test': test_val['test']
})

Sauvegarde et Chargement

# Sauvegarder
dataset.save_to_disk("./my_dataset")

# Charger
from datasets import load_from_disk
dataset = load_from_disk("./my_dataset")

# Export CSV/JSON
dataset.to_csv("output.csv")
dataset.to_json("output.json")

Dataset Custom

from datasets import Dataset

data = {
    'text': ['exemple 1', 'exemple 2', 'exemple 3'],
    'label': [0, 1, 0]
}

dataset = Dataset.from_dict(data)

# Depuis Pandas
import pandas as pd
df = pd.read_csv("data.csv")
dataset = Dataset.from_pandas(df)

Tokenization Batch

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

def tokenize_function(examples):
    return tokenizer(
        examples["text"],
        padding="max_length",
        truncation=True,
        max_length=512
    )

tokenized_dataset = dataset.map(
    tokenize_function,
    batched=True,
    batch_size=1000
)

7. Ollama - Commands & API

Installation

# Linux / macOS
curl -fsSL https://ollama.com/install.sh | sh

# Windows
# Télécharger depuis https://ollama.com/download

# Vérifier
ollama --version

Commandes Essentielles

# Télécharger un modèle
ollama pull llama3.1:8b

# Lister les modèles installés
ollama list

# Lancer une conversation
ollama run llama3.1:8b

# Supprimer un modèle
ollama rm llama3.1:8b

# Afficher informations modèle
ollama show llama3.1:8b

# Copier un modèle
ollama cp llama3.1:8b my-llama

API REST

# Lancer le serveur (automatique avec run)
ollama serve

# Generate endpoint
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Pourquoi le ciel est bleu ?",
  "stream": false
}'

# Chat endpoint
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.1:8b",
  "messages": [
    {"role": "user", "content": "Bonjour !"}
  ]
}'

Python Client

import requests
import json

def ollama_generate(prompt, model="llama3.1:8b"):
    url = "http://localhost:11434/api/generate"
    data = {
        "model": model,
        "prompt": prompt,
        "stream": False,
        "options": {
            "temperature": 0.7,
            "top_p": 0.9
        }
    }

    response = requests.post(url, json=data)
    return response.json()["response"]

result = ollama_generate("Explique Python en 2 phrases")

Modelfile - Créer un Modèle Custom

# Créer fichier 'Modelfile'
FROM llama3.1:8b

PARAMETER temperature 0.8
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER num_ctx 4096

SYSTEM """
Tu es un assistant spécialisé en Python.
Réponds toujours avec des exemples de code.
"""

# Créer le modèle
ollama create python-expert -f Modelfile

# Utiliser
ollama run python-expert

Modèles Populaires

8. LM Studio - Interface Graphique

Télécharger des Modèles

1. Ouvrir LM Studio
2. Cliquer sur l'onglet Search
3. Rechercher un modèle (ex: "Mistral 7B")
4. Choisir une quantization (Q4_K_M recommandé)
5. Cliquer sur Download

Mode Chat

• Sélectionner un modèle dans la liste
• Configurer les paramètres (température, context, etc.)
• Choisir un preset (Instruct, Chat, Alpaca, etc.)
• Commencer la conversation

Server Mode - API OpenAI Compatible

# Dans LM Studio: Developer > Local Server > Start Server
# Par défaut: http://localhost:1234

# Test avec curl
curl http://localhost:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "local-model",
    "messages": [
      {"role": "user", "content": "Bonjour !"}
    ],
    "temperature": 0.7
  }'

Python avec OpenAI SDK

from openai import OpenAI

# Pointer vers LM Studio
client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")

response = client.chat.completions.create(
    model="local-model",
    messages=[
        {"role": "system", "content": "Tu es un assistant utile."},
        {"role": "user", "content": "Explique le machine learning"}
    ],
    temperature=0.7,
)

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

Configuration Avancée

Quantizations GGUF

9. llama.cpp - Inference Native

Installation

# Clone repository
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Build (Linux/Mac)
make

# Build avec CUDA (NVIDIA GPU)
make LLAMA_CUBLAS=1

# Build avec Metal (Apple Silicon)
make LLAMA_METAL=1

# Build Windows (MinGW)
mingw32-make.exe

Conversion de Modèles

# Convertir modèle Hugging Face en GGUF
python convert.py /path/to/model --outfile model.gguf

# Quantizer le modèle
./quantize model.gguf model-q4_k_m.gguf q4_k_m

Niveaux de Quantization GGUF

Inference Simple

# Lancer inference
./main -m models/mistral-7b-q4_k_m.gguf \
       -p "Explique la photosynthèse:" \
       -n 256 \
       -t 8 \
       --temp 0.7 \
       --top-p 0.9

Paramètres Importants

./main -m model.gguf \
  -p "prompt"              # Prompt d'entrée
  -n 512                   # Nombre max tokens générés
  -t 8                     # Threads CPU
  -c 2048                  # Context size
  --temp 0.7               # Temperature
  --top-p 0.9              # Nucleus sampling
  --top-k 40               # Top-k sampling
  --repeat-penalty 1.1     # Pénalité répétition
  -ngl 32                  # GPU layers (avec CUDA)
  -b 512                   # Batch size
  --mlock                  # Lock en RAM
  -f prompt.txt            # Charger prompt depuis fichier

Mode Serveur

# Lancer serveur HTTP
./server -m models/mistral-7b-q4_k_m.gguf \
         -c 2048 \
         -ngl 32 \
         --port 8080

# Requête depuis client
curl http://localhost:8080/completion \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Bonjour",
    "n_predict": 128
  }'

10. vLLM - Serveur Haute Performance

Installation

pip install vllm

# Avec CUDA 11.8
pip install vllm --extra-index-url https://download.pytorch.org/whl/cu118

# Avec CUDA 12.1
pip install vllm --extra-index-url https://download.pytorch.org/whl/cu121

Lancer Serveur

# Lancer serveur API OpenAI-compatible
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.3 \
    --host 0.0.0.0 \
    --port 8000 \
    --dtype bfloat16 \
    --max-model-len 4096 \
    --tensor-parallel-size 1

Python API

from vllm import LLM, SamplingParams

# Charger modèle
llm = LLM(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    dtype="bfloat16",
    max_model_len=4096,
    gpu_memory_utilization=0.9
)

# Configuration sampling
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    top_k=50,
    max_tokens=256
)

# Génération
prompts = [
    "Explique Python:",
    "Qu'est-ce que vLLM ?"
]

outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(output.outputs[0].text)

Client OpenAI

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[
        {"role": "user", "content": "Bonjour !"}
    ],
    temperature=0.7,
    max_tokens=200
)

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

PagedAttention - Concept Clé

Benchmarking

# Benchmark throughput
python benchmarks/benchmark_throughput.py \
    --model mistralai/Mistral-7B-Instruct-v0.3 \
    --num-prompts 1000 \
    --input-len 128 \
    --output-len 256

# Benchmark latency
python benchmarks/benchmark_latency.py \
    --model mistralai/Mistral-7B-Instruct-v0.3 \
    --input-len 128 \
    --output-len 256

Paramètres Avancés

11. Paramètres de Génération - Guide Complet

Temperature

Top-p (Nucleus Sampling)

Top-k

Limite aux k tokens les plus probables

• 40-50 : Bon équilibre
• 20-30 : Plus conservateur
• 0 : Désactivé (utiliser top_p)

Repetition Penalty

Stop Tokens

# Arrêter génération sur patterns spécifiques
stop_tokens = [
    "\n\n",           # Double newline
    "###",            # Marqueur section
    "User:",          # Début nouveau tour
    "",           # EOS token
    "[END]"           # Marqueur custom
]

outputs = model.generate(
    **inputs,
    max_new_tokens=500,
    eos_token_id=tokenizer.eos_token_id,
    pad_token_id=tokenizer.pad_token_id,
    stop_strings=stop_tokens
)

Exemple Configurations

12. Guide de Quantization

Comparatif Formats

bitsandbytes - INT8 & INT4

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

# Configuration 8-bit
bnb_config_8bit = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0,
    llm_int8_has_fp16_weight=False
)

# Configuration 4-bit (NF4)
bnb_config_4bit = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True
)

model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-Instruct-v0.3",
    quantization_config=bnb_config_4bit,
    device_map="auto"
)

GPTQ - Quantization Aggressive

from transformers import AutoModelForCausalLM

# Charger modèle GPTQ pré-quantizé
model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/Mistral-7B-Instruct-v0.3-GPTQ",
    device_map="auto",
    trust_remote_code=False,
    revision="gptq-4bit-32g-actorder_True"
)

AWQ - Activation-aware Quantization

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

# Charger modèle AWQ
model = AutoAWQForCausalLM.from_quantized(
    "TheBloke/Mistral-7B-Instruct-v0.3-AWQ",
    fuse_layers=True,
    trust_remote_code=False,
    safetensors=True
)

tokenizer = AutoTokenizer.from_pretrained(
    "TheBloke/Mistral-7B-Instruct-v0.3-AWQ"
)

Recommandations par GPU

13. Calculateur VRAM

Formule de Base

Exemples de Calcul

Table de Référence VRAM

Facteurs d'Overhead

• KV Cache: Dépend de context length et batch size
• Activations: Proportionnel à batch size
• Gradients: Seulement en training (égal taille modèle)
• Optimizer States: Training uniquement (AdamW = 2x modèle)

KV Cache Calculation

# Exemple: Llama 7B, context 2048, batch 1, FP16
# 32 layers × 4096 hidden × 2048 context × 1 batch × 2 bytes
# = 536,870,912 bytes ≈ 0.5 GB

Optimisations Mémoire

14. Modèles Spécialisés en Code

Top Modèles 2026

DeepSeek-Coder - Exemple

from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "deepseek-ai/deepseek-coder-6.7b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

prompt = """### Instruction:
Write a Python function to calculate fibonacci numbers.

### Response:
"""

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

StarCoder 2 - Code Completion

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "bigcode/starcoder2-7b",
    device_map="auto",
    torch_dtype=torch.bfloat16
)
tokenizer = AutoTokenizer.from_pretrained("bigcode/starcoder2-7b")

# Fill-in-the-middle
code = """def calculate_area(radius):
    
    return area
"""

inputs = tokenizer.encode(code, return_tensors="pt").to(model.device)
outputs = model.generate(inputs, max_new_tokens=50)
print(tokenizer.decode(outputs[0]))

Benchmarks Explication

Use Cases Spécialisés

15. Chat Templates - Formats de Conversation

ChatML Format (OpenAI, Mistral)

<|im_start|>system
Tu es un assistant utile et précis.<|im_end|>
<|im_start|>user
Quelle est la capitale de France ?<|im_end|>
<|im_start|>assistant
La capitale de la France est Paris.<|im_end|>

Llama Format

[INST] <>
Tu es un assistant utile et précis.
<>

Quelle est la capitale de France ? [/INST]
La capitale de la France est Paris.
[INST] Quelle est sa population ? [/INST]

[INST] Tu es un assistant utile.

Quelle est la capitale de France ? [/INST]
La capitale de la France est Paris.
[INST] Et sa population ? [/INST]

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")

messages = [
    {"role": "system", "content": "Tu es un assistant utile."},
    {"role": "user", "content": "Explique la photosynthèse"},
    {"role": "assistant", "content": "La photosynthèse est..."},
    {"role": "user", "content": "Merci, et pour les animaux ?"}
]

# Appliquer template automatiquement
formatted = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

print(formatted)

# Définir template Jinja2
custom_template = """{% for message in messages %}
{% if message['role'] == 'system' %}
### System: {{ message['content'] }}
{% elif message['role'] == 'user' %}
### Human: {{ message['content'] }}
{% elif message['role'] == 'assistant' %}
### Assistant: {{ message['content'] }}
{% endif %}
{% endfor %}
### Assistant:"""

tokenizer.chat_template = custom_template

formatted = tokenizer.apply_chat_template(messages, tokenize=False)

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Mistral-7B-Instruct-v0.3"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

messages = [
    {"role": "system", "content": "Tu es un expert Python."},
    {"role": "user", "content": "Comment lire un fichier CSV ?"}
]

inputs = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt",
    add_generation_prompt=True
).to(model.device)

outputs = model.generate(inputs, max_new_tokens=300)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)