Configuration des seuils de détection

Les seuils de détection définissent le niveau de confiance à partir duquel Discuse signale un contenu, en équilibrant les faux positifs et les faux négatifs. Dans Discuse, ces seuils sont des paramètres de projet configurés dans le tableau de bord (ou via l’API de paramètres), et la requête API se contente d’activer ou de désactiver les vérifications à exécuter : elle ne transmet pas de seuils numériques. Ce guide explique le fonctionnement de ce compromis et comment choisir les valeurs adaptées à votre plateforme.

Fonctionnement des seuils Discuse

Chaque vérification renvoie un score de confiance compris entre 0.0 et 1.0, ainsi qu’un indicateur hit. Le champ hit est défini lorsque le score atteint ou dépasse le seuil que vous avez configuré pour cette catégorie dans votre projet. Les seuils configurables sont les suivants :

Seuil (paramètre du projet)	S’applique à
`threshold_sentiment`	Seuil global du sentiment négatif
`threshold_toxicity`	Texte toxique
`threshold_profanity`	Grossièretés
`threshold_threat`	Menaces
`threshold_insult`	Insultes
`threshold_spam`	Niveau de confiance du classificateur de spam
`threshold_images`	Images explicites (global)
`threshold_images_porn`	Images pornographiques
`threshold_images_sexual`	Images à caractère sexuel suggestif

Ce sont les noms exposés par l’API des paramètres du projet ; l’objet settings envoyé par requête contient uniquement des bascules d’activation/désactivation check_*, ainsi que expected_language. Les seuils se modifient dans le tableau de bord, pas au niveau de chaque requête.

Le compromis

Lower Threshold = More Strict
├── More content flagged
├── Higher false positive rate
├── Fewer harmful posts slip through
└── More user friction

Higher Threshold = More Permissive
├── Less content flagged
├── Lower false positive rate
├── More harmful posts may slip through
└── Better user experience

Visualiser le compromis

                False Positives ─────────────────────────►
                     Few                              Many
               ┌─────────────────────────────────────────┐
False      Few │   ◄─── Ideal Zone                      │
Negatives      │        (High threshold,                │
               │         low false rates)               │
      │        │                                        │
      │        │              Your platform's           │
      │        │              optimal point →  ●        │
      ▼        │                                        │
          Many │                      Too permissive ──►│
               └─────────────────────────────────────────┘
                       Threshold: 0.3   0.5   0.7   0.9

Quels seuils conviennent à quelle plateforme ?

Les valeurs ci-dessous sont des points de départ exprimés avec les noms de seuils de Discuse (threshold_toxicity, threshold_images_porn, etc.). Considérez-les comme une base à ajuster en fonction de vos propres données de faux positifs, et non comme des chiffres garantis comme corrects. Un seuil plus bas signale les contenus de manière plus stricte.

Plateformes de réseaux sociaux

Les plateformes sociales généralistes ont besoin d’une modération équilibrée :

const SOCIAL_MEDIA_THRESHOLDS = {
  threshold_toxicity: 0.7,
  threshold_profanity: 0.6,
  threshold_threat: 0.5,        // Lower (stricter) for threats
  threshold_insult: 0.7,
  threshold_spam: 0.75,
  threshold_images_porn: 0.6,
  threshold_images_sexual: 0.8  // More permissive for suggestive content
};

Plateformes professionnelles / d’entreprise

Les contextes professionnels exigent généralement une modération plus stricte :

const PROFESSIONAL_THRESHOLDS = {
  threshold_toxicity: 0.5,
  threshold_profanity: 0.4,
  threshold_threat: 0.3,
  threshold_insult: 0.5,
  threshold_spam: 0.6,
  threshold_images_porn: 0.3,
  threshold_images_sexual: 0.5
};

Communautés de jeu

Les plateformes de jeu peuvent tolérer davantage de plaisanteries, tout en restant strictes sur les menaces réelles :

const GAMING_THRESHOLDS = {
  threshold_toxicity: 0.8,
  threshold_profanity: 0.85,    // Banter allowed
  threshold_threat: 0.5,        // Still strict on real threats
  threshold_insult: 0.8,
  threshold_spam: 0.8,
  threshold_images_porn: 0.6,
  threshold_images_sexual: 0.9
};

Plateformes destinées aux enfants

Les plateformes destinées aux mineurs nécessitent les paramètres les plus stricts :

const CHILDRENS_THRESHOLDS = {
  threshold_toxicity: 0.3,
  threshold_profanity: 0.2,
  threshold_threat: 0.2,
  threshold_insult: 0.3,
  threshold_spam: 0.5,
  threshold_images_porn: 0.1,   // Maximum strictness
  threshold_images_sexual: 0.2
};

Puis-je faire varier les seuils dynamiquement ?

Discuse stocke un seul ensemble de seuils par projet ; les variations par utilisateur ou par contexte relèvent donc de votre application. Les modèles ci-dessous calculent un seuil effectif de votre côté ; vous pouvez ensuite soit router vers différents projets (chacun avec ses propres seuils configurés), soit effectuer vous-même la comparaison avec les scores renvoyés par Discuse.

Niveaux de confiance des utilisateurs

Ajustez les seuils effectifs en fonction de la réputation de l’utilisateur :

function getThresholds(user) {
  const baseThresholds = PLATFORM_THRESHOLDS;

  const trustMultipliers = {
    new_user: 0.8,       // Stricter (lower effective threshold)
    basic_user: 1.0,     // Standard
    verified_user: 1.15, // Slightly more permissive
    trusted_user: 1.3,   // More permissive
    moderator: 1.5       // Most permissive
  };

  const multiplier = trustMultipliers[user.trustLevel] || 1.0;

  return Object.fromEntries(
    Object.entries(baseThresholds).map(([key, value]) => [
      key,
      typeof value === 'number'
        ? Math.min(value * multiplier, 0.95)
        : adjustNestedThresholds(value, multiplier)
    ])
  );
}

Seuils basés sur le contexte

Différents types de contenu peuvent nécessiter des seuils différents :

const CONTEXT_THRESHOLDS = {
  // Public posts visible to everyone
  public_post: {
    toxic: 0.6,
    profanity: 0.5
  },

  // Direct messages between users
  direct_message: {
    toxic: 0.7,      // Slightly more permissive
    profanity: 0.6
  },

  // Comments on public content
  comment: {
    toxic: 0.55,     // Stricter than posts
    profanity: 0.5
  },

  // Profile information
  profile: {
    toxic: 0.5,      // Strict for public-facing content
    profanity: 0.4
  }
};

function getContextThresholds(contentType) {
  return CONTEXT_THRESHOLDS[contentType] || CONTEXT_THRESHOLDS.public_post;
}

Ajustements basés sur l’heure

Ajustez les seuils pendant les périodes à risque élevé :

function getTimeAdjustedThresholds(baseThresholds) {
  const hour = new Date().getHours();
  const dayOfWeek = new Date().getDay();

  // Stricter during off-hours when fewer moderators available
  const isOffHours = hour < 6 || hour > 22;
  const isWeekend = dayOfWeek === 0 || dayOfWeek === 6;

  let multiplier = 1.0;

  if (isOffHours) multiplier *= 0.85;
  if (isWeekend) multiplier *= 0.9;

  return adjustThresholds(baseThresholds, multiplier);
}

Implémentation de la configuration des seuils

Configuration centralisée

// config/moderation.js — mirrors your Discuse project thresholds so app-side
// routing stays in sync with the values configured in the dashboard.
export const ModerationConfig = {
  thresholds: {
    threshold_toxicity:      parseFloat(process.env.THRESHOLD_TOXICITY || '0.7'),
    threshold_profanity:     parseFloat(process.env.THRESHOLD_PROFANITY || '0.6'),
    threshold_threat:        parseFloat(process.env.THRESHOLD_THREAT || '0.5'),
    threshold_insult:        parseFloat(process.env.THRESHOLD_INSULT || '0.7'),
    threshold_spam:          parseFloat(process.env.THRESHOLD_SPAM || '0.75'),
    threshold_images_porn:   parseFloat(process.env.THRESHOLD_IMAGES_PORN || '0.6'),
    threshold_images_sexual: parseFloat(process.env.THRESHOLD_IMAGES_SEXUAL || '0.8')
  },

  actions: {
    high_confidence: 'auto_block',     // score > 0.95
    medium_confidence: 'human_review', // 0.7 - 0.95
    low_confidence: 'allow_with_flag'  // threshold - 0.7
  }
};

Mises à jour des seuils à l’exécution

Autorisez l’ajustement des seuils sans redéploiement :

class ModerationService {
  constructor() {
    this.thresholds = defaultThresholds;
    this.loadRemoteConfig();
  }

  async loadRemoteConfig() {
    try {
      const config = await fetch('/api/admin/moderation-config');
      const data = await config.json();
      this.thresholds = data.thresholds;
      console.log('Loaded remote moderation config');
    } catch (error) {
      console.warn('Using default thresholds:', error);
    }
  }

  async checkContent(content, context) {
    const result = await callModerationAPI(content);
    const thresholds = this.getThresholdsForContext(context);

    return this.applyThresholds(result, thresholds);
  }
}

Mesurer l’efficacité des seuils

Indicateurs clés

const MODERATION_METRICS = {
  // Accuracy
  precision: 'True positives / (True positives + False positives)',
  recall: 'True positives / (True positives + False negatives)',
  f1_score: 'Harmonic mean of precision and recall',

  // User impact
  block_rate: 'Content blocked / Total content',
  appeal_rate: 'Appeals filed / Content blocked',
  appeal_success: 'Appeals won / Appeals filed',

  // Operational
  review_queue_size: 'Items waiting for human review',
  review_time: 'Average time to human decision'
};

Seuils de test A/B

Testez les changements de seuil sur un sous-ensemble du trafic :

async function moderateWithExperiment(content, userId) {
  const experiment = getExperiment(userId, 'threshold_test');

  const thresholds = experiment === 'control'
    ? CURRENT_THRESHOLDS
    : EXPERIMENTAL_THRESHOLDS;

  const result = await checkContent(content);
  const decision = applyThresholds(result, thresholds);

  // Log for analysis
  await logExperiment({
    experiment: 'threshold_test',
    variant: experiment,
    content_id: content.id,
    scores: result,
    decision: decision,
    timestamp: Date.now()
  });

  return decision;
}

Analyse des résultats

-- Calculate precision and recall for each threshold variant
SELECT
  variant,
  COUNT(*) as total_decisions,
  SUM(CASE WHEN blocked AND actually_harmful THEN 1 ELSE 0 END) as true_positives,
  SUM(CASE WHEN blocked AND NOT actually_harmful THEN 1 ELSE 0 END) as false_positives,
  SUM(CASE WHEN NOT blocked AND actually_harmful THEN 1 ELSE 0 END) as false_negatives,
  SUM(CASE WHEN blocked AND actually_harmful THEN 1 ELSE 0 END) * 1.0 /
    NULLIF(SUM(CASE WHEN blocked THEN 1 ELSE 0 END), 0) as precision,
  SUM(CASE WHEN blocked AND actually_harmful THEN 1 ELSE 0 END) * 1.0 /
    NULLIF(SUM(CASE WHEN actually_harmful THEN 1 ELSE 0 END), 0) as recall
FROM moderation_decisions
WHERE experiment = 'threshold_test'
GROUP BY variant;

Flux de travail pour l’ajustement des seuils

Étape 1 : Établir une référence

// Start with conservative thresholds
const INITIAL_THRESHOLDS = {
  threshold_toxicity: 0.5,
  threshold_profanity: 0.5,
  threshold_spam: 0.6
};

Étape 2 : Collecter des données

async function logModerationDecision(content, result, decision) {
  await db.insert('moderation_log', {
    content_id: content.id,
    content_hash: hashContent(content.text),
    scores: result.results,
    thresholds_used: currentThresholds,
    decision: decision,
    user_trust_level: content.author.trustLevel,
    created_at: Date.now()
  });
}

Étape 3 : Analyser les taux d’erreur

Passez en revue le contenu bloqué et les réclamations des utilisateurs afin d’identifier :

Faux positifs : contenu sûr bloqué à tort
Faux négatifs : contenu préjudiciable qui n’a pas été détecté

Étape 4 : Ajuster et itérer

// Based on analysis, raise thresholds that fire too often
const ADJUSTED_THRESHOLDS = {
  threshold_toxicity: 0.65,  // Raised after false positives
  threshold_profanity: 0.55,
  threshold_spam: 0.7
};

Étape 5 : Surveiller en continu

Configurez des alertes pour suivre l’efficacité des seuils :

async function checkModerationHealth() {
  const stats = await getModerationStats(last24Hours);

  // Alert if false positive rate too high
  if (stats.appealSuccessRate > 0.3) {
    alert('High appeal success rate - thresholds may be too strict');
  }

  // Alert if harmful content is getting through
  if (stats.reportedAfterApproval > threshold) {
    alert('Increase in reported content - thresholds may be too permissive');
  }
}

Résumé des bonnes pratiques

Commencez prudemment : commencez avec des seuils plus stricts, puis assouplissez-les en fonction des données.
Tenez compte du contexte : différentes surfaces (publications publiques, messages privés, profils) justifient des seuils différents.
Les niveaux de confiance comptent : ajustez le seuil effectif en fonction de la réputation de l’utilisateur dans votre application.
Mesurez tout : suivez la précision, le rappel et l’impact sur les utilisateurs.
Itérez en continu : la modération n’est jamais « terminée ».
Documentez les décisions : conservez une trace des raisons pour lesquelles les seuils ont changé.
Prévoyez des solutions de repli : envoyez les cas limites vers une révision humaine.

Rappel : dans Discuse, ces seuils sont des paramètres de projet. Modifiez-les dans le tableau de bord ou via l’API des paramètres ; l’objet settings par requête ne fait qu’activer ou désactiver les check_* à exécuter.

Prochaines étapes

Guide de modération de contenu par AI - Comprendre la modération par AI
Passer la modération de contenu à l’échelle - Mise en œuvre à grand volume
Analyse de texte - Détails de modération propres au texte