Entraîner son IA en local

Le modèle est entraîné et mesuré. Il reste à le rendre utilisable au quotidien : le convertir dans un format léger, le servir avec Ollama, l'exposer à une interface ou à une application, et mettre en place la boucle qui l'améliorera au fil de l'usage.

Fusionner et convertir en GGUF

L'adaptateur LoRA ne s'utilise pas seul : il faut le fusionner avec le modèle de base, puis quantifier le résultat en GGUF pour Ollama. Unsloth fait les deux en une commande.

from unsloth import FastLanguageModel
 
model, tokenizer = FastLanguageModel.from_pretrained(
    "../models/checkpoints/checkpoint-200",   # le meilleur checkpoint identifié au chapitre 6
    max_seq_length=4096,
    load_in_4bit=True,
)
 
model.save_pretrained_gguf("../models/potager-gguf", tokenizer, quantization_method="q4_k_m")

uv run exporter.py
ls ../models/potager-gguf

La conversion télécharge et compile llama.cpp au premier lancement ; comptez quelques minutes. Pour garder plus de qualité, q5_k_m ou q8_0 au prix d'un fichier plus gros.

Si vous voulez aussi conserver le modèle fusionné en 16 bits (pour le republier sur Hugging Face ou le réentraîner), Unsloth propose save_pretrained_merged(..., save_method="merged_16bit").

Créer le modèle dans Ollama

Un Modelfile décrit le modèle pour Ollama : fichier de poids, prompt système, paramètres.

FROM ./unsloth.Q4_K_M.gguf
 
SYSTEM """Tu es un assistant expert du potager. Tu réponds en français, de façon précise, pratique et concise.
Appuie-toi sur les documents fournis. S'ils ne contiennent pas la réponse, dis-le clairement et n'invente rien."""
 
PARAMETER temperature 0.2
PARAMETER num_ctx 8192
PARAMETER top_p 0.9

Adaptez le nom du fichier .gguf à celui produit par l'export. Unsloth génère souvent un Modelfile de départ à côté du GGUF ; partez de celui-là, il contient le bon chat template.

cd models/potager-gguf
ollama create potager -f Modelfile
ollama run potager "Quand semer les radis ?"

Vérifier le chat template

C'est le moment de vérifier le piège signalé depuis le chapitre 3 :

ollama show potager --template

Le template affiché doit correspondre à celui utilisé pendant l'entraînement (pour Qwen, les balises <|im_start|> et <|im_end|>). Si Ollama a appliqué un template générique, ajoutez une directive TEMPLATE dans le Modelfile en copiant celle du modèle de base :

ollama show qwen3:8b --modelfile

Symptômes d'un template incorrect : le modèle continue la conversation tout seul, affiche des balises, ou répond beaucoup moins bien que lors du test Python.

Brancher le RAG sur le modèle final

Dans rag/assistant.py, remplacez simplement le modèle :

MODELE = "potager"

Relancez eval/evaluer.py : la configuration D doit donner les mêmes résultats qu'au chapitre 7. C'est la vérification finale que l'export n'a rien cassé.

Exposer une API

Pour qu'une application web ou un bot utilise l'assistant, une petite API HTTP autour du pipeline RAG :

from fastapi import FastAPI
from pydantic import BaseModel
 
from assistant import repondre
 
app = FastAPI(title="Assistant potager")
 
class Question(BaseModel):
    question: str
    historique: list[dict] = []
 
class Reponse(BaseModel):
    reponse: str
 
@app.post("/ask", response_model=Reponse)
def ask(q: Question) -> Reponse:
    return Reponse(reponse=repondre(q.question, q.historique[-6:]))

uv add fastapi uvicorn
uv run uvicorn api:app --app-dir rag --host 127.0.0.1 --port 8000

curl -s localhost:8000/ask -H "Content-Type: application/json" \
  -d '{"question": "Que planter avec les fraisiers ?"}'

Par défaut, Ollama et cette API n'écoutent que sur la machine locale. Si vous les ouvrez sur le réseau, placez-les derrière un reverse proxy avec authentification et filtrez les ports : un LLM exposé sans protection est une ressource de calcul gratuite pour n'importe qui. Le guide UFW, le pare-feu Linux couvre le filtrage de base.

Une interface pour les utilisateurs

Trois options, de la plus rapide à la plus intégrée :

Exemple Gradio, qui conserve votre pipeline de recherche et de reranking :

import gradio as gr
 
from assistant import repondre
 
def discuter(message, historique):
    histo = [{"role": m["role"], "content": m["content"]} for m in historique][-6:]
    return repondre(message, histo)
 
gr.ChatInterface(discuter, type="messages", title="🌱 Assistant potager").launch()

Faire évoluer l'IA

Un assistant n'est jamais terminé. La boucle d'amélioration :

Utilisation réelle
      │  journaliser questions, réponses, passages, retours 👍 / 👎
      ▼
Analyse hebdomadaire des 👎 et des questions sans réponse
      │
      ├── information absente      → ajouter des sources, réindexer (minutes)
      ├── recherche ratée          → ajuster découpage / reranking (heures)
      └── comportement inadapté    → nouveaux exemples, re-fine-tuning (jours)
      │
      ▼
Ajouter les cas corrigés au jeu d'évaluation → relancer le banc → déployer si meilleur

Deux principes à garder :

• Mettre à jour les connaissances par le RAG, pas par le fine-tuning. Une nouvelle fiche sur la culture des patates douces se réindexe en une minute. Réentraîner le modèle pour ça serait lent et peu fiable.
• Ne jamais déployer un modèle sans repasser le banc d'évaluation. Un nouveau fine-tuning peut améliorer un point et en casser trois autres.

Journaliser les conversations implique de stocker ce que les utilisateurs écrivent : informez-les, limitez la durée de conservation et évitez de garder des données personnelles inutiles. Les obligations sont détaillées dans RGPD et IA.

Quand changer de modèle de base

De nouvelles générations de modèles ouverts sortent régulièrement, souvent nettement meilleures à taille égale. Grâce à votre travail, changer de modèle devient une opération maîtrisée :

1. passer le nouveau modèle sur le banc d'évaluation (configurations A et B)
2. s'il fait mieux, relancer le fine-tuning avec les mêmes données (seuls le nom du modèle et les balises du template changent)
3. comparer D ancien contre D nouveau, déployer le meilleur

Vos vrais actifs sont le corpus nettoyé, le jeu d'entraînement et le jeu d'évaluation. Le modèle, lui, est remplaçable.

Récapitulatif du parcours

Une IA qui connaît vraiment un sujet ne sort pas d'un seul entraînement. Elle vient d'un corpus soigné consulté par RAG, d'un fine-tuning qui lui apprend à bien s'en servir, et d'une évaluation qui dit la vérité à chaque version. Ce trio fonctionne pour le potager comme pour n'importe quel domaine, et il tient sur une seule carte graphique chez vous. Pour situer ce projet dans l'usage plus large de l'IA au quotidien, voir l'IA pour les développeurs.