Documentation • Fonctionnalités et utilisations • Exemples d'utilisation • Modèles d'attaque • Conception de la boîte à outils

OpenAttack est une boîte à outils open source d'attaque adversarial textuelle basée sur Python, qui gère l'ensemble du processus d'attaque adversarial textuelle, y compris le prétraitement du texte, l'accès au modèle victime, la génération d'exemples adversarial et l'évaluation.

Fonctionnalités et utilisations

OpenAttack offre les fonctionnalités suivantes :

⭐️ Prise en charge de tous les types d'attaque. OpenAttack prend en charge tous les types d'attaque, y compris les perturbations au niveau des phrases/mots/caractères et les modèles d'attaque basés sur le gradient/score/décision/aveugle.

⭐️ Multilinguisme. OpenAttack prend actuellement en charge l'anglais et le chinois. Sa conception extensible permet une prise en charge rapide de davantage de langues.

⭐️ Traitement parallèle. OpenAttack offre la possibilité d'exécuter les modèles d'attaque en multi-processus pour améliorer l'efficacité des attaques.

⭐️ Compatibilité avec 🤗 Hugging Face. OpenAttack est entièrement intégré aux bibliothèques 🤗 Transformers et Datasets.

⭐️ Grande extensibilité. Vous pouvez facilement attaquer un modèle victime personnalisé sur n'importe quel jeu de données personnalisé, ou développer et évaluer un modèle d'attaque personnalisé.

OpenAttack a un large éventail d'utilisations, notamment :

✅ Fournir diverses références pratiques pour les modèles d'attaque.

✅ Évaluer de manière exhaustive les modèles d'attaque à l'aide de ses métriques d'évaluation approfondies.

✅ Aider au développement rapide de nouveaux modèles d'attaque grâce à ses composants d'attaque courants.

✅ Évaluer la robustesse d'un modèle d'apprentissage automatique face à diverses attaques adversariales.

✅ Mener un entraînement adversarial pour améliorer la robustesse d'un modèle d'apprentissage automatique en enrichissant les données d'entraînement avec des exemples adversarial générés.

Installation

1. Utilisation de `pip` (recommandé)```bash

pip install OpenAttack

#### 2. Cloner ce dépôt```bash
git clone https://github.com/thunlp/OpenAttack.git
cd OpenAttack
python setup.py install

Après l'installation, vous pouvez essayer d'exécuter demo.py pour vérifier si OpenAttack fonctionne correctement :``` python demo.py

![demo](https://assets.kitploit.com/production/public/readmes/4421/8322af527eba3c3dcd09c66e50aa3a1229ca0f529018fa6d08b6d8349eb0a51f.gif)
## Exemples d'utilisation

#### Attaquer les modèles victimes intégrés

OpenAttack intègre certains modèles NLP couramment utilisés comme BERT ([Devlin et al. 2018](https://arxiv.org/abs/1810.04805)) et RoBERTa ([Liu et al. 2019](https://arxiv.org/abs/1907.11692)) qui ont été affinés sur des jeux de données courants (comme [SST-2](https://nlp.stanford.edu/sentiment/treebank.html)). Vous pouvez mener sans effort des attaques adverses contre ces modèles victimes intégrés.

L'extrait de code suivant montre comment utiliser PWWS, un modèle d'attaque basé sur un algorithme glouton ([Ren et al., 2019](https://www.aclweb.org/anthology/P19-1103.pdf)), pour attaquer BERT sur le jeu de données SST-2 (le code exécutable complet est [ici](https://github.com/thunlp/openattack/blob/HEAD/examples/workflow.py)).```python
import OpenAttack as oa
import datasets # use the Hugging Face's datasets library
# change the SST dataset into 2-class
def dataset_mapping(x):
    return {
        "x": x["sentence"],
        "y": 1 if x["label"] > 0.5 else 0,
    }
# choose a trained victim classification model
victim = oa.DataManager.loadVictim("BERT.SST")
# choose 20 examples from SST-2 as the evaluation data 
dataset = datasets.load_dataset("sst", split="train[:20]").map(function=dataset_mapping)
# choose PWWS as the attacker and initialize it with default parameters
attacker = oa.attackers.PWWSAttacker()
# prepare for attacking
attack_eval = OpenAttack.AttackEval(attacker, victim)
# launch attacks and print attack results 
attack_eval.eval(dataset, visualize=True)

Modèle victime personnalisé

L'extrait de code suivant montre comment utiliser PWWS pour attaquer un modèle d'analyse de sentiment personnalisé (un modèle statistique construit avec NLTK) sur SST-2 (le code exécutable complet est ici).```python import OpenAttack as oa import numpy as np import datasets import nltk from nltk.sentiment.vader import SentimentIntensityAnalyzer

configure access interface of the customized victim model by extending OpenAttack.Classifier.

class MyClassifier(oa.Classifier): def init(self): # nltk.sentiment.vader.SentimentIntensityAnalyzer is a traditional sentiment classification model. nltk.download('vader_lexicon') self.model = SentimentIntensityAnalyzer()

def get_pred(self, input_):
    return self.get_prob(input_).argmax(axis=1)

# access to the classification probability scores with respect input sentences
def get_prob(self, input_):
    ret = []
    for sent in input_:
        # SentimentIntensityAnalyzer calculates scores of “neg” and “pos” for each instance
        res = self.model.polarity_scores(sent)

        # we use 𝑠𝑜𝑐𝑟𝑒_𝑝𝑜𝑠 / (𝑠𝑐𝑜𝑟𝑒_𝑛𝑒𝑔 + 𝑠𝑐𝑜𝑟𝑒_𝑝𝑜𝑠) to represent the probability of positive sentiment
        # Adding 10^−6 is a trick to avoid dividing by zero.
        prob = (res["pos"] + 1e-6) / (res["neg"] + res["pos"] + 2e-6)

        ret.append(np.array([1 - prob, prob]))
    
    # The get_prob method finally returns a np.ndarray of shape (len(input_), 2). See Classifier for detail.
    return np.array(ret)

Multiprocessing

OpenAttack prend en charge le multiprocessing pratique pour accélérer le processus des attaques adversariales. L'extrait de code suivant montre comment utiliser le multiprocessing dans les attaques adversariales avec Genetic (Alzantot et al. 2018), un modèle d'attaque basé sur un algorithme génétique (le code exécutable complet est ici).```python import OpenAttack as oa import datasets

def dataset_mapping(x): return { "x": x["sentence"], "y": 1 if x["label"] > 0.5 else 0, }

victim = oa.loadVictim("BERT.SST") dataset = datasets.load_dataset("sst", split="train[:20]").map(function=dataset_mapping) attacker = oa.attackers.GeneticAttacker() attack_eval = oa.AttackEval(attacker, victim)

Using multiprocessing simply by specify num_workers

attack_eval.eval(dataset, visualize=True, num_workers=4)

</details>

<details>
<summary><strong>Attaque chinoise</strong></summary>

OpenAttack prend désormais en charge les attaques adversariales contre les modèles victimes en anglais et en chinois. [Ici](https://github.com/thunlp/openattack/blob/HEAD/examples/chinese.py) se trouve un exemple de code pour mener des attaques adversariales contre un modèle de classification d'avis en chinois en utilisant PWWS.
</details>

<details>
<summary><strong>Modèle d'attaque personnalisé</strong></summary>

OpenAttack intègre de nombreux composants pratiques qui peuvent être facilement assemblés en de nouveaux modèles d'attaque. [Ici](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_attacker.py) donne un exemple de la façon de concevoir un modèle d'attaque simple qui mélange les tokens dans la phrase originale.
</details>

<details>
<summary><strong>Apprentissage adversarial</strong></summary>

OpenAttack peut facilement générer des exemples adversariaux en attaquant des instances de l'ensemble d'apprentissage, qui peuvent être ajoutés à l'ensemble de données d'apprentissage original pour ré-entraîner un modèle victime plus robuste, c'est-à-dire l'apprentissage adversarial. [Ici](https://github.com/thunlp/openattack/blob/HEAD/examples/adversarial_training.py) donne un exemple de la façon de mener un apprentissage adversarial avec OpenAttack.
</details>

<details>
<summary><strong>Plus d'exemples</strong></summary>

- Attaquer les modèles de classification de paires de phrases. En plus des modèles de classification de phrases uniques, OpenAttack prend en charge les attaques contre les modèles de classification de paires de phrases. [Ici](https://github.com/thunlp/openattack/blob/HEAD/examples/nli_attack.py) se trouve un exemple de code pour mener des attaques adversariales contre un modèle NLI avec OpenAttack.

- Métrique d'évaluation personnalisée. OpenAttack prend en charge la conception d'une métrique d'évaluation d'attaque adversariale personnalisée. [Ici](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_eval.py) donne un exemple de la façon d'ajouter une métrique d'évaluation personnalisée et de l'utiliser pour évaluer les attaques adversariales.


</details>


## Modèles d'attaque

Selon le niveau de perturbations imposé à l'entrée originale, les modèles d'attaque adversariale textuelle peuvent être catégorisés en modèles d'attaque au niveau de la phrase, au niveau du mot et au niveau du caractère.

Selon l'accessibilité au modèle victime, les modèles d'attaque adversariale textuelle peuvent être catégorisés en modèles d'attaque basés sur le `gradient`, sur le `score`, sur la `décision` et `aveugles`.

> [TAADPapers](https://github.com/thunlp/TAADpapers) est une liste d'articles qui résume presque tous les articles concernant l'attaque et la défense adversariales textuelles. Vous pouvez consulter cette liste pour trouver plus de modèles d'attaque.

Actuellement, OpenAttack inclut 15 modèles d'attaque typiques contre les modèles de classification de texte qui couvrent **tous** les types d'attaque.

Voici la liste des modèles d'attaque actuellement impliqués.

- Niveau de la phrase
  - (SEA) **Règles adversiales sémantiquement équivalentes pour le débogage des modèles NLP**. *Marco Tulio Ribeiro, Sameer Singh, Carlos Guestrin*. ACL 2018. `decision` [[pdf](https://aclweb.org/anthology/P18-1079)] [[code](https://github.com/marcotcr/sears)]
  - (SCPN) **Génération d'exemples adversariaux avec des réseaux de paraphrase contrôlés syntaxiquement**. *Mohit Iyyer, John Wieting, Kevin Gimpel, Luke Zettlemoyer*. NAACL-HLT 2018. `blind` [[pdf](https://www.aclweb.org/anthology/N18-1170)] [[code&data](https://github.com/miyyer/scpn)]
  - (GAN) **Génération d'exemples adversariaux naturels**. *Zhengli Zhao, Dheeru Dua, Sameer Singh*. ICLR 2018. `decision` [[pdf](https://arxiv.org/pdf/1710.11342.pdf)] [[code](https://github.com/zhengliz/natural-adversary)]
- Niveau du mot
  - (TextFooler) **Est-ce que BERT est vraiment robuste ? Une ligne de base forte pour l'attaque en langage naturel sur la classification de texte et l'implication**. *Di Jin, Zhijing Jin, Joey Tianyi Zhou, Peter Szolovits*. AAAI-20. `score` [[pdf](https://arxiv.org/pdf/1907.11932v4)] [[code](https://github.com/wqj111186/TextFooler)]
  - (PWWS) **Génération d'exemples adversariaux en langage naturel via la saillance de mots pondérée par probabilité**. *Shuhuai Ren, Yihe Deng, Kun He, Wanxiang Che*. ACL 2019. `score` [[pdf](https://www.aclweb.org/anthology/P19-1103.pdf)] [[code](https://github.com/JHL-HUST/PWWS/)]
  - (Genetic) **Génération d'exemples adversariaux en langage naturel**. *Moustafa Alzantot, Yash Sharma, Ahmed Elgohary, Bo-Jhang Ho, Mani Srivastava, Kai-Wei Chang*. EMNLP 2018. `score` [[pdf](https://www.aclweb.org/anthology/D18-1316)] [[code](https://github.com/nesl/nlp_adversarial_examples)]
  - (SememePSO) **Attaque adversariale textuelle au niveau du mot comme optimisation combinatoire**. *Yuan Zang, Fanchao Qi, Chenghao Yang, Zhiyuan Liu, Meng Zhang, Qun Liu and Maosong Sun*. ACL 2020. `score` [[pdf](https://www.aclweb.org/anthology/2020.acl-main.540.pdf)] [[code](https://github.com/thunlp/SememePSO-Attack)]
  - (BERT-ATTACK) **BERT-ATTACK : Attaque adversariale contre BERT en utilisant BERT**. *Linyang Li, Ruotian Ma, Qipeng Guo, Xiangyang Xue, Xipeng Qiu*. EMNLP 2020. `score` [[pdf](https://www.aclweb.org/anthology/2020.emnlp-main.500.pdf)] [[code](https://github.com/LinyangLee/BERT-Attack)]
  - (BAE) **BAE : Exemples adversariaux basés sur BERT pour la classification de texte**. *Siddhant Garg, Goutham Ramakrishnan. EMNLP 2020*. `score` [[pdf](https://www.aclweb.org/anthology/2020.emnlp-main.498.pdf)] [[code](https://github.com/QData/TextAttack/blob/master/textattack/attack_recipes/bae_garg_2019.py)]
  - (FD) **Création de séquences d'entrée adversariales pour les réseaux de neurones récurrents**. *Nicolas Papernot, Patrick McDaniel, Ananthram Swami, Richard Harang*. MILCOM 2016. `gradient` [[pdf](https://arxiv.org/pdf/1604.08275.pdf)]
- Niveau mot/caractère
  - (TextBugger) **TEXTBUGGER : Génération de texte adversarial pour des applications réelles**. *Jinfeng Li, Shouling Ji, Tianyu Du, Bo Li, Ting Wang*. NDSS 2019. `gradient` `score` [[pdf](https://arxiv.org/pdf/1812.05271.pdf)]
  - (UAT) **Déclencheurs adversariaux universels pour attaquer et analyser le NLP**. *Eric Wallace, Shi Feng, Nikhil Kandpal, Matt Gardner, Sameer Singh*. EMNLP-IJCNLP 2019. `gradient` [[pdf](https://arxiv.org/pdf/1908.07125.pdf)] [[code](https://github.com/Eric-Wallace/universal-triggers)] [[website](http://www.ericswallace.com/triggers)]
  - (HotFlip) **HotFlip : Exemples adversariaux boîte blanche pour la classification de texte**. *Javid Ebrahimi, Anyi Rao, Daniel Lowd, Dejing Dou*. ACL 2018. `gradient` [[pdf](https://www.aclweb.org/anthology/P18-2006)] [[code](https://github.com/AnyiRao/WordAdver)]
- Niveau du caractère
  - (VIPER) **Traitement du texte comme les humains : attaquer visuellement et protéger les systèmes NLP**. *Steffen Eger, Gözde Gül ¸Sahin, Andreas Rücklé, Ji-Ung Lee, Claudia Schulz, Mohsen Mesgar, Krishnkant Swarnkar, Edwin Simpson, Iryna Gurevych*. NAACL-HLT 2019. `score` [[pdf](https://www.aclweb.org/anthology/N19-1165)] [[code&data](https://github.com/UKPLab/naacl2019-like-humans-visual-attacks)]
  - (DeepWordBug) **Génération boîte noire de séquences de texte adversariales pour échapper aux classifieurs d'apprentissage profond**. *Ji Gao, Jack Lanchantin, Mary Lou Soffa, Yanjun Qi*. IEEE SPW 2018. `score` [[pdf](https://ieeexplore.ieee.org/document/8424632)] [[code](https://github.com/QData/deepWordBug)]

Le tableau suivant illustre la comparaison des modèles d'attaque.

|    Model    |  Accessibility  | Perturbation | Main Idea                                           |
| :---------: | :-------------: | :----------: | :-------------------------------------------------- |
|     SEA     |    Décision    |   Phrase    | Paraphrase basée sur des règles                    |
|    SCPN     |    Aveugle     |   Phrase    | Paraphrase                                          |
|     GAN     |    Décision    |   Phrase    | Génération de texte par encodeur-décodeur           |
| TextFooler  |     Score      |     Mot     | Substitution gloutonne de mots                      |
|    PWWS     |     Score      |     Mot     | Substitution gloutonne de mots                      |
|   Genetic   |     Score      |     Mot     | Substitution de mots basée sur un algorithme génétique |
|  SememePSO  |     Score      |     Mot     | Substitution de mots basée sur l'optimisation par essaims particulaires |
| BERT-ATTACK |     Score      |     Mot     | Substitution gloutonne de mots contextualisés       |
|     BAE     |     Score      |     Mot     | Substitution et insertion gloutonnes de mots contextualisés |
|     FD      |   Gradient    |     Mot     | Substitution de mots basée sur le gradient          |
| TextBugger  | Gradient, Score |  Mot+Char  | Substitution gloutonne de mots et manipulation de caractères |
|     UAT     |   Gradient    |  Mot, Char | Manipulation de mots ou de caractères basée sur le gradient |
|   HotFlip   |   Gradient    |  Mot, Char | Substitution de mots ou de caractères basée sur le gradient |
|    VIPER    |    Aveugle    |    Car     | Substitution de caractères visuellement similaires   |
| DeepWordBug |     Score      |    Car     | Manipulation gloutonne de caractères                 |

## Conception de la boîte à outils

Compte tenu des distinctions significatives entre les différents modèles d'attaque, nous laissons une liberté considérable pour la conception du squelette des modèles d'attaque, et nous nous concentrons davantage sur la rationalisation du traitement général de l'attaque adversariale et des composants communs utilisés dans les modèles d'attaque.

OpenAttack possède 7 modules principaux :

<img src="https://assets.kitploit.com/production/public/readmes/4421/3c70579cf4ea406c82bd3bf407eb9c1e1e8b8ffb3b3c4eede4fe2812ff76eebf.png" alt="toolkit_framework" style="zoom:40%;" />

* **TextProcessor** : traite la séquence de texte originale pour aider les modèles d'attaque à générer des exemples adversariaux ;
* **Victim** : encapsule les modèles victimes ;
* **Attacker** : comprend divers modèles d'attaque ;
* **AttackAssist** : regroupe différentes méthodes de substitution de mots/caractères utilisées dans les modèles d'attaque au niveau du mot/caractère et certains autres composants utilisés dans les modèles d'attaque au niveau de la phrase comme le modèle de paraphrase ;
* **Metric** : fournit plusieurs métriques de qualité des exemples adversariaux qui peuvent servir soit de contraintes sur les exemples adversariaux pendant l'attaque, soit de métriques d'évaluation pour évaluer les attaques adversariales ;
* **AttackEval** : évalue les attaques adversariales textuelles en termes d'efficacité de l'attaque, de qualité des exemples adversariaux et d'efficacité de l'attaque ;
* **DataManager** : gère toutes les données et les modèles sauvegardés utilisés dans les autres modules.

## Citation

Veuillez citer notre [article](https://aclanthology.org/2021.acl-demo.43.pdf) si vous utilisez cette boîte à outils :```
@inproceedings{zeng2020openattack,
  title={{Openattack: An open-source textual adversarial attack toolkit}},
  author={Zeng, Guoyang and Qi, Fanchao and Zhou, Qianrui and Zhang, Tingji and Hou, Bairu and Zang, Yuan and Liu, Zhiyuan and Sun, Maosong},
  booktitle={Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing: System Demonstrations},
  pages={363--371},
  year={2021},
  url={https://aclanthology.org/2021.acl-demo.43},
  doi={10.18653/v1/2021.acl-demo.43}
}

OpenAttack

Populaires

load some examples of SST-2 for evaluation

choose the costomized classifier as the victim model

choose PWWS as the attacker and initialize it with default parameters

prepare for attacking

launch attacks and print attack results

Contributors