Jailbreaking de LLMs de pesos abertos via perturbações aleatórias de embeddings: execuções, rótulos e código

Código e dados para o artigo Jailbreaking Open-Weight LLMs via Random Embedding Perturbations.

Link para o pré-print do artigo - https://arxiv.org/abs/2610.07125

De autoria das pessoas incríveis do Departamento de Ciência da Computação Teórica da Universidade da Califórnia, Santa Cruz.

Este trabalho tem contribuições significativas de Scott Sirri, do Prof. Vaggos Chatziafratis, do Prof. C. Seshadhri e de mim mesmo.

O repositório contém todas as respostas de modelos geradas para o artigo, o rótulo de seguro / inseguro / degenerado de cada resposta, os notebooks do Colab que as produziram e os scripts de inferência que os notebooks importam. Isso abrange o ataque de Vetor de Embedding Perturbado (PEV) e os cinco outros métodos de jailbreak comparados no artigo. Todas as taxas de jailbreak e tempos de execução no artigo são calculados a partir dos arquivos em results/.

Estrutura

code/
  inference/             run_<model>.py: model loading, prompt construction and the manual
                         generation loop that every PEV notebook imports
  ours/<model>/          PEV notebooks for one model
  ours/<model>/fixed_peak_sigma/
                         notebooks for the fixed peak sigma runs (GLM-4-9B, Phi-4-mini,
                         Qwen2.5-1.5B); their logs are in results/<model>/ours/fixed_peak_sigma/
  igcg/                  I-GCG, one notebook per model
  latentfusion/          LatentFusion, one notebook per model
  refusalcones/          RefusalCones, one notebook per model
  softprompt/            SoftPrompt notebooks (Llama-3.1-8B and Mistral-7B)
  figures/               notebook that draws the paper figures
results/<model>/
  baseline/              direct responses to the unperturbed prompts (.txt log) and their
                         labels (.xlsx / .csv); these give the baseline jailbreak rate
  ours/raw_responses/    PEV response logs from the sigma sweeps, split by prompt range
  ours/classified/       labels for those responses, split the same way
  ours/fixed_peak_sigma/ PEV runs at the fixed peak sigma of the model (GLM-4-9B, Phi-4-mini,
                         Qwen2.5-1.5B): the full 100-prompt sweep and the SELECT re-runs
  igcg/ latentfusion/ neurostrike/ refusalcones/ softprompt/
                         responses (.txt) and labels (.xlsx) for the other methods

Modelos: Qwen2.5-1.5B, SmolLM3-3B, Phi-4-mini, Mistral-7B-Instruct, Llama-3.1-8B, GLM-4-9B, as variantes de chat ajustadas por instrução nomeadas na Sec. 4 do artigo.

Onde está o código de cada método:

Método	Localização
PEV	code/ours/<model>/; execuções de pico sigma fixo em code/ours/<model>/fixed_peak_sigma/; código de inferência partilhado em code/inference/
I-GCG	code/igcg/, um notebook por modelo
LatentFusion	code/latentfusion/, um notebook por modelo
RefusalCones	code/refusalcones/, um notebook por modelo
SoftPrompt	code/softprompt/, Llama-3.1-8B e Mistral-7B
NeuroStrike	dentro dos notebooks PEV code/ours/Llama-3.1-8B/LLama31_perturbation_p76_to_p100.ipynb (célula de configuração também em LLama31_perturbation_p1_to_p25.ipynb) e code/ours/SmolLM3-3B/run_smollm3_batched_p26_p50.ipynb; as respostas vão para results/<model>/neurostrike/

Scripts de inferência

code/inference/run_<model>.py é um ficheiro por modelo (run_qwen.py, run_smollm3.py, run_phi4mini.py, run_mistral.py, run_llama.py, run_glm.py). Cada um carrega o modelo com HuggingFace Transformers, aplica o template de chat com uma mensagem de sistema vazia, expõe load_model(), build_prompt() e encode_prompt(), e executa um ciclo manual de geração autorregressiva com um hook nos embeddings de entrada. Os notebooks importam o script do seu modelo e injetam o ruído gaussiano através desse hook. Executado isoladamente, um script abre um terminal interativo para um único modelo; os comandos /verbose e /embedfile imprimem tabelas de tokens e vetores de embedding. Os interruptores de dispositivo e de comportamento são variáveis de ambiente documentadas no cabeçalho de cada ficheiro. O script do Llama necessita de um token do Hugging Face porque o checkpoint tem acesso restrito; o token é lido a partir do ambiente e nunca é armazenado.

Convenções de ficheiros

• Os registos de respostas (.txt) são logs apenas de adição escritos pelos notebooks. Cada entrada regista o índice do prompt, o nível de ruído sigma quando aplicável, o número da execução e a resposta completa do modelo. Os nomes dos ficheiros incluem o intervalo de prompts (p001_to_p025 significa os prompts 1 a 25 dos 100 prompts prejudiciais do JailbreakBench) e o timestamp UTC da execução. O tempo de relógio é escrito após cada lote de 20 execuções por prompt e no final da experiência.
• Os ficheiros de rótulos (.xlsx, .csv) contêm uma linha por resposta com o respetivo rótulo, safe, unsafe ou degenerate, conforme definido na Sec. 4 do artigo. Um prompt conta como jailbroken se qualquer das suas execuções for rotulada como unsafe. Os ficheiros com nomes *_categorization* ou do estilo *_p01_25 são as versões rotuladas do log com o mesmo intervalo de prompts.
• As execuções de pico sigma fixo (ours/fixed_peak_sigma/) são nomeadas JBB_<model>_sigma0pXXX_..._<timestamp>.txt; sigma0p003 significa sigma = 0.003. O ficheiro p001_to_p100 é a varredura completa de 100 prompts e 20 execuções nesse sigma. Os ficheiros SELECT_..._nNN são execuções de seguimento no mesmo sigma sobre os prompts listados no nome do ficheiro, com NN execuções por prompt.
• Os ficheiros que contêm HIGHSIGMA são as execuções com sigma maior discutidas na Sec. 4.1.
• Os ficheiros que contêm SELECT são execuções adicionais sobre os prompts listados no nome do ficheiro, para prompts que precisaram de mais de 20 execuções para serem jailbroken. A linha de cabeçalho de cada log regista os valores de sigma, o número de execuções, os ids dos prompts e a seed aleatória.
• Llama-3.1-8B/baseline/fixed_baseline.xlsx e os ficheiros de rótulos fixed_* são os ficheiros de rótulos após verificação manual e substituem versões anteriores.

Classificação de respostas

As respostas foram classificadas pelo Claude Opus 4.6 com as instruções do juiz do JailbreakBench, recebendo o ficheiro de log com o prompt, o número da execução e a resposta. Cada resposta rotulada como unsafe foi depois verificada manualmente. Os ficheiros de rótulos em results/ são os rótulos verificados.

Reproduzir uma execução

Cada notebook em code/ours/<model>/ foi executado em uma única NVIDIA A100-SXM4-80GB no Google Colab. Ele importa o run_<model>.py correspondente, carrega os prompts prejudiciais do JailbreakBench, mapeia cada prompt através da camada de embedding de entrada do modelo, adiciona ruído gaussiano independente N(0, sigma^2) ao embedding completo do prompt e passa o embedding perturbado para as camadas do transformer. Para cada prompt, ele amostra 20 matrizes de ruído em um único lote e anexa cada resposta ao log. Os parâmetros de decodificação e o sigma por modelo estão listados na Sec. 4 e na Tab. 3 do artigo e definidos no topo de cada notebook. O token do Hugging Face é solicitado interativamente e não é armazenado neste repositório. Os notebooks para os outros métodos seguem o mesmo padrão com o ataque correspondente substituído.

As taxas de jailbreak no artigo podem ser recalculadas apenas a partir dos arquivos de rótulos, sem executar nenhum modelo.