Introduction
Suite à la classe virtuelle (qui n’est d’ailleurs pas encore terminée, haha), je me suis penché sur Whisper, l’outil de transcription en local développé par OpenAI. Mais très vite, un autre sujet m’a happé : le SEO, ce monstre fascinant et capricieux du web moderne.
En général, pour produire du contenu optimisé, on s’appuie sur des ressources en ligne, des API externes ou des modèles hébergés comme ChatGPT, Gemini ou Claude. Le problème ? Ces solutions sont pratiques, mais elles dépendent du cloud, de connexions instables, et elles nous rendent dépendants de services externes. Bref, une perte de temps et d’autonomie.
Alors je me suis posé une question : et si on fine-tunait un petit modèle de langage open source, en local, pour le spécialiser dans le SEO ? Un LLM optimisé maison, capable d’analyser, corriger et rédiger du contenu parfaitement calibré pour le référencement. Et pourquoi pas, ensuite, en faire un service localisé et indépendant ?
C’est ce qu’on va explorer ensemble, pas à pas : comprendre si c’est faisable, comment le faire, et jusqu’où on peut pousser un modèle comme Mistral 7B sans GPU de data center.
Mistral ou Gemma ?
Pourquoi avoir choisi un modèle 7B ? La question mérite d’être posée. Travailler en local impose certaines contraintes matérielles : mémoire GPU, puissance de calcul, stockage. Il faut donc trouver le bon équilibre entre taille du modèle et performance réelle.
Les modèles de 7 milliards de paramètres — les fameux 7B — comme Mistral 7B ou Gemma 7B, offrent ce compromis idéal : assez puissants pour comprendre le contexte et produire un texte cohérent, mais encore légers pour tourner sur une machine personnelle équipée d’un GPU de milieu de gamme.
Ensuite, il y a une raison plus culturelle, presque chauvine : Mistral est français. Et les équipes derrière Mistral ont fait un travail remarquable en matière de qualité et d’ouverture. Leurs modèles open source se distinguent par une excellente gestion du multilingue, une compréhension fine du français, et une optimisation pensée pour les usages réels, pas seulement les benchmarks.
En d’autres termes, choisir Mistral 7B, c’est miser sur la performance locale, la liberté technologique et la fierté de pouvoir dire : “Mon LLM parle français mieux qu’un modèle américain !”
Le flux simple et les problèmes
Qui dit fine-tuning dit forcément prise de tête avec les données. Car un modèle, aussi puissant soit-il, ne sort pas du néant : il faut lui apprendre ce qu’on veut qu’il sache. Et dans notre cas, lui faire comprendre ce qu’est le SEO, ses logiques, ses patterns, son langage.
Un modèle pré-entraîné comme Mistral 7B n’est pas “nu” : il a déjà une base linguistique solide. Mais pour le spécialiser — par exemple en rédaction SEO, en analyse de balises, ou en audit sémantique — il faut lui fournir des données contextualisées. Des textes web, des exemples d’optimisation, des métadonnées bien formées. Et c’est là que commence la gymnastique.
Il faut se poser quelques questions essentielles : comment le modèle analyse ces données ? Combien de temps d’entraînement est nécessaire ? Quelle taille de contexte (nombre de tokens) faut-il lui donner pour qu’il capte le sens global d’un texte SEO ?
Pour ce projet, on va faire simple et utile : un petit flux automatisé, entièrement encapsulé dans Docker.
Tout le pipeline — téléchargement, preprocessing, audit et fine-tuning — tourne dans un container unique, isolé du système hôte. Cela garantit la reproductibilité, évite les conflits de dépendances, et permet de redéployer le projet sur n’importe quelle machine en un clin d’œil.
Concrètement, on lance une commande qui télécharge les données depuis le web, en s’appuyant sur les librairies Python requests et beautifulsoup4 pour récupérer du contenu pertinent. Ensuite, toujours dans le container Docker, on exécute une commande qui fait passer un premier audit par Mistral. Oui, vous avez bien lu : on demande directement au modèle ce qu’il pense de son propre corpus.
L’objectif ici n’est pas encore d’obtenir un modèle parfait, mais de créer un pipeline clair, reproductible et portable, capable de tester, analyser et itérer. C’est une première étape cruciale avant de lancer le vrai fine-tuning.
CPU rendering ou GPU ?
Comme tout le projet tourne dans Docker, on pourrait se dire : “autant tout faire à l’intérieur du container, c’est plus propre !”. En théorie, oui. En pratique, ça se complique.
Un container Docker, surtout lorsqu’il tourne sur un Linux virtualisé, n’a pas forcément accès au GPU de la machine hôte. Il exécute Python, Mistral et toutes les librairies dans un environnement isolé, ce qui est parfait pour la reproductibilité… mais beaucoup moins pour la performance. Résultat : si l’on fait le fine-tuning du modèle sur CPU, le rendu peut prendre des heures, voire des jours.
Sur une vraie machine équipée d’un GPU (même modeste, comme une RTX 3060 ou 4060), les choses changent radicalement. On peut tirer parti de frameworks comme Hugging Face Transformers, PEFT ou bitsandbytes pour exploiter pleinement la carte graphique et accélérer les calculs de façon spectaculaire.
Le bon compromis consiste à découper le flux :
- Effectuer le scraping et le prétraitement des données dans Docker (via
requestsetbeautifulsoup4) ; - Puis exécuter le fine-tuning ou l’inférence directement sur le système hôte, en accédant au GPU via Python.
Ce workflow hybride permet de garder la sécurité et la portabilité du container tout en profitant de la vitesse brute du GPU pour la partie la plus lourde.
Les limites des paramètres
Avec un modèle 7B (7 milliards de paramètres), la question des performances devient vite centrale. C’est une taille idéale pour un usage local sérieux, mais cela reste un gros bébé quand il s’agit de faire de l’analyse textuelle rapide.
Pour une analyse simple ou répétitive, on pourrait être tenté de passer sur un modèle plus petit, du type 3B, histoire d’accélérer le rendu et d’économiser un peu de VRAM. Mais on ne va pas brûler les étapes : cette optimisation viendra plus tard.
Pour l’instant, l’objectif reste de tester Mistral 7B tel quel, d’observer son comportement, sa manière d’interpréter les données SEO, et surtout de mesurer le temps de réponse réel en environnement local. Sur un CPU ou un GPU moyen, il n’est pas rare d’attendre 2 à 3 minutes selon la taille du prompt ou la complexité de la tâche.
La solution n’est pas forcément de réduire le modèle, mais d’optimiser le prompt lui-même. Et oui, tout ça se fait en Python ! Avec un peu d’astuce dans le code, on peut nettoyer le texte avant envoi, réduire le contexte inutile, et structurer les requêtes pour que Mistral aille droit au but sans ramer.
Ce n’est pas de la magie, c’est de l’ingénierie : moins de tokens, moins de calculs, et donc plus de vitesse — sans sacrifier la qualité du résultat.
Mon idée pour cette V1
L’objectif de cette version 1 est simple : prendre tout ce qu’on a exploré jusqu’ici et le rendre fonctionnel, clair et fun. Pas besoin d’un cluster GPU ni d’une infrastructure cloud, tout tourne en local, dans Docker, ou en local directement suivant la machine, avec un flux bien défini.
L’idée : partir d’un fichier website.txt contenant une dizaine d’URLs de sites web, puis automatiser l’audit complet avec Mistral 7B-instruct.
Le flux se déroule en quatre étapes :
- Scraping du contenu des sites : un script Python lit
website.txtet télécharge les pages à l’aide derequestsetbeautifulsoup4. - Appel automatique du modèle Mistral 7B-instruct : chaque contenu est envoyé au modèle pour analyse SEO.
- Génération du rapport SEO : Mistral produit un diagnostic textuel — lisibilité, structure Hn, densité de mots-clés, cohérence sémantique.
- Exposition du résultat via une API locale : le tout est servi en JSON, accessible depuis n’importe quelle application front ou terminal.
C’est une base solide pour construire un service SEO local capable de fonctionner sans dépendance externe. L’intérêt est évident : autonomie totale, confidentialité des données, et rapidité d’expérimentation.
Requirements pour Mistral SEO Audit
L’environnement reste volontairement minimaliste, pensé pour Python 3.11+ :
# ===== WEB SCRAPING =====
requests==2.31.0 # Téléchargement HTTP
beautifulsoup4==4.12.2 # Parsing HTML
# ===== MACHINE LEARNING =====
torch==2.1.2 # Moteur de calcul PyTorch
tokenizers==0.15.0
transformers==4.36.2 # Hugging Face – chargement du modèle Mistral
accelerate==0.25.0 # Gestion mémoire optimisée
sentencepiece==0.1.99 # Tokenizer pour Mistral
protobuf==4.25.1 # Dépendance de sentencepiece
# ===== UTILITAIRES =====
python-dotenv==1.0.0 # Variables d’environnement
tqdm==4.66.1 # Barres de progressionUne fois ces dépendances installées , le projet est prêt à tourner : scraping, audit, rapport, API.
Chargement du model Mistral
Lors du premier lancement, Hugging Face télécharge les poids du modèle (environ 14 Go), ainsi que les shards — les fragments du checkpoint — nécessaires au chargement progressif. Une fois en cache, les relancements suivants sont beaucoup plus rapides.
Dans ce test, on remarque que le système détecte automatiquement la puce GPU M4 et bascule sur le backend Metal Performance Shaders (MPS), l’API Apple pour le calcul parallèle. Cela permet d’exploiter la VRAM du GPU et de réduire le temps de chargement d’un facteur 2 à 3 par rapport au CPU.
La précision utilisée ici est le torch.float16, un format allégé (16 bits) qui divise la consommation mémoire sans sacrifier la qualité des calculs. Ce choix est stratégique pour les environnements locaux où la mémoire GPU est limitée.
Une fois le message Modèle chargé et prêt ! affiché, le moteur est opérationnel : Mistral est en mémoire, prêt à traiter les prompts et à analyser les contenus SEO.
La gestion du modèle
Toute la logique du projet repose sur un seul fichier Python, le cerveau du Mistral SEO Audit.
C’est lui qui charge le modèle, prépare le prompt, génère l’audit, et sauvegarde le résultat.
La partie automatique (boucle complète sur plusieurs sites, génération parallèle, gestion d’erreurs, etc.) arrivera dans la V2, où je tenterai une approche un peu plus deep — on verra si ça tient la route !
L’idée ici est simple : faire tourner Mistral 7B en local, sans dépendance cloud, en optimisant chaque étape pour qu’elle soit rapide et stable.
Architecture du script
Ce fichier gère quatre grands blocs :
- Chargement du modèle — via Hugging Face, avec détection automatique du GPU (MPS sur Mac, CUDA sur PC, sinon CPU fallback).
- Création du prompt optimisé — le script construit un texte d’instruction en français, condensé à 256 tokens, pour forcer le modèle à répondre vite et précisément.
- Génération de l’audit SEO — Mistral produit une analyse concise : forces, problèmes et actions concrètes, avec un score sur 10.
- Sauvegarde locale — le rapport est exporté dans
/datasous forme de fichier texte, horodaté et prêt à être exploité par une API locale ou un tableau de bord.
import sys
import json
import torch
from pathlib import Path
from transformers import AutoModelForCausalLM, AutoTokenizer
from seo_analyzer import analyze_seo
# ===== CONFIGURATION OPTIMISÉE =====
MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.1"
# OPTIMISATION 1 : Tokens réduits
TEMPERATURE = 0.3
MAX_NEW_TOKENS = 256 # ← Réduit de 1024 à 256 pour temps gagné
TOP_P = 0.95
# ===== CHARGEMENT MODÈLE =====
def load_model():
print("📦 Chargement de Mistral-7B-Instruct...")
print("⏳ Première fois ? Le téléchargement peut prendre 10-15 minutes.")
use_mps = torch.backends.mps.is_available()
if use_mps:
device = "mps"
dtype = torch.float16
print("🚀 GPU M4 détecté ! Utilisation de Metal Performance Shaders")
else:
device = "cpu"
dtype = torch.float32
print("💻 Utilisation du CPU (float32)")
print("1/2 Chargement du tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, use_fast=False)
if tokenizer.pad_token is None:
tokenizer.pad_token = tokenizer.eos_token
print(f"2/2 Chargement du modèle (~14GB en {dtype})...")
model = AutoModelForCausalLM.from_pretrained(
MODEL_NAME,
torch_dtype=dtype,
low_cpu_mem_usage=True
)
if use_mps:
model = model.to("mps")
print(" Modèle chargé avec succès !")
print(f" Device utilisé : {device} | Dtype : {dtype}")
model.eval()
return model, tokenizer
# ===== PROMPT OPTIMISÉ =====
def create_seo_prompt(seo_data: dict) -> str:
essential_data = {
'title': seo_data.get('title', ''),
'title_length': len(seo_data.get('title', '')),
'meta_description': seo_data.get('meta_description', ''),
'meta_length': len(seo_data.get('meta_description', '')) if seo_data.get('meta_description') else 0,
'h1_count': len(seo_data.get('headings', {}).get('h1', [])),
'h1': seo_data.get('headings', {}).get('h1', [])[:2],
'total_links': seo_data.get('links', {}).get('total', 0),
'internal_links': seo_data.get('links', {}).get('internal', 0),
'images_total': seo_data.get('images', {}).get('total', 0),
'images_no_alt': seo_data.get('images', {}).get('without_alt', 0),
'canonical': seo_data.get('canonical', ''),
'robots': seo_data.get('meta_robots', '')
}
prompt = f"""[INST] Tu es un expert SEO français. Réponds UNIQUEMENT EN FRANÇAIS. Analyse ultra-concise.
Données SEO : {json.dumps(essential_data, indent=2, ensure_ascii=False)}
IMPORTANT : Réponds en français, 200 mots maximum.
## TOP 2 Forces
- Force 1 (une phrase en français)
- Force 2 (une phrase en français)
## TOP 2 Problèmes
- Problème 1 avec impact SEO (une phrase en français)
- Problème 2 avec impact SEO (une phrase en français)
## TOP 3 Actions
1. Action prioritaire concrète (une phrase en français)
2. Action prioritaire concrète (une phrase en français)
3. Action prioritaire concrète (une phrase en français)
## Score : X/10
Justification en une phrase en français.
Exemple de réponse attendue :
TOP 2 Forces
- Meta description bien rédigée avec mots-clés.
- Structure H1-H6 cohérente facilitant la lecture.
[/INST]
Voici mon analyse SEO en français :
"""
return prompt
# ===== GÉNÉRATION OPTIMISÉE =====
def generate_audit(model, tokenizer, prompt: str) -> str:
"""OPTIMISATION 3 : Transferts GPU et génération optimisés"""
import time
print("\n Génération de l'audit par Mistral...")
print(" Génération optimisée (~30-45s attendu)...")
start_time = time.time()
# Tokenize avec gestion d'erreur
try:
inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=2048)
except Exception as e:
print(f" Erreur de tokenization : {e}")
print(" Tentative avec nettoyage du prompt...")
# Nettoie le prompt des caractères problématiques
cleaned_prompt = prompt.encode('utf-8', errors='ignore').decode('utf-8')
inputs = tokenizer(cleaned_prompt, return_tensors="pt", truncation=True, max_length=2048)
# Debug : longueur du prompt
prompt_length = len(inputs['input_ids'][0])
print(f" Longueur prompt : {prompt_length} tokens")
# OPTIMISATION : Transfert GPU optimisé
if torch.backends.mps.is_available():
inputs = {k: v.to("mps", non_blocking=True) for k, v in inputs.items()}
torch.mps.synchronize()
# OPTIMISATION : Génération avec cache et autocast
with torch.no_grad():
# Limite stricte du vocab pour éviter "piece id out of range"
vocab_size = len(tokenizer)
if torch.backends.mps.is_available():
outputs = model.generate(
**inputs,
do_sample=True,
temperature=TEMPERATURE,
top_p=TOP_P,
max_new_tokens=MAX_NEW_TOKENS,
pad_token_id=tokenizer.pad_token_id,
eos_token_id=tokenizer.eos_token_id,
use_cache=True,
renormalize_logits=True # Évite les tokens invalides
)
else:
outputs = model.generate(
**inputs,
do_sample=True,
temperature=TEMPERATURE,
top_p=TOP_P,
max_new_tokens=MAX_NEW_TOKENS,
pad_token_id=tokenizer.pad_token_id,
eos_token_id=tokenizer.eos_token_id,
use_cache=True,
renormalize_logits=True # Évite les tokens invalides
)
end_time = time.time()
duration = end_time - start_time
# Décode avec gestion d'erreur pour tokens invalides
try:
# Filtre les tokens hors range avant décodage
vocab_size = len(tokenizer)
valid_tokens = torch.clamp(outputs[0], max=vocab_size - 1)
response = tokenizer.decode(valid_tokens, skip_special_tokens=True)
except Exception as e:
print(f" Erreur de décodage : {e}")
print(" Tentative de décodage partiel...")
# Fallback : décode token par token en ignorant les erreurs
tokens = []
for token_id in outputs[0].tolist():
if 0 <= token_id < vocab_size:
try:
tokens.append(tokenizer.decode([token_id], skip_special_tokens=True))
except:
continue
response = ''.join(tokens)
if "[/INST]" in response:
response = response.split("[/INST]")[1].strip()
# Stats
num_tokens = len(outputs[0]) - prompt_length
tokens_per_sec = num_tokens / duration
print(f" Audit généré en {duration:.1f} secondes !")
print(f" Performance : {tokens_per_sec:.1f} tokens/sec | {num_tokens} tokens générés")
return response
# ===== SAUVEGARDE =====
def save_audit(audit: str, original_filepath: str, output_dir: str = "./data") -> str:
from datetime import datetime
original_path = Path(original_filepath)
base_name = original_path.stem
filename = f"{base_name}_AUDIT.txt"
filepath = Path(output_dir) / filename
with open(filepath, 'w', encoding='utf-8') as f:
f.write("=" * 80 + "\n")
f.write("AUDIT SEO AUTOMATISÉ - Mistral-7B-Instruct (OPTIMISÉ)\n")
f.write(f"Généré le : {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
f.write(f"Fichier source : {original_filepath}\n")
f.write("=" * 80 + "\n\n")
f.write(audit)
f.write("\n\n" + "=" * 80 + "\n")
print(f" Audit sauvegardé : {filepath}")
return str(filepath)
# ===== MAIN =====
def main():
import time
if len(sys.argv) < 2:
print(" Usage: python mistral_audit.py <fichier.html>")
print(" Exemple: python mistral_audit.py data/example.com_20240115_143022.html")
sys.exit(1)
filepath = Path(sys.argv[1])
if not filepath.exists():
print(f" Fichier introuvable : {filepath}")
sys.exit(1)
print("=" * 80)
print(" AUDIT SEO AUTOMATISÉ AVEC MISTRAL (OPTIMISÉ)")
print("=" * 80)
total_start = time.time()
# Lit le HTML
print(f"\n Lecture de {filepath}...")
with open(filepath, 'r', encoding='utf-8') as f:
html = f.read()
# Analyse SEO
print(" Extraction des données SEO...")
seo_data = analyze_seo(html)
print(" Données extraites")
# Charge Mistral
load_start = time.time()
model, tokenizer = load_model()
load_time = time.time() - load_start
# Crée le prompt
print("\n️ Création du prompt optimisé...")
prompt = create_seo_prompt(seo_data)
# Génère l'audit
audit = generate_audit(model, tokenizer, prompt)
# Sauvegarde
audit_path = save_audit(audit, filepath)
# Stats finales
total_time = time.time() - total_start
# Affiche l'audit
print("\n" + "=" * 80)
print("AUDIT SEO GÉNÉRÉ")
print("=" * 80)
print(audit)
print("=" * 80)
print(f"\n️ STATISTIQUES")
print(f" Chargement : {load_time:.1f}s")
print(f" Total : {total_time:.1f}s")
print(f"\n Terminé ! Audit disponible dans : {audit_path}")
if __name__ == "__main__":
main()
Optimisations clés
- Réduction du nombre de tokens : le
MAX_NEW_TOKENSpasse de 1024 à 256. Cela réduit drastiquement le temps de génération tout en gardant un contenu clair et exploitable. - Température basse (0.3) : le modèle produit des réponses plus stables et moins fantaisistes, parfait pour l’audit SEO.
- Gestion fine du device : le code détecte si le GPU MPS ou CUDA est disponible et adapte le type de calcul (
float16pour MPS,float32sinon). - Nettoyage automatique des prompts : si le texte contient des caractères illisibles, il est re-encodé proprement avant tokenization.
- Décodage robuste : le script évite les erreurs “piece id out of range” grâce à un filtrage intelligent des tokens invalides.
Exemple de flux interne
- Le script lit un fichier HTML (résultat du scraping).
- Il en extrait les données SEO structurées via
seo_analyzer(titres, meta, liens, images, etc.). - Il fabrique un prompt ultra-condensé pour Mistral :“Tu es un expert SEO français. Analyse ce site en 200 mots, donne 2 forces, 2 problèmes, 3 actions concrètes et une note sur 10.”
- Mistral génère la réponse en ~30–45 secondes, selon la puissance de la machine.
- Le rapport est sauvegardé automatiquement dans un fichier texte horodaté.
Résultat
Une fois lancé, le terminal affiche les temps de chargement, la vitesse de génération (tokens/sec) et l’audit complet directement à l’écran, prêt à être exploité :
AUDIT SEO AUTOMATISÉ AVEC MISTRAL (OPTIMISÉ)
============================================
Audit généré en 41.2 secondes !
Performance : 7.8 tokens/sec | 310 tokens générés
Audit sauvegardé : ./data/example.com_AUDIT.txt
Et voilà : en un seul script, tu obtiens un outil d’audit SEO 100 % local, dopé au Mistral 7B-Instruct.
🧭 Conclusion
Ce que l’on a exploré ici, c’est avant tout un POC — une preuve de concept — montrant comment mettre en place un pipeline complet de fine-tuning local autour d’un modèle de langage open source. Rien d’excessivement complexe, mais tout de même dense, surtout lorsqu’on vient du monde PHP et qu’on plonge d’un coup dans l’univers de PyTorch, Hugging Face et des LLMs.
Grâce à ces bibliothèques, la manipulation de modèles comme Mistral-7B-Instruct devient presque naturelle : charger le modèle, préparer le prompt, générer la sortie, sauvegarder les résultats. En quelques centaines de lignes de Python, on tient déjà les bases d’un mini-agent SEO autonome, capable d’auditer des sites web et de produire des rapports cohérents — le tout sans connexion cloud.
Et la preuve, voici un extrait d’audit généré automatiquement par notre modèle sur le site jschristophe.fr :
Audit SEO automatisé – Mistral-7B-Instruct (2025-11-02)
TOP 2 Forces
– H1 bien présent avec un message clair et concis.
– Images avec des alt tags rédigés.TOP 2 Problèmes
– Pas de mots-clés dans le titre.
– Pas de mots-clés dans la meta description.TOP 3 Actions
- Ajouter des mots-clés dans le titre.
- Ajouter des mots-clés dans la meta description.
- Optimiser les images avec des alt tags rédigés.
Score : 7/10
Les forces sont présentes, mais pourraient être améliorées par une meilleure intégration des mots-clés.
Ce petit extrait prouve qu’un LLM open source bien configuré peut déjà effectuer un audit SEO basique de manière structurée, logique et parfaitement en français.
Ce projet n’est pas un aboutissement, mais un point de départ.
Il montre comment un modèle open source peut être spécialisé, adapté, et intégré dans une logique métier concrète comme le SEO. C’est un avant-goût de ce que pourrait devenir un assistant SEO local, finement ajusté à tes propres critères et à ton style d’écriture.
Pour la V2, on ira plus loin. On parlera d’automatisation, de prompts dynamiques, peut-être de LoRA pour un vrai fine-tuning, et pourquoi pas d’une petite API REST pour piloter tout ça depuis un dashboard web.
En attendant, l’important reste le même : apprendre, expérimenter, partager, échouer, recommencer — et peu à peu, donner vie à une idée.
Laisser un commentaire