PoisonCraft

Ce dépôt fournit l'implémentation officielle de POISONCRAFT : Empoisonnement pratique de la génération augmentée par récupération pour les grands modèles de langage.

Vue d'ensemble

POISONCRAFT vise à démontrer comment un acteur malveillant peut introduire du contenu « empoisonné » dans le corpus utilisé par les pipelines de génération augmentée par récupération (RAG), induisant ainsi un grand modèle de langage en erreur pour qu'il hallucine ou référence un contenu malveillant. Cette base de code fournit des scripts pour :

• Préparer et prétraiter des jeux de données standard (par exemple, Natural Questions, MS MARCO, HotpotQA).

• Injecter des suffixes adversariaux (c'est-à-dire des « poisons ») dans du texte de type requête afin de dégrader ou de manipuler les résultats de récupération.

• Évaluer l'efficacité de l'empoisonnement avec différents récupérateurs (par exemple, Contriever, SimCSE et BGE) et mesurer la transférabilité.

Utilisation rapide

Configuration de l'environnement

Vous trouverez ci-dessous un guide de haut niveau pour configurer l'environnement. Les exigences exactes sont listées dans requirements.txt. Nous recommandons de créer un nouvel environnement virtuel pour éviter les conflits :

# Exemple avec conda
conda create -n PoisonCraft python=3.10
conda activate PoisonCraft

# Installation des dépendances
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu118
pip install -r requirements.txt

Définir la clé API et la configuration du modèle

Certaines parties de ce projet, comme la classification par domaine et la catégorisation des requêtes, reposent sur des appels API (par exemple, les modèles OpenAI GPT). Vous devez configurer la clé API et les paramètres du modèle comme suit :

1. Accédez au répertoire src/models_configs/.
2. Localisez le fichier de configuration approprié (par exemple, gpt3.5_config.py).
3. Mettez à jour le champ api_keys avec votre clé API :
   root@kitploit:~

   "api_key_info": {
       "api_keys": ["your_openai_api_key"],
       "api_key_use": 0
   }
   

Remarque : Ce projet prend en charge plusieurs fournisseurs de LLM (par exemple, OpenAI, Llama et PaLM2). Assurez-vous de sélectionner le fichier de configuration approprié pour votre modèle.

Comment exécuter le code

Nous fournissons divers scripts bash dans le dossier scripts pour les différentes étapes du pipeline. Vous trouverez ci-dessous une référence étape par étape :

Préparation des jeux de données

1. Télécharger et préparer les jeux de données

Exécutez scripts/run_prepare_dataset.sh pour télécharger et décompresser les jeux de données, et pour créer les ensembles d'entraînement/test :

bash scripts/run_prepare_dataset.sh

Ce script appelle en interne :

• experiments/prepare_datasets.py
• experiments/classify_queries_by_domain.py (pour la classification par domaine, si nécessaire)

2. Prétraiter les jeux de données

Pour calculer les scores de similarité de vérité terrain top-k pour chaque domaine, exécutez :

bash scripts/run_process_data.sh

3. [Optionnel]Évaluer BEIR pour la vérité terrain

N'exécutez cette étape que si vous souhaitez évaluer un modèle de récupération, car elle peut prendre un temps considérable. Suivez ces étapes :

1. Exécutez le script d'évaluation BEIR pour calculer les résultats de récupération :
   root@kitploit:~

   python src/beir_eval/eval_beir.py --model_code bge-small --dataset nq --top_k 100
   

2. Utilisez les résultats récupérés pour générer les scores de vérité terrain :
   root@kitploit:~

   bash scripts/run_process_data.sh
   

Entraînement de l'attaque par empoisonnement

Pour générer des suffixes adversariaux (c'est-à-dire des « poisons »), vous pouvez utiliser :

bash scripts/run_multi_poisoncraft.sh

• Ce script lancera plusieurs exécutions de run_poisoncraft.sh en parallèle, chacune explorant différentes longueurs de suffixes adversariaux et différents index de domaine.
• La logique principale appelle experiments/poisoncraft_exp.py

Vous pouvez personnaliser des paramètres tels que :

• DOMAIN_LIST (les index de domaine des requêtes que vous souhaitez empoisonner)
• ADV_LENGTH_LIST (les longueurs de suffixes adversariaux à tester)

Exécution de l'évaluation de l'attaque de récupération

Après avoir généré les suffixes adversariaux, vous pouvez évaluer combien de requêtes obtiennent des références « empoisonnées » en exécutant :

bash scripts/run_retrieval_attack.sh

Ce script :

• Charge les suffixes adversariaux pré-calculés.
• Exécute un test d'attaque à l'aide de experiments/retrieval_attack.py.
• Journalise les résultats indiquant combien de requêtes ont fini par récupérer le texte empoisonné.

Exécution de l'évaluation de l'attaque de génération ciblée

Alternativement, pour une évaluation au niveau du LLM (c'est-à-dire, la génération de texte finale incluant les résultats de récupération top-k), vous pouvez utiliser :

bash scripts/run_target_attack.sh

Résultats et journalisation

• Les journaux sont stockés dans le répertoire logs/.
• Les résultats (par exemple, les requêtes empoisonnées et les taux de succès de l'attaque) sont enregistrés dans le répertoire results/.

Remerciements

• Open-Prompt-Injection : Le code modèle de base est issu de ce dépôt.
• PoisonedRAG : Certaines implémentations ont été adaptées de ce projet.
• Beir Benchmark : Utilisé comme cadre de référence pour l'évaluation.
• Contriever : Utilisé pour les capacités de génération augmentée par récupération (RAG).
• llms-attacks : Certaines implémentations pour l'entraînement adversarial proviennent de ce dépôt.