MEA-Bench: Ein Benchmark für Model-Extraction-Angriffe

Dieses Repository bietet einen einheitlichen Benchmark für Model-Extraction-Angriffe, Verteidigungen, adaptive Angriffe und Evaluierung. Die öffentliche Schnittstelle ist um eine kleine Anzahl portabler Befehle organisiert. Methodenspezifische Python-Module und Legacy-Run-Skripte sind Implementierungsdetails und keine benutzerseitigen Einstiegspunkte.

Die vier unten aufgeführten portablen Einstiegspunkte validieren ihre öffentlichen Argumente und leiten dann an die Methodenimplementierungen weiter. Slurm-Ressourcen-Wrapper sind absichtlich ausgeschlossen. Methodeneigene Manifeste bleiben maßgeblich für das Resume-Verhalten und die Artefakt-Herkunft.

Paper und Autoren

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) und Yushun Dong (Florida State University).

Paper-Quelle: https://github.com/sliu11-byte/MEA_benchmark_arXiv

Dieses Repository bietet die Implementierungen und die Reproduktionsschnittstelle für das Paper. Query-Pools werden unter dem Hugging-Face-Projekt der Autoren gehostet: https://huggingface.co/datasets/watermarkproject/lord-mea-benchmark

Repository-Layout```text

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

## Kanonische öffentliche Schnittstelle

Die Benchmark stellt vier Top-Level-Befehle bereit:

| Experiment | Einstiegspunkt | Erforderliche Experiment-Argumente |
|---|---|---|
| Attack | `runs/run_attack.sh` | `--attack`, `--budget` |
| Defense | `runs/run_defense.sh` | verteidigte Extraktion: `--defense`, `--attack`, `--budget`; ergebnisbasierte Verteidigung: `--defense`, `--attack-run` |
| Adaptive attack | `runs/run_adaptive_attack.sh` | `--adaptive-attack`, `--defense`, `--attack`, `--budget` |
| Evaluation | `runs/run_evaluation.sh` | `--manifest` |

Alle vier Befehle:

- funktionieren als gewöhnliche Shell-Befehle ohne Slurm;
- akzeptieren `--help` und `--dry-run`;
- validieren das angeforderte Experiment vor dem Start;
- erstellen, entdecken, validieren und verwenden automatisch alle vorausgesetzten Artefakte wieder;
- verwenden deterministische Benchmark-Standardwerte unter `--profile paper`;
- bewahren das bestehende Resume- und Artefakt-Wiederverwendungsverhalten jeder Methode;
- schreiben oder bewahren maschinenlesbare Laufzeit-Metadaten und Eingabe-Provenienz;
- vermeiden eingebettete Benutzernamen, Cluster-Konten, E-Mail-Adressen oder standortspezifische Pfade.

Die Runner koordinieren die Experimentlogik im aktuellen Shell-Prozess. Sie
übermitteln keine Cluster-Jobs und wählen keine Scheduler-Partition aus. Der
Aufrufer ist dafür verantwortlich, vor dem Aufruf eines Runners ausreichend
CPU, Speicher und GPUs zuzuweisen. Ein Benutzer kann bereits laufende
OpenAI-kompatible Teacher- und Student-Endpunkte bereitstellen; der
Attack-Dispatcher kann auch seine bestehenden methodenlokalen vLLM-Dienste
starten.

Die unten gezeigten Befehle sind die vollständige öffentliche
Reproduktionsschnittstelle. Ein Leser sollte keine Transkripte,
Warmup-Checkpoints, adaptiven Baselines, zurückgehaltenen Teacher-Ausgaben oder
Checkpoint-Bundles manuell vorbereiten müssen. Diese sind interne
Abhängigkeiten, die den Runnern gehören. Die manuelle Konfiguration ist auf
Ressourcen oder Anmeldedaten beschränkt, die nicht abgeleitet werden können,
wie GPU-Zuweisung, Zugriff auf gated Hugging Face-Modelle und optionale
externe Modell-Endpunkte.

## Unterstützte Methoden

### Angriffe

Die Angriffsregistrierung enthält sechs Methoden:```text
seqkd
lord
soda
qedks
model_leeching
gad

Das Paper-Protokoll verwendet Angriffsbudgets von 100, 1000 und 10000. Der veröffentlichte Abfrage-Datensatz enthält außerdem Pools mit 50.000 und 100.000 Datensätzen für deterministische Teilmengen und die Konstruktion von Hold-out-Mengen, diese werden jedoch nicht als primäre Angriffsbudgets angegeben.

Abwehrmaßnahmen

Abwehrmaßnahmen werden nach den Artefakten unterschieden, die sie erfordern.

Defended-Extraction-Abwehrmaßnahmen verändern Antworten, das Training oder den Extraktionsprozess und führen daher einen ausgewählten Angriff unter der Abwehrmaßnahme aus:```text ads doge trace_rewriting adfp ginsew radioactivity

**Ergebnisbasierte Abwehrmechanismen und Detektoren** konsumieren Artefakte aus einem abgeschlossenen Angriffsdurchlauf:```text
duffin
mmd
prada
seat

MMD, PRADA und SEAT konsumieren hauptsächlich Angriffsabfrage-Verkehr. DuFFin konsumiert die fertigen Angriffsartefakte, die von seinem Detektor benötigt werden. Die Verteidigungsregistrierung, nicht der Shell-Wrapper, definiert die genauen Artefaktanforderungen für jede Methode.

Adaptive Angriffe

Die Registrierung für adaptive Angriffe enthält:```text dipper translation

`translation` bezeichnet den Back-Translation-Adaptive-Angriff des Benchmarks. Die
Registry lehnt Angriffs-Verteidigungs-Adaptions-Kombinationen ab, die nicht
implementiert oder nicht Teil des Benchmark-Protokolls sind.

## Setup

Verwenden Sie Python 3.10 und eine CUDA/PyTorch-Umgebung, die mit den im Paper
dokumentierten Versionen kompatibel ist. Die einheitliche Benchmark-Umgebung ist:```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

Führen Sie die folgenden Befehle aus dem Repository-Stammverzeichnis aus. Die Skripte lokalisieren ihre Methodenimplementierungen relativ zu diesem Stammverzeichnis und schreiben alle Standardartefakte dorthin.

Die einzelne Top-Level-Requirements-Datei deckt Angriffe, Verteidigungen, adaptive Angriffe, lokales vLLM-Serving und Evaluierung ab. Sie verwendet den CUDA 12.8 PyTorch-Wheel- Index, der von der Paper-Umgebung aufgezeichnet wurde. Auf einer Maschine mit einem anderen CUDA- Stack installieren Sie zuerst den passenden PyTorch-Build und dann die übrigen Requirements. Aktivieren Sie die gewünschte Umgebung, bevor Sie einen Runner aufrufen; die portablen Skripte laden keine Umgebungsmodule und aktivieren Conda nicht automatisch.

Überprüfen Sie die Installation vor einem vollständigen Durchlauf:```bash python3 attacks/scripts/check_attack_env.py
--require-trl --require-vllm --strict-versions

Die von Angriffen verwendeten Llama-Modelle, adaptive Angriffe und deren Evaluierung sind
auf Hugging Face zugangsbeschränkt. Beantrage den Zugriff auf beide Llama-Modell-Repositories und
authentifiziere dich dann einmalig, bevor du den Benchmark ausführst:```bash
hf auth login

Auf einer nicht-interaktiven Maschine stattdessen HF_TOKEN setzen. Das Token wird von den Hugging-Face-Bibliotheken gelesen und darf niemals in ein Manifest, Skript oder veröffentlichtes Repository geschrieben werden. Der Query-Pool-Datensatz selbst ist öffentlich.

Im Paper verwendete Modelle