Scores de modération et seuils
Op deze pagina
Mis à jour le 3 novembre 2026. Les profils de seuil faisaient précédemment référence à des catégories inexistantes (
hate,violence,unpredictable) ; ils sont désormais alignés sur les onze clés demistral-moderation-2603, y comprisdangerous. Le guide d’interprétation des scores est fourni à titre de référence pédagogique, car Mistral n’en publie aucun. Le moniteur levait auparavant uneKeyErrorpour toute catégorie manquante dans le profil et utilisaitdatetime.utcnow(), qui est dépréciée depuis Python 3.12. Sources : Moderation & Guardrailing · datetime.utcnow.
Interprétation des scores de modération
Chaque catégorie renvoie un score compris entre 0,0 et 1,0. Mais que signifient concrètement ces chiffres ? Et comment définir les seuils de décision pour votre application ? Cette leçon vous donne les clés pour transformer des scores bruts en décisions automatisées, passant de la mesure à la politique d’usage.
Comprenez d’abord que Mistral ne présente pas ces scores comme des probabilités étalonnées. Un score de 0,6 ne signifie pas « six chances sur dix que ce texte soit dangereux » ; c’est un signal fort émis par le classifieur. La documentation met en avant deux points utiles. Les booléens categories dans la réponse appliquent des seuils choisis par Mistral pour une performance optimale sur son jeu de tests interne ; vous pouvez les utiliser, ou partir des scores bruts pour définir les vôtres. Sur ce jeu de tests, la précision par catégorie varie de 0,8 à 1,0, et le rappel de 0,7 à 1,0 : des faux positifs et des contenus manquants surviennent, ce qui explique pourquoi un réglage manuel des seuils est crucial.
La grille ci-dessous n’est pas publiée par Mistral : elle sert de référence de départ à valider contre vos propres métriques.
| Plage | Interprétation |
|---|---|
| 0,0 - 0,1 | Contenu clairement sûr, aucun signal détecté |
| 0,1 - 0,3 | Signal faible, potentiellement bénin mais ambigu |
| 0,3 - 0,5 | Signal modéré, contenu potentiellement problématique |
| 0,5 - 0,7 | Signal fort, contenu très probablement problématique |
| 0,7 - 1,0 | Signal très fort, contenu manifestement dangereux |
Définition de vos seuils : la matrice de décision
Choisir un seuil implique un arbitrage entre sécurité (bloquer le plus possible) et utilisabilité (minimiser les faux positifs). Aucun réglage ne gagne sur les deux tableaux, et prétendre le contraire mène à des allers-retours sans fin. La méthode de travail consiste à définir trois profils explicites et à mapper chaque application sur l’un d’eux.
Le profil strict vise une application grand public où des mineurs peuvent être présents ; le profil équilibré convient à une application professionnelle B2B avec des utilisateurs identifiés ; le profil permissif est réservé à un outil interne manipulé par des experts qui savent ce qu’ils demandent.
# Trois profils de seuils
PROFILES = {
"strict": {
# Application grand public, enfants possibles
"sexual": 0.1,
"hate_and_discrimination": 0.1,
"violence_and_threats": 0.1,
"dangerous": 0.1,
"criminal": 0.1,
"selfharm": 0.1,
"health": 0.2,
"financial": 0.2,
"law": 0.2,
"pii": 0.1,
"jailbreaking": 0.1,
},
"balanced": {
# Application professionnelle B2B
"sexual": 0.2,
"hate_and_discrimination": 0.15,
"violence_and_threats": 0.25,
"dangerous": 0.15,
"criminal": 0.15,
"selfharm": 0.15,
"health": 0.4,
"financial": 0.4,
"law": 0.4,
"pii": 0.2,
"jailbreaking": 0.15,
},
"permissive": {
# Outil interne pour experts
"sexual": 0.3,
"hate_and_discrimination": 0.2,
"violence_and_threats": 0.4,
"dangerous": 0.2,
"criminal": 0.2,
"selfharm": 0.2,
"health": 0.7,
"financial": 0.7,
"law": 0.7,
"pii": 0.3,
"jailbreaking": 0.2,
},
}
Comparez la colonne health entre les profils : 0,2, puis 0,4, puis 0,7. Le même échange sur un dosage sera bloqué dans le premier cas et accepté dans le dernier. C’est le contexte d’usage qui décide, pas la nature du texte.
Système de classification multi-niveaux
Bloquer ou accepter constitue une vision simpliste de la réalité. Entre un contenu manifestement sûr et un contenu manifestement违规 se trouve une zone grise où la bonne décision consiste à afficher tout en signalant. La fonction ci-dessous introduit ce troisième état : au-dessus du seuil, bloquer ; au-dessus de 60 % du seuil, avertir et journaliser ; en dessous, laisser passer.
from enum import Enum
class RiskLevel(Enum):
SAFE = "safe" # Vert : contenu sûr
WARNING = "warning" # Orange : contenu à surveiller
BLOCKED = "blocked" # Rouge : contenu bloqué
def classify_content(scores: dict, thresholds: dict) -> dict:
"""Classe le contenu en 3 niveaux de risque."""
blocking_violations = []
warnings = []
for category, threshold in thresholds.items():
score = scores.get(category, 0)
if score > threshold:
blocking_violations.append({
"category": category,
"score": round(score, 3)
})
elif score > threshold * 0.6:
# Zone d'avertissement : 60 % du seuil
warnings.append({
"category": category,
"score": round(score, 3)
})
if blocking_violations:
return {
"level": RiskLevel.BLOCKED,
"violations": blocking_violations,
"action": "block_and_log"
}
elif warnings:
return {
"level": RiskLevel.WARNING,
"warnings": warnings,
"action": "display_and_log"
}
else:
return {
"level": RiskLevel.SAFE,
"action": "display"
}
La valeur de la zone orange est autant opérationnelle que pédagogique : elle vous montre ce qui frôle vos seuils. Si une catégorie génère beaucoup d’avertissements sans jamais franchir la ligne, vous savez qu’un ajustement de quelques centièmes déplacerait un volume significatif de trafic.
Exemple concret : analyser et décider
L’assemblage se résume à une fonction : appeler le classifieur, appliquer le profil, prendre la décision. La comparaison ci-dessous sert de démonstration : un dosage de paracétamol est bloqué avec le profil strict sous health et accepté avec le profil permissif, sans qu’une seule ligne de texte ne change.
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def moderate_and_decide(text: str, profile: str = "balanced") -> dict:
"""Modère le texte et prend une décision basée sur le profil."""
# Appel à l'API de modération
response = client.classifiers.moderate(
model="mistral-moderation-2603",
inputs=[text]
)
scores = response.results[0].category_scores or {}
# Application des seuils du profil
thresholds = PROFILES[profile]
classification = classify_content(scores, thresholds)
return {
"text": text[:80],
"profile": profile,
"raw_scores": {k: round(v, 3) for k, v in scores.items()},
"decision": classification
}
# Test avec différents profils
text = "Take 2 paracetamol tablets every 6 hours"
# Profil strict : probablement bloqué (health)
result_strict = moderate_and_decide(text, "strict")
# Profil permissif : probablement accepté
result_permissive = moderate_and_decide(text, "permissive")
Ajustement dynamique des seuils
En production, vos seuils doivent évoluer, et vous pilotez cette évolution par la donnée. Le moniteur ci-dessous écrit chaque décision dans un fichier JSONL et maintient des compteurs pour les blocages, les avertissements et les passages, catégorie par catégorie. Le rapport résultant vous donne un taux de blocage par catégorie — la seule métrique qui vous indique si un seuil est trop bas.
import json
from datetime import datetime, timezone
class ModerationMonitor:
"""Collecte les métriques de modération pour ajuster les seuils."""
def __init__(self, log_file: str = "moderation_logs.jsonl"):
self.log_file = log_file
self.stats = {cat: {"blocked": 0, "warned": 0, "passed": 0}
for cat in PROFILES["balanced"].keys()}
def log_decision(self, scores: dict, thresholds: dict, decision: str):
"""Journalise une décision de modération."""
entry = {
"timestamp": datetime.now(timezone.utc).isoformat(),
"scores": scores,
"thresholds": thresholds,
"decision": decision
}
with open(self.log_file, "a") as f:
f.write(json.dumps(entry) + "\n")
# Mise à jour des compteurs
for cat, threshold in thresholds.items():
score = scores.get(cat, 0.0)
self.stats.setdefault(cat, {"blocked": 0, "warned": 0, "passed": 0})
if score > threshold:
self.stats[cat]["blocked"] += 1
elif score > threshold * 0.6:
self.stats[cat]["warned"] += 1
else:
self.stats[cat]["passed"] += 1
def report(self) -> dict:
"""Génère un rapport pour ajuster les seuils."""
report = {}
for cat, stats in self.stats.items():
total = sum(stats.values())
if total > 0:
report[cat] = {
"block_rate": round(stats["blocked"] / total, 3),
"warning_rate": round(stats["warned"] / total, 3),
"total": total
}
return report
Pièges à éviter
Le premier piège est l’application d’un seuil unique à toutes les catégories. Chaque catégorie possède sa propre distribution de scores : un seuil de 0,3 pour hate_and_discrimination ne signifie pas la même chose que 0,3 pour health, où le contenu légitime se situe naturellement plus haut sur l’échelle. Ajustez chaque catégorie individuellement, même si cela implique de prendre onze décisions au lieu d’une.
Le deuxième est d’ignorer les faux positifs. Un taux de blocage élevé érode la confiance des utilisateurs bien plus vite qu’un incident isolé, car il touche des personnes agissant de bonne foi. Suivez le taux de blocage par catégorie et relevez les seuils lorsque les données le justifient.
Le troisième, plus insidieux, est de ne pas journaliser les décisions. Sans journaux, vous ne pouvez pas ajuster vos seuils de manière éclairée et vous retombez dans des discussions basées sur l’opinion. Enregistrez systématiquement les scores, les seuils appliqués et les décisions prises — ce corpus est ce qui rendra la prochaine révision rapide et indiscutable.
Belangrijkste punten
- Les scores vont de 0,0 à 1,0 ; ce ne sont pas des probabilités étalonnées, et Mistral encourage la définition de vos propres seuils
- Définissez des profils de seuils adaptés à votre contexte (strict, équilibré, permissif)
- Implémentez un système à 3 niveaux : sûr, avertissement, bloqué
- Journalisez toutes les décisions pour ajuster continuellement vos seuils
- Chaque catégorie nécessite son propre seuil — aucune valeur unique ne convient à tous