sliu11-byte/mea-benchUn benchmark de cycle de vie pour les attaques d'extraction de LLM en boîte noire, les défenses et les attaques adaptatives.
Ce dépôt fournit un benchmark unifié pour les attaques d'extraction de modèles, les défenses, les attaques adaptatives et l'évaluation. L'interface publique est organisée autour d'un petit nombre de commandes portables. Les modules Python spécifiques aux méthodes et les scripts d'exécution hérités sont des détails d'implémentation plutôt que des points d'entrée destinés aux utilisateurs.
Les quatre points d'entrée portables ci-dessous valident leurs arguments publics puis dispatchent vers les implémentations des méthodes. Les wrappers de ressources Slurm sont intentionnellement exclus. Les manifestes propres aux méthodes restent la référence pour le comportement de reprise et la provenance des artefacts.
Do Defenses Against LLM Extraction Work Across Attacks? A Lifecycle Benchmark of Black-Box Model Extraction
Shuze Liu (Florida State University), Kaixiang Zhao (Brigham Young University), Runyang Xu (University of Michigan, Ann Arbor), Jingzhi Chen (State University of New York at Buffalo), Nathan Wu (Wake Forest University), Yu Wang (University of Georgia), et Yushun Dong (Florida State University).
Source de l'article : https://github.com/sliu11-byte/MEA_benchmark_arXiv
Ce dépôt fournit les implémentations et l'interface de reproduction pour l'article. Les pools de requêtes sont hébergés dans le projet Hugging Face des auteurs : https://huggingface.co/datasets/watermarkproject/lord-mea-benchmark
attacks/ attack implementations and shared attack pipeline defenses/ defense implementations and detector adapters countermeasures/ adaptive-attack pipeline evaluation/ shared tasks, rollout code, and metrics infra/ portable model-serving helpers runs/ canonical public entry points
## Interface publique canonique
Le benchmark expose quatre commandes de premier niveau :
| Expérience | Point d'entrée | Arguments d'expérience requis |
|---|---|---|
| Attaque | `runs/run_attack.sh` | `--attack`, `--budget` |
| Défense | `runs/run_defense.sh` | extraction défendue : `--defense`, `--attack`, `--budget` ; défense basée sur les résultats : `--defense`, `--attack-run` |
| Attaque adaptative | `runs/run_adaptive_attack.sh` | `--adaptive-attack`, `--defense`, `--attack`, `--budget` |
| Évaluation | `runs/run_evaluation.sh` | `--manifest` |
Les quatre commandes :
- fonctionnent comme des commandes shell ordinaires sans Slurm ;
- acceptent `--help` et `--dry-run` ;
- valident l'expérience demandée avant de démarrer ;
- créent, découvrent, valident et réutilisent automatiquement tous les artefacts prérequis ;
- utilisent les valeurs par défaut déterministes du benchmark sous `--profile paper` ;
- préservent le comportement existant de reprise et de réutilisation des artefacts de chaque méthode ;
- écrivent ou préservent les métadonnées d'exécution lisibles par machine et la provenance des entrées ;
- évitent les noms d'utilisateur, comptes de cluster, adresses e-mail ou chemins spécifiques au site intégrés.
Les exécuteurs coordonnent la logique d'expérience dans le processus shell courant. Ils ne
soumettent pas de tâches de cluster et ne choisissent pas de partition de planificateur. L'appelant est responsable
de l'allocation de suffisamment de CPU, de mémoire et de GPU avant d'invoquer un exécuteur. Un utilisateur
peut fournir des points de terminaison enseignant et étudiant compatibles OpenAI déjà en cours d'exécution ; le
dispatcher d'attaque peut également démarrer ses services vLLM locaux à la méthode existants.
Les commandes présentées ci-dessous constituent l'interface publique complète de reproduction. Un
lecteur ne devrait pas avoir besoin de préparer manuellement des transcriptions, des points de contrôle de préchauffage, des
lignes de base adaptatives, des sorties d'enseignant retenues ou des lots de points de contrôle.
Ce sont des dépendances internes gérées par les exécuteurs. La configuration manuelle est
limitée aux ressources ou aux identifiants qui ne peuvent pas être déduits, tels que l'allocation GPU, l'accès aux modèles Hugging Face à accès restreint et les points de terminaison de modèles externes optionnels.
## Méthodes prises en charge
### Attaques
Le registre d'attaques contient six méthodes :```text
seqkd
lord
soda
qedks
model_leeching
gad
Le protocole de l'article utilise des budgets d'attaque de 100, 1000 et 10000. Le jeu de données de requêtes publié contient également des pools de 50 000 et 100 000 enregistrements pour les sous-ensembles déterministes et la construction d'ensembles de validation, mais ceux-ci ne sont pas annoncés comme budgets d'attaque principaux.
Les défenses sont séparées selon les artefacts qu'elles nécessitent.
Les défenses d'extraction protégée modifient les réponses, l'entraînement ou le processus d'extraction et exécutent donc une attaque sélectionnée sous la défense :```text ads doge trace_rewriting adfp ginsew radioactivity
**Défenses et détecteurs basés sur les résultats** consomment les artefacts d'une exécution d'attaque terminée :```text
duffin
mmd
prada
seat
MMD, PRADA et SEAT consomment principalement le trafic de requêtes d'attaque. DuFFin consomme les artefacts d'attaque complétés requis par son détecteur. Le registre de défense, et non le wrapper shell, définit les exigences exactes en matière d'artefacts pour chaque méthode.
Le registre des attaques adaptatives contient :```text dipper translation
`translation` désigne l'attaque adaptative par rétro-traduction du benchmark. Le registre rejette les combinaisons attaque-défense-adaptation qui ne sont pas implémentées ou qui ne font pas partie du protocole du benchmark.
## Configuration
Utilisez Python 3.10 et un environnement CUDA/PyTorch compatible avec les versions enregistrées dans l'article. L'environnement unifié du benchmark est :```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
Exécutez les commandes ci-dessous depuis la racine du dépôt. Les scripts localisent leurs implémentations de méthodes relativement à cette racine et écrivent tous les artefacts par défaut à cet endroit.
Le fichier unique de dépendances de premier niveau couvre les attaques, les défenses, les attaques adaptatives, le service vLLM local et l'évaluation. Il utilise l'index de wheels PyTorch CUDA 12.8 enregistré par l'environnement de l'article. Sur une machine disposant d'une pile CUDA différente, installez d'abord la version correspondante de PyTorch, puis installez les dépendances restantes. Activez l'environnement souhaité avant d'invoquer un exécuteur ; les scripts portables ne chargent pas les modules d'environnement ni n'activent Conda automatiquement.
Vérifiez l'installation avant une exécution complète :```bash
python3 attacks/scripts/check_attack_env.py
--require-trl --require-vllm --strict-versions
Les modèles Llama utilisés par les attaques, les attaques adaptatives et leur évaluation sont
soumis à autorisation sur Hugging Face. Demandez l'accès aux deux dépôts de modèles Llama, puis
authentifiez-vous une fois avant d'exécuter le benchmark :```bash
hf auth login
Sur une machine non interactive, définissez plutôt HF_TOKEN. Le jeton est lu par les
bibliothèques Hugging Face et ne doit jamais être écrit dans un manifeste, un script ou un
dépôt publié. Le jeu de données query-pool lui-même est public.