StealthRL : Attaques de paraphrase par apprentissage par renforcement pour l'évasion multi-détecteurs des détecteurs de texte IA

Article (arXiv)
Démo
Modèle (Hugging Face)
Jeu de données de référence (Hugging Face)

Résumé

Les détecteurs de texte IA sont de plus en plus utilisés dans des contextes à forts enjeux, mais leur robustesse face à la réécriture adversarial préservant le sens reste incertaine. Nous introduisons StealthRL, un cadre d'apprentissage par renforcement pour tester la robustesse des détecteurs de texte IA avec des attaques par paraphrase adaptatives. StealthRL entraîne une politique de paraphrase contre un ensemble de détecteurs tout en préservant le contenu sémantique, puis évalue le transfert vers des familles de détecteurs non vues. Sur le pool de test MAGE complet filtré (15 310 textes humains / 14 656 textes IA), StealthRL réduit l'AUROC moyen de 0,79 à 0,43 et atteint un TPR@1%FPR moyen de 0,024 sur RoBERTa, Fast-DetectGPT, Binoculars et MAGE. L'attaque se transfère à deux détecteurs non utilisés lors de l'entraînement, exposant des vulnérabilités partagées plutôt qu'une défaillance d'un seul détecteur. Nous analysons en outre les distributions des scores des détecteurs et évaluons la qualité avec E5, BERTScore et des évaluations Likert basées sur LLM. Nos résultats montrent que les détecteurs de texte IA actuels restent fragiles sous une pression de paraphrase réaliste et fournissent un protocole reproductible pour l'évaluation de la robustesse adversarial.

Contenu de ce dépôt

Ce dépôt est la base de code de recherche et d'ingénierie derrière StealthRL. Il contient :

• code d'entraînement basé sur GRPO pour la politique de paraphrase StealthRL
• implémentations des méthodes d'attaque pour les méthodes M0-M5 de l'article
• wrappers de détecteurs et utilitaires d'évaluation
• le pipeline d'évaluation complet MAGE par étapes utilisé pour produire les résultats rapportés
• code de génération de graphiques, de métriques et d'évaluation de qualité pour des figures et tableaux prêts pour publication

Ce dépôt est destiné à servir de point de départ utile aux chercheurs qui souhaitent :

• reproduire notre évaluation de la robustesse des détecteurs
• intégrer de nouveaux détecteurs ou méthodes d'attaque
• étudier le transfert vers des familles de détecteurs non vues
• évaluer leurs propres défenses contre la paraphrase ou méthodes red-team

Plan du dépôt

• stealthrl/ : code d'entraînement, wrappers de détecteurs, récompenses, utilitaires de données et le package StealthBench d'origine
• eval/ : harnais d'évaluation de niveau recherche utilisé pour les résultats de l'article
• scripts/ : points d'entrée exécutables pour l'entraînement, l'évaluation, l'orchestration, la génération de graphiques et les utilitaires
• configs/ : configurations YAML pour l'entraînement, l'évaluation et les ablations
• figures/ : schémas du pipeline et ressources statiques
• tests/ : vérifications d'intégration et de cohérence
• analysis/ : aides à l'analyse ad hoc et utilitaires ponctuels

Configuration de l'environnement

Environnement de base

python -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

Dépendances optionnelles

Selon les parties du projet que vous souhaitez exécuter, vous pouvez également avoir besoin de :

pip install tinker
pip install openai
pip install vllm

Notes :

• tinker est requis pour le chemin d'inférence de checkpoint StealthRL basé sur le cloud utilisé par M2.
• openai n'est requis que pour l'étape d'évaluation de qualité GPT/Likert.
• vllm est recommandé pour la génération locale rapide dans les lignes de base de l'article.

Variables d'environnement

Variables d'environnement typiquement utilisées par le dépôt :

export HF_HOME=$HOME/.cache/huggingface
export TRANSFORMERS_CACHE=$HF_HOME
export OPENAI_API_KEY=...
export TINKER_API_KEY=...

Pour le pipeline d'évaluation par étapes de l'article, nous avons utilisé un fichier d'environnement ainsi qu'un JSON descripteur de checkpoint. Les scripts publics vous permettent de remplacer explicitement les deux chemins :

python scripts/run_full_mage_research_eval.py \
  --env-file ~/.config/stealthrl/eval.env \
  --checkpoint-json ~/.config/stealthrl/m2_checkpoint.json

Démarrage rapide

Test d'évaluation rapide (smoke test)

python scripts/run_eval.py --quick

Exécuter le harnais StealthBench existant

python scripts/run_stealthbench.py --config configs/stealthbench.yaml

Ce script charge désormais les fichiers texte configurés, exécute les détecteurs configurés, enregistre les sorties CSV et génère des graphiques de comparaison. L'ancien stub ne contenant que des TODO a été supprimé.

Exécuter une évaluation complète MAGE par étapes

python scripts/run_full_mage_research_eval.py \
  --env-file ~/.config/stealthrl/eval.env \
  --checkpoint-json ~/.config/stealthrl/m2_checkpoint.json \
  --run-root outputs/eval_runs/full_mage_public \
  --gpus 0 1 2 3

Exécuter le site de démonstration

Le dépôt inclut un site de démonstration basé sur FastAPI dans demo/. Il sert une interface statique soignée et expose POST /api/paraphrase avec prise en charge de clé API ainsi qu'un quota public de 20/jour pour les utilisateurs non authentifiés.

pip install -r demo/requirements.txt
uvicorn demo.stealthrl_demo.app:app --reload --port 8080

Par défaut, la démo s'exécute en mode mock sans coût pour les tests d'interface. Pour utiliser le véritable échantillonneur StealthRL, définissez STEALTHRL_DEMO_INFERENCE_BACKEND=tinker, STEALTHRL_DEMO_CHECKPOINT_JSON et TINKER_API_KEY. Voir demo/README.md pour les notes sur la clé API, le quota, Docker et le déploiement AWS.

Reproduction des résultats de l'article

L'article rapporte des résultats sur le pool d'évaluation MAGE complet filtré :

• 15 310 échantillons humains
• 14 656 échantillons IA
• 29 966 au total

Le pipeline d'évaluation de niveau recherche est implémenté dans le module eval/ ainsi que dans les scripts par étapes sous scripts/.

Flux de reproduction recommandé

1. Préparez les informations d'identification et les métadonnées du checkpoint.

   Créez un fichier d'environnement contenant OPENAI_API_KEY et TINKER_API_KEY, ainsi qu'un JSON de checkpoint décrivant le chemin de l'échantillonneur StealthRL Tinker.

2. Exécutez la vérification préalable (preflight).

python scripts/preflight_research_eval.py \
  --env-file ~/.config/stealthrl/eval.env \
  --checkpoint-json ~/.config/stealthrl/m2_checkpoint.json

3. Lancez l'évaluation complète.

python scripts/run_full_mage_research_eval.py \
  --env-file ~/.config/stealthrl/eval.env \
  --checkpoint-json ~/.config/stealthrl/m2_checkpoint.json \
  --run-root outputs/eval_runs/full_mage_repro \
  --gpus 0 1 2 3

4. Inspectez les sorties générées des méthodes, les scores des détecteurs, les métriques et les graphiques dans le répertoire d'exécution choisi.

5. Si vous devez uniquement relancer l'évaluation de qualité basée sur GPT sur les sorties en cache :

python scripts/run_gpt_quality_only.py \
  --run-root outputs/eval_runs/full_mage_repro \
  --env-file ~/.config/stealthrl/eval.env

6. Si vous devez uniquement ajouter BERTScore à une exécution assemblée avec des sorties en cache :

python scripts/compute_bertscore_for_run.py \
  --run-dir outputs/eval_runs/full_mage_repro/assembled \
  --device cuda:0 \
  --batch-size 16 \
  --chunk-size 512

Le script BERTScore met à jour quality.parquet et quality.csv en place après chaque bloc, de sorte que les exécutions interrompues peuvent être reprises sans recalculer les lignes déjà traitées. Utilisez --limit-per-method pour un petit smoke test et --force uniquement lorsque vous souhaitez délibérément recalculer les colonnes BERTScore existantes.

Principaux artefacts de sortie

L'exécution par étapes produit :

• method_runs/ : sorties générées par méthode
• detector_scores/ : fichiers de scores parquet par détecteur
• assembled/metrics.json : métriques agrégées des détecteurs
• assembled/thresholds.json : seuils calibrés des détecteurs
• assembled/quality.parquet : métriques de qualité automatiques
• assembled/quality_gpt.parquet : évaluations de qualité GPT/Likert
• assembled/figures/ : graphiques prêts pour publication

Paramètres canoniques de l'article

Le checkpoint principal de l'article utilise configs/tinker_mage_10k.yaml comme configuration d'entraînement canonique : Qwen3-4B-Instruct avec LoRA de rang 32, taille de groupe GRPO de 8, 10 000 échantillons d'entraînement MAGE, trois époques, taux d'apprentissage 2.8e-4, coefficient KL 0.05, température 1.0, top-p 0.9, et un ensemble de récompenses à deux détecteurs pondéré 0.6 RoBERTa / 0.4 Fast-DetectGPT. Les autres configurations dans configs/ sont conservées comme exemples hérités, paramètres de smoke test ou modèles d'ablation et ne doivent pas être considérées comme faisant autorité pour l'article, sauf mention explicite.

Implémentation de l'entraînement

StealthRL entraîne une politique de paraphrase plutôt qu'un détecteur. L'idée centrale est d'optimiser un modèle qui réécrit le texte généré par IA afin qu'il reste sémantiquement fidèle tout en réduisant la confiance des détecteurs.

Modèle et optimisation

• Modèle de base : Qwen/Qwen3-4B-Instruct-2507
• Adaptation : LoRA
• Algorithme de RL : GRPO
• Style d'entraînement : optimisation de politique de paraphrase guidée par détecteur

Conception de la récompense

La récompense est multi-objective et équilibre :

• l'évasion des détecteurs face à l'ensemble de détecteurs utilisé en entraînement
• la préservation sémantique par rapport au texte source
• les contraintes de validité et de stabilité de la génération

L'implémentation se trouve principalement dans :

• stealthrl/tinker/train.py
• stealthrl/rewards/
• configs/

Comportement au moment de l'inférence

L'attaque StealthRL de l'article est en un seul passage (single-shot) au moment du test :

• un appel de génération de la politique par échantillon
• aucune boucle de raffinement itératif
• aucune requête aux détecteurs cibles pendant l'évaluation

L'accès aux détecteurs est utilisé pendant l'entraînement RL hors ligne et pour l'évaluation externe, et non pour une recherche adaptative au moment des requêtes dans M2.

Implémentation de l'évaluation

L'évaluation de l'article est implémentée dans la pile plus récente eval/ plutôt que dans l'ancien harnais stealthrl/evaluation/.

Méthodes

• M0 : aucune attaque
• M1 : ligne de base de paraphrase simple
• M2 : StealthRL
• M3 : ligne de base de paraphrase adversarial guidée par détecteur
• M4 : ligne de base AuthorMist
• M5 : ligne de base d'obfuscation au niveau des caractères

Code pertinent :

• eval/methods/
• scripts/generate_method_outputs.py

Panel de détecteurs

Le panel principal de détecteurs de l'article utilise :

• roberta : openai-community/roberta-large-openai-detector
• fast_detectgpt
• binoculars
• mage : yaful/MAGE

Le dépôt conserve également la prise en charge de ghostbuster pour les expériences héritées/de compatibilité, mais Ghostbuster ne fait pas partie du panel final de quatre détecteurs de l'article.

Code pertinent :

• eval/detectors.py
• scripts/score_detector_outputs.py
• eval/runner.py

Métriques et analyse de qualité

Le code d'évaluation public calcule :

• AUROC
• TPR@1%FPR
• TPR@5%FPR
• ASR
• similarité E5
• précision/rappel/F1 BERTScore
• perplexité
• taux d'édition
• scores de qualité et de similarité GPT/Likert
• intervalles de confiance par bootstrap

Code pertinent :

• eval/metrics.py
• eval/plots.py
• eval/quality_judge.py
• scripts/finalize_eval_run.py

Notes d'ingénierie

Intégration vLLM

Le code d'évaluation actuel prend en charge la génération locale basée sur vLLM pour l'évaluation de lignes de base à haut débit. Ceci est implémenté dans :

• eval/methods/vllm_backend.py

Intégration Tinker

La méthode StealthRL M2 prend en charge l'échantillonnage basé sur Tinker via un JSON descripteur de checkpoint. Ce chemin est implémenté dans :

• eval/methods/stealthrl.py

Reprise et orchestration par étapes

Le pipeline complet MAGE est volontairement organisé par étapes :

• les vérifications préalables échouent rapidement en cas de problèmes de configuration des détecteurs/modèles
• la génération par méthode est isolée et peut être reprise
• la notation des détecteurs est séparée de la génération
• l'assemblage final et l'évaluation GPT peuvent être repris

Cela rend les longues exécutions multi-GPU plus robustes et plus faciles à déboguer.

Étendre le dépôt

Ajouter une nouvelle méthode d'attaque

1. Ajoutez une classe sous eval/methods/
2. Implémentez l'interface BaseAttackMethod
3. Enregistrez la méthode dans eval/methods/__init__.py
4. Ajoutez-la à l'exécuteur par étapes si vous souhaitez qu'elle soit incluse dans les exécutions orchestrées

Ajouter un nouveau détecteur

1. Ajoutez un wrapper de détecteur à la pile d'évaluation
2. Implémentez le chargement et la notation par lots
3. Enregistrez-le dans le registre de détecteurs utilisé par eval/runner.py
4. Ajoutez des seuils, des graphiques et des hooks de tableaux selon les besoins

Ajouter un nouveau jeu de données de référence

1. Ajoutez un chargeur ou un adaptateur de jeu de données
2. Normalisez-le selon le schéma d'échantillons d'évaluation
3. Mettez à jour les scripts d'exécution avec le nom du jeu de données et la logique d'échantillonnage

Utilisation responsable

Ce dépôt est publié pour la recherche sur la robustesse des détecteurs de texte IA, l'évaluation adversarial et l'évaluation comparative défensive. Il n'est pas destiné à faciliter la tricherie, le plagiat ou l'évasion de systèmes légitimes de sécurité et d'intégrité.

Si vous vous appuyez sur ce travail, veuillez l'utiliser pour améliorer la robustesse des détecteurs, la calibration, l'évaluation du transfert et la transparence concernant les limites de déploiement.

Citation

Si vous utilisez ce dépôt, veuillez citer l'article :

@article{ranganath2026stealthrl,
  title={StealthRL: Reinforcement Learning Paraphrase Attacks for Multi-Detector Evasion of AI-Text Detectors},
  author={Ranganath, Suraj and others},
  journal={arXiv preprint arXiv:2602.08934},
  year={2026}
}