MEA-Bench: Un Benchmark para Ataques de Extracción de Modelos

Este repositorio proporciona un benchmark unificado para ataques de extracción de modelos, defensas, ataques adaptativos y evaluación. La interfaz pública está organizada en torno a un pequeño número de comandos portables. Los módulos Python específicos de cada método y los scripts de ejecución heredados son detalles de implementación más que puntos de entrada orientados al usuario.

Los cuatro puntos de entrada portables a continuación validan sus argumentos públicos y luego se despachan a las implementaciones de los métodos. Los envoltorios de recursos de Slurm están intencionalmente excluidos. Los manifiestos propiedad de cada método siguen siendo la autoridad para el comportamiento de reanudación y la procedencia de los artefactos.

Artículo y Autores

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

Fuente del artículo: https://github.com/sliu11-byte/MEA_benchmark_arXiv

Este repositorio proporciona las implementaciones y la interfaz de reproducción para el artículo. Los grupos de consultas están alojados bajo el proyecto de Hugging Face de los autores: https://huggingface.co/datasets/watermarkproject/lord-mea-benchmark

Estructura del Repositorio```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

## Interfaz Pública Canónica

El benchmark expone cuatro comandos de nivel superior:

| Experimento | Punto de entrada | Argumentos de experimento requeridos |
|---|---|---|
| Ataque | `runs/run_attack.sh` | `--attack`, `--budget` |
| Defensa | `runs/run_defense.sh` | extracción defendida: `--defense`, `--attack`, `--budget`; defensa basada en resultados: `--defense`, `--attack-run` |
| Ataque adaptativo | `runs/run_adaptive_attack.sh` | `--adaptive-attack`, `--defense`, `--attack`, `--budget` |
| Evaluación | `runs/run_evaluation.sh` | `--manifest` |

Los cuatro comandos:

- funcionan como comandos de shell ordinarios sin Slurm;
- aceptan `--help` y `--dry-run`;
- validan el experimento solicitado antes de comenzar;
- crean, descubren, validan y reutilizan automáticamente todos los artefactos prerequisito;
- utilizan los valores predeterminados deterministas del benchmark bajo `--profile paper`;
- preservan el comportamiento existente de reanudación y reutilización de artefactos de cada método;
- escriben o preservan metadatos de ejecución legibles por máquina y procedencia de entradas;
- evitan nombres de usuario incrustados, cuentas de clúster, direcciones de correo electrónico o rutas específicas del sitio.

Los runners coordinan la lógica del experimento en el proceso de shell actual. No
envían trabajos al clúster ni eligen una partición del planificador. El llamador es responsable
de asignar suficiente CPU, memoria y GPUs antes de invocar un runner. Un usuario
puede proporcionar endpoints de profesor y estudiante compatibles con OpenAI ya en ejecución; el
despachador de ataques también puede iniciar sus servicios vLLM locales al método existentes.

Los comandos que se muestran a continuación son la interfaz de reproducción pública completa. Un
lector no debería necesitar preparar transcripciones, checkpoints de calentamiento, líneas base
adaptativas, salidas de profesor reservadas o paquetes de checkpoints manualmente.
Esas son dependencias internas propiedad de los runners. La configuración manual se
limita a recursos o credenciales que no pueden inferirse, como la
asignación de GPU, el acceso a modelos restringidos de Hugging Face y endpoints opcionales de modelos externos.

## Métodos Soportados

### Ataques

El registro de ataques contiene seis métodos:```text
seqkd
lord
soda
qedks
model_leeching
gad

El protocolo del artículo utiliza presupuestos de ataque 100, 1000 y 10000. El conjunto de datos de consultas publicado también contiene pools de 50.000 y 100.000 registros para subconjuntos deterministas y construcción de conjuntos reservados, pero estos no se anuncian como presupuestos de ataque principales.

Defensas

Las defensas se separan según los artefactos que requieren.

Defensas de extracción protegida modifican las respuestas, el entrenamiento o el proceso de extracción y, por lo tanto, ejecutan un ataque seleccionado bajo la defensa:```text ads doge trace_rewriting adfp ginsew radioactivity

**Defensas y detectores basados en resultados** consumen artefactos de una ejecución de ataque completada:```text
duffin
mmd
prada
seat

MMD, PRADA y SEAT consumen principalmente tráfico de consultas de ataque. DuFFin consume los artefactos de ataque completados que requiere su detector. El registro de defensas, no el envoltorio del shell, define los requisitos exactos de artefactos para cada método.

Ataques adaptativos

El registro de ataques adaptativos contiene:```text dipper translation

`translation` denota el ataque adaptativo de retro-traducción del benchmark. El
registro rechaza las combinaciones de ataque-defensa-adaptación que no están
implementadas o que no forman parte del protocolo del benchmark.

## Configuración

Utilice Python 3.10 y un entorno CUDA/PyTorch compatible con las versiones
registradas en el artículo. El entorno unificado del benchmark es:```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

Ejecuta los comandos a continuación desde la raíz del repositorio. Los scripts localizan sus implementaciones de métodos en relación con esa raíz y escriben todos los artefactos predeterminados allí.

El único archivo de requisitos de nivel superior cubre ataques, defensas, ataques adaptativos, servicio local de vLLM y evaluación. Utiliza el índice de ruedas de PyTorch con CUDA 12.8 registrado por el entorno del artículo. En una máquina con una pila CUDA diferente, instala primero la compilación de PyTorch correspondiente y luego instala los requisitos restantes. Activa el entorno deseado antes de invocar un ejecutor; los scripts portables no cargan módulos de entorno ni activan Conda automáticamente.

Verifica la instalación antes de una ejecución completa:```bash python3 attacks/scripts/check_attack_env.py
--require-trl --require-vllm --strict-versions

Los modelos Llama utilizados por los ataques, los ataques adaptativos y su evaluación están restringidos en Hugging Face. Solicita acceso a ambos repositorios de modelos Llama, luego autentícate una vez antes de ejecutar el benchmark:```bash
hf auth login

En una máquina no interactiva, configure HF_TOKEN en su lugar. El token es leído por las bibliotecas de Hugging Face y nunca debe escribirse en un manifiesto, script o repositorio publicado. El conjunto de datos del grupo de consultas en sí es público.

Modelos utilizados en el artículo