Fine-tuning et Modèles Locaux

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model
from trl import SFTTrainer, SFTConfig

# Configuration de quantification en 4 bits
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype="float16",
    bnb_4bit_use_double_quant=True,
)

# Charger le modèle quantifié
model_name = "mistralai/Mistral-7B-v0.3"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# Configuration LoRA
lora_config = LoraConfig(
    r=16,                 # Rang de la décomposition (plus grand = plus expressif)
    lora_alpha=32,        # Facteur de scaling
    lora_dropout=0.05,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],  # Couches ciblées
    bias="none",
    task_type="CAUSAL_LM"
)

# Appliquer LoRA au modèle
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# → trainable params: 4,194,304 || all params: 3,756,513,280 || trainable%: 0.11%

{"messages": [
  {"role": "system", "content": "Tu es un expert en droit français."},
  {"role": "user", "content": "Quels sont les délais de préavis pour un CDI ?"},
  {"role": "assistant", "content": "Selon l''article L1234-1 du Code du travail, les délais de préavis pour un CDI sont..."}
]}

from datasets import Dataset

# Vos données d''entraînement
conversations = [
    {
        "text": """<s>[INST] Tu es un assistant culinaire expert.

Donne-moi une recette de ratatouille. [/INST]
Voici la recette de la ratatouille provençale :

**Ingrédients (4 personnes) :**
- 2 aubergines
- 3 courgettes
- 2 poivrons
- 4 tomates
- 2 oignons
- Huile d''olive, thym, laurier

**Préparation :**
1. Coupez tous les légumes en dés
2. Faites revenir les oignons dans l''huile d''olive
3. Ajoutez les aubergines et poivrons (5 min)
4. Ajoutez les courgettes et tomates
5. Laissez mijoter 45 min à feu doux
6. Assaisonnez avec thym et laurier</s>"""
    },
    # ... plus d''exemples (idéalement 100-1000)
]

dataset = Dataset.from_list(conversations)
print(f"Dataset : {len(dataset)} exemples")

training_config = SFTConfig(
    output_dir="./mistral-cuisine",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    logging_steps=10,
    save_steps=100,
    max_seq_length=2048,
)

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    args=training_config,
    tokenizer=tokenizer,
)

# Lancer l''entraînement
trainer.train()

# Sauvegarder l''adapter LoRA (quelques Mo)
trainer.model.save_pretrained("./mistral-cuisine-lora")

# Installer Ollama (macOS/Linux/Windows)
# https://ollama.com

# Télécharger et lancer un modèle
ollama pull llama3.1:8b       # Llama 3.1 8B (4.7 Go)
ollama pull mistral:7b         # Mistral 7B (4.1 Go)
ollama pull gemma2:9b          # Gemma 2 9B (5.5 Go)

# Lancer un chat
ollama run llama3.1:8b

from openai import OpenAI

# Client local (aucune clé API nécessaire)
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Valeur ignorée mais requise
)

response = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[
        {"role": "system", "content": "Tu es un assistant qui répond en français."},
        {"role": "user", "content": "Explique les réseaux de neurones en 3 phrases."}
    ],
    temperature=0.5
)

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

# Créer un Modelfile
cat > Modelfile << 'EOF'
FROM mistral:7b
ADAPTER ./mistral-cuisine-lora

SYSTEM "Tu es un assistant culinaire expert en cuisine française."

PARAMETER temperature 0.5
PARAMETER top_p 0.9
EOF

# Créer le modèle dans Ollama
ollama create cuisine-expert -f Modelfile

# Le tester
ollama run cuisine-expert

import time

# Test avec API (OpenRouter)
api_client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key="sk-or-...")

# Test avec Ollama (local)
local_client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

question = "Quels sont les 3 piliers du développement durable ?"

for name, client_instance, model in [
    ("API (GPT-4o-mini)", api_client, "openai/gpt-4o-mini"),
    ("Local (Llama 3.1)", local_client, "llama3.1:8b"),
]:
    start = time.time()
    response = client_instance.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": question}],
        temperature=0,
        max_tokens=200
    )
    elapsed = time.time() - start
    answer = response.choices[0].message.content

    print(f"\n--- {name} ({elapsed:.2f}s) ---")
    print(answer[:200])