Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Scores de modération et seuils

Les 7 van 12 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Interprétation des scores de modération
  2. Définition de vos seuils : la matrice de décision
  3. Système de classification multi-niveaux
  4. Exemple concret : analyser et décider
  5. Ajustement dynamique des seuils
  6. Pièges à éviter
  7. Belangrijkste punten

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 de mistral-moderation-2603, y compris dangerous. 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 une KeyError pour toute catégorie manquante dans le profil et utilisait datetime.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.

PlageInterprétation
0,0 - 0,1Contenu clairement sûr, aucun signal détecté
0,1 - 0,3Signal faible, potentiellement bénin mais ambigu
0,3 - 0,5Signal modéré, contenu potentiellement problématique
0,5 - 0,7Signal fort, contenu très probablement problématique
0,7 - 1,0Signal 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