Small Language Models : Phi-3, Gemma, Mistral 7B

Qualité > Quantité

GPT-3 (2020) : 300B tokens (web crawl brut)
Phi-3 (2024) : 3.3T tokens (filtrés, synthétiques de haute qualité)

→ Moins de paramètres, mais mieux entraînés

Phi-3 (3.8B) :
- FP16 : 7.6 GB
- INT8 : 3.8 GB
- INT4 : 2.3 GB (Q4_K_M)

→ Tient sur MacBook Air M2 (8GB RAM)

Paramètres : 3.8B
Context : 128K tokens
Taille : 2.3GB (quantized Q4)
Hardware : 4GB RAM minimum
Performances : Rivalise GPT-3.5 sur MMLU

# Avec Ollama
ollama run phi3.5

# Avec Transformers
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3.5-mini-instruct")
tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3.5-mini-instruct")

messages = [{"role": "user", "content": "Écris une fonction Python pour Fibonacci"}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt")
outputs = model.generate(inputs, max_new_tokens=200)

print(tokenizer.decode(outputs[0]))

Paramètres : 9B
Context : 8K tokens
Taille : 5.4GB (quantized Q4)
Hardware : 8GB RAM
Performances : #1 des SLMs sur MMLU

# Ollama
ollama run gemma2:9b

# Python (Transformers)
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("google/gemma-2-9b-it")
tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b-it")

chat = [{"role": "user", "content": "Explique la physique quantique simplement"}]
prompt = tokenizer.apply_chat_template(chat, tokenize=False)
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0]))

Paramètres : 7.3B
Context : 32K tokens
Taille : 4.4GB (quantized Q4)
Hardware : 6-8GB RAM
Performances : Référence des SLMs 7B

# Ollama
ollama run mistral:7b

# vLLM (serveur haute performance)
vllm serve mistralai/Mistral-7B-Instruct-v0.3 --max-model-len 32768

Paramètres : 7.6B
Context : 128K tokens
Taille : 4.5GB (quantized Q4)
Hardware : 8GB RAM
Performances : Top multilingue

# Ollama
ollama run qwen2.5:7b

# MLX (Apple Silicon optimisé)
mlx_lm.generate --model Qwen/Qwen2.5-7B-Instruct --prompt "Hello"

Paramètres : 8B
Context : 128K tokens
Taille : 4.9GB (quantized Q4)
Hardware : 8GB RAM
Performances : Très bon équilibre

# macOS
brew install ollama

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

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

# Télécharger et lancer Phi-3.5
ollama run phi3.5

>>> Écris une fonction Python pour calculer Fibonacci
Voici une fonction élégante utilisant la memoization :

def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo)
    return memo[n]

# Test
print(fibonacci(10))  # 55

>>> /bye

import requests

response = requests.post('http://localhost:11434/api/generate', json={
    "model": "phi3.5",
    "prompt": "Résume la révolution française en 3 points",
    "stream": False
})

print(response.json()['response'])

pip install transformers torch accelerate

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Charger modèle et tokenizer
model_name = "microsoft/Phi-3.5-mini-instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,  # FP16 pour économiser VRAM
    device_map="auto"  # Distribution automatique GPU/CPU
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Chat
messages = [
    {"role": "system", "content": "Tu es un assistant Python expert."},
    {"role": "user", "content": "Écris une classe Python pour un arbre binaire"}
]

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

# Générer
outputs = model.generate(
    inputs,
    max_new_tokens=500,
    temperature=0.7,
    do_sample=True,
    top_p=0.9
)

# Décoder
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

# Configuration quantization 4-bit
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16
)

# Charger modèle quantizé (2.3GB au lieu de 7.6GB)
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-3.5-mini-instruct",
    quantization_config=quantization_config,
    device_map="auto"
)
# Latence légèrement réduite, mémoire divisée par 3

pip install mlx mlx-lm

from mlx_lm import load, generate

# Charger modèle (optimisé Apple Silicon)
model, tokenizer = load("mlx-community/Phi-3.5-mini-instruct-4bit")

# Générer
prompt = "Explique la récursion en programmation"
response = generate(model, tokenizer, prompt=prompt, max_tokens=200)

print(response)

# App desktop avec Phi-3.5 mini
import ollama

def analyze_patient_note(note: str):
    """Analyse note médicale localement (aucune donnée envoyée au cloud)"""

    prompt = f"""
    Analyse cette note médicale et extrais :
    - Symptômes principaux
    - Diagnostics potentiels
    - Actions recommandées

    Note : {note}
    """

    response = ollama.generate(model="phi3.5", prompt=prompt)
    return response['response']

# Données restent 100% locales
note = "Patient 45 ans, fièvre 39°C depuis 3 jours, toux sèche..."
analysis = analyze_patient_note(note)

# Robot avec Gemma 2 2B (1.5GB)
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("google/gemma-2-2b-it", device_map="cuda")
tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-2b-it")

def robot_respond(user_query: str, context: dict):
    """Réponse robot basée sur contexte environnement"""

    prompt = f"""
    Tu es un robot d'assistance dans un hôtel.
    Localisation : {context['location']}
    Heure : {context['time']}
    Question client : {user_query}

    Réponds de manière concise et utile.
    """

    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
    outputs = model.generate(**inputs, max_new_tokens=100)
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# Usage
response = robot_respond(
    "Où est le restaurant ?",
    {"location": "Lobby", "time": "19:30"}
)
# Latence : ~150ms sur Jetson Orin Nano

// iOS avec Core ML
import CoreML

class AIAssistant {
    let model: Phi3Mini_CoreML  // Modèle exporté en Core ML

    func chat(message: String) -> String {
        let input = Phi3MiniInput(prompt: message)
        let output = try? model.prediction(input: input)
        return output?.response ?? "Erreur"
    }
}

// Taille modèle : ~2.5GB (quantized INT4)
// Latence iPhone 15 Pro : ~50ms/token

# Itération rapide et gratuite
prompts_variants = [
    "Résume ce texte : {text}",
    "En tant qu'expert, résume : {text}",
    "Résume en 2 phrases : {text}"
]

for variant in prompts_variants:
    response = ollama.generate(model="phi3.5", prompt=variant.format(text=doc))
    print(f"Variant: {variant[:30]}... → {response[:100]}...")

# Coût : $0 (vs $0.50-2 avec GPT-4o)

# Augmenter SLM avec recherche web
def sml_with_rag(question: str):
    # 1. Rechercher info récente
    context = web_search(question)

    # 2. Fournir contexte au SLM
    prompt = f"Contexte : {context}\n\nQuestion : {question}"
    return ollama.generate(model="phi3.5", prompt=prompt)

# → SLM peut répondre avec infos actualisées

Question : "Une voiture roule à 100 km/h pendant 2h30, puis 80 km/h pendant 1h45.
Quelle est la distance totale et vitesse moyenne ?"

prompt = """
Tu dois :
1. Résumer le texte
2. Extraire 3 points clés
3. Proposer une question de compréhension
4. Évaluer le ton (formel/informel)
5. Identifier le public cible

Texte : [...]
"""

# Grands modèles : suivent les 5 instructions
# SLMs : souvent oublient les points 4-5

# Mieux : 1 instruction à la fois
summary = sml("Résume : {text}")
key_points = sml("Extrais 3 points clés : {text}")
question = sml("Crée question sur : {text}")

Avez-vous <4GB RAM ?
├─ Oui → Phi-3.5 mini (2.3GB Q4)
└─ Non → Continuer

Besoin long context (>10K tokens) ?
├─ Oui → Phi-3.5 mini (128K) ou Qwen 2.5 7B (128K)
└─ Non → Continuer

Priorité : Performance max ?
├─ Oui → Gemma 2 9B (top MMLU 71.3%)
└─ Non → Continuer

Besoin multilingue (>10 langues) ?
├─ Oui → Qwen 2.5 7B (29 langues)
└─ Non → Continuer

Priorité : Open source Apache 2.0 ?
├─ Oui → Mistral 7B ou Qwen 2.5 7B
└─ Non → Gemma 2 9B (licence Gemma OK pour plupart des cas)

import time
import ollama

models = ["phi3.5", "gemma2:9b", "mistral:7b"]
questions = [
    "Écris une fonction tri rapide en Python",
    "Calcule 15% de 230",
    "Résume la révolution française en 3 points"
]

results = {}

for model in models:
    results[model] = []

    for q in questions:
        start = time.time()
        response = ollama.generate(model=model, prompt=q)
        latency = time.time() - start

        results[model].append({
            "question": q,
            "latency": latency,
            "response": response['response'][:100]
        })

# Analyser résultats
for model, data in results.items():
    avg_latency = sum(d["latency"] for d in data) / len(data)
    print(f"{model}: {avg_latency:.2f}s moyenne")

Documents → Chroma (embeddings) → Phi-3.5 mini

from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
from langchain.llms import Ollama
from langchain.chains import RetrievalQA

# 1. Charger documents
loader = DirectoryLoader("./docs", glob="**/*.md")
docs = loader.load()

# 2. Chunking
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(docs)

# 3. Embeddings locaux
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(chunks, embeddings)

# 4. LLM local
llm = Ollama(model="phi3.5")

# 5. Chaîne RAG
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)

# Question
response = qa_chain.invoke("Comment fonctionne le RAG ?")
print(response["result"])

# 100% local, $0, privacy totale

[
  {
    "messages": [
      {"role": "user", "content": "Comment réinitialiser le produit X ?"},
      {"role": "assistant", "content": "Pour réinitialiser : 1) Appuyez sur..."}
    ]
  }
]

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from trl import SFTTrainer
from peft import LoraConfig
import torch

# Modèle de base
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-3.5-mini-instruct",
    torch_dtype=torch.float16
)
tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3.5-mini-instruct")

# Configuration LoRA (adapter léger)
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# Training arguments
training_args = TrainingArguments(
    output_dir="./phi3-support",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    learning_rate=2e-4,
    logging_steps=10
)

# Trainer
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,  # Votre dataset
    peft_config=lora_config,
    args=training_args,
    tokenizer=tokenizer
)

# Fine-tune (1-2h sur RTX 3090)
trainer.train()

# Sauvegarder adapter (quelques MB seulement)
model.save_pretrained("./phi3-support-lora")