Dokumentation • Funktionen & Anwendungen • Anwendungsbeispiele • Angriffsmodelle • Toolkit-Design

OpenAttack ist ein quelloffenes, auf Python basierendes Toolkit für textuelle adversarial Angriffe, das den gesamten Prozess textueller adversarialer Angriffe abdeckt, einschließlich Textvorverarbeitung, Zugriff auf das Opfermodell, Generierung adversarialer Beispiele und Evaluierung.

Funktionen & Anwendungen

OpenAttack hat die folgenden Funktionen:

⭐️ Unterstützung aller Angriffsarten. OpenAttack unterstützt alle Arten von Angriffen, einschließlich Satz-/Wort-/Zeichenebene-Perturbationen sowie gradienten-/score-/entscheidungsbasierte/blinde Angriffsmodelle;

⭐️ Mehrsprachigkeit. OpenAttack unterstützt jetzt Englisch und Chinesisch. Sein erweiterbares Design ermöglicht eine schnelle Unterstützung weiterer Sprachen;

⭐️ Parallelverarbeitung. OpenAttack bietet Unterstützung für die Ausführung von Angriffsmodellen in mehreren Prozessen, um die Angriffseffizienz zu verbessern;

⭐️ Kompatibilität mit 🤗 Hugging Face. OpenAttack ist vollständig in die Bibliotheken 🤗 Transformers und Datasets integriert;

⭐️ Große Erweiterbarkeit. Sie können problemlos ein angepasstes Opfermodell auf einem beliebigen angepassten Datensatz angreifen oder ein angepasstes Angriffsmodell entwickeln und evaluieren.

OpenAttack hat vielfältige Anwendungsmöglichkeiten, darunter:

✅ Bereitstellung verschiedener praktischer Baselines für Angriffsmodelle;

✅ Umfassende Evaluierung von Angriffsmodellen mit seinen gründlichen Evaluierungsmetriken;

✅ Unterstützung bei der schnellen Entwicklung neuer Angriffsmodelle mithilfe seiner gemeinsamen Angriffskomponenten;

✅ Bewertung der Robustheit eines maschinellen Lernmodells gegenüber verschiedenen adversarialen Angriffen;

✅ Durchführung von adversarialem Training, um die Robustheit eines maschinellen Lernmodells zu verbessern, indem die Trainingsdaten mit generierten adversarialen Beispielen angereichert werden.

Installation

1. Mit `pip` (empfohlen)```bash

pip install OpenAttack

#### 2. Dieses Repository klonen```bash
git clone https://github.com/thunlp/OpenAttack.git
cd OpenAttack
python setup.py install

Nach der Installation können Sie versuchen, demo.py auszuführen, um zu prüfen, ob OpenAttack gut funktioniert:``` python demo.py

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

#### Angriff auf integrierte Opfermodelle

OpenAttack enthält einige häufig verwendete NLP-Modelle wie BERT ([Devlin et al. 2018](https://arxiv.org/abs/1810.04805)) und RoBERTa ([Liu et al. 2019](https://arxiv.org/abs/1907.11692)), die auf gängigen Datensätzen (wie [SST-2](https://nlp.stanford.edu/sentiment/treebank.html)) feinabgestimmt wurden. Sie können mühelos gegnerische Angriffe gegen diese integrierten Opfermodelle durchführen.

Das folgende Codebeispiel zeigt, wie man PWWS, ein auf einem gierigen Algorithmus basierendes Angriffsmodell ([Ren et al., 2019](https://www.aclweb.org/anthology/P19-1103.pdf)), verwenden kann, um BERT auf dem SST-2-Datensatz anzugreifen (der vollständige ausführbare Code befindet sich [hier](https://github.com/thunlp/openattack/blob/HEAD/examples/workflow.py)).

```python
def attack_eval(...):
    ...
``````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)

Benutzerdefiniertes Opfermodell

Das folgende Code-Snippet zeigt, wie man PWWS verwendet, um ein angepasstes Stimmungsanalysemodell (ein mit NLTK erstelltes statistisches Modell) auf SST-2 anzugreifen (der vollständige ausführbare Code ist hier).

```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)

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

load some examples of SST-2 for evaluation

dataset = datasets.load_dataset("sst", split="train[:20]").map(function=dataset_mapping)

choose the costomized classifier as the victim model

victim = MyClassifier()

choose PWWS as the attacker and initialize it with default parameters

attacker = oa.attackers.PWWSAttacker()

prepare for attacking

attack_eval = oa.AttackEval(attacker, victim)

launch attacks and print attack results

attack_eval.eval(dataset, visualize=True)

</details>


<details>
<summary><strong>Benutzerdefinierter Datensatz</strong></summary>

Das folgende Codebeispiel zeigt, wie PWWS verwendet wird, um ein vorhandenes feinabgestimmtes Stimmungsanalysemodell auf einem **benutzerdefinierten** Datensatz anzugreifen (der vollständige ausführbare Code befindet sich [hier](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_dataset.py)).```python
import OpenAttack as oa
import transformers
import datasets

# load a fine-tuned sentiment analysis model from Transformers (you can also use our fine-tuned Victim.BERT.SST)
tokenizer = transformers.AutoTokenizer.from_pretrained("echarlaix/bert-base-uncased-sst2-acc91.1-d37-hybrid")
model = transformers.AutoModelForSequenceClassification.from_pretrained("echarlaix/bert-base-uncased-sst2-acc91.1-d37-hybrid", num_labels=2, output_hidden_states=False)
victim = oa.classifiers.TransformersClassifier(model, tokenizer, model.bert.embeddings.word_embeddings)

# choose PWWS as the attacker and initialize it with default parameters
attacker = oa.attackers.PWWSAttacker()

# create your customized dataset
dataset = datasets.Dataset.from_dict({
    "x": [
        "I hate this movie.",
        "I like this apple."
    ],
    "y": [
        0, # 0 for negative
        1, # 1 for positive
    ]
})

# prepare for attacking
attack_eval = oa.AttackEval(attacker, victim, metrics = [oa.metric.EditDistance(), oa.metric.ModificationRate()])
# launch attacks and print attack results
attack_eval.eval(dataset, visualize=True)

Multiprocessing

OpenAttack unterstützt praktisches Multiprocessing, um den Prozess von adversarialen Angriffen zu beschleunigen. Das folgende Code-Snippet zeigt, wie man Multiprocessing bei adversarialen Angriffen mit Genetic (Alzantot et al. 2018), einem auf genetischen Algorithmen basierenden Angriffsmodell, verwendet (der vollständige ausführbare Code ist hier).```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>Chinesischer Angriff</strong></summary>

OpenAttack unterstützt nun adversarial Angriffe gegen englische und chinesische Opfermodelle. [Hier](https://github.com/thunlp/openattack/blob/HEAD/examples/chinese.py) ist ein Beispielcode zur Durchführung von adversarial Angriffen gegen ein chinesisches Bewertungsklassifikationsmodell mit PWWS.
</details>

<details>
<summary><strong>Angepasstes Angriffsmodell</strong></summary>

OpenAttack enthält viele praktische Komponenten, die leicht zu neuen Angriffsmodellen zusammengesetzt werden können. [Hier](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_attacker.py) wird ein Beispiel gegeben, wie ein einfaches Angriffsmodell entworfen werden kann, das die Token im ursprünglichen Satz mischt.
</details>

<details>
<summary><strong>Adversarial Training</strong></summary>

OpenAttack kann leicht adversarial Beispiele generieren, indem Instanzen im Trainingssatz angegriffen werden. Diese können zum ursprünglichen Trainingsdatensatz hinzugefügt werden, um ein robusteres Opfermodell, d.h. adversarial Training, zu trainieren. [Hier](https://github.com/thunlp/openattack/blob/HEAD/examples/adversarial_training.py) wird ein Beispiel gegeben, wie adversarial Training mit OpenAttack durchgeführt werden kann.
</details>

<details>
<summary><strong>Weitere Beispiele</strong></summary>

- Angriff auf Satzpaar-Klassifikationsmodelle. Neben Einzelsatz-Klassifikationsmodellen unterstützt OpenAttack auch Angriffe auf Satzpaar-Klassifikationsmodelle. [Hier](https://github.com/thunlp/openattack/blob/HEAD/examples/nli_attack.py) ist ein Beispielcode zur Durchführung von adversarial Angriffen gegen ein NLI-Modell mit OpenAttack.

- Angepasste Bewertungsmetrik. OpenAttack unterstützt das Entwerfen einer angepassten adversarial Angriffsbewertungsmetrik. [Hier](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_eval.py) wird ein Beispiel gegeben, wie eine angepasste Bewertungsmetrik hinzugefügt und zur Bewertung adversarialer Angriffe verwendet werden kann.


</details>


## Angriffsmodelle

Basierend auf dem Grad der Störung des ursprünglichen Inputs können textuelle adversarial Angriffsmodelle in satzebene, wortebene und zeichenebene Angriffsmodelle kategorisiert werden.

Basierend auf der Zugänglichkeit zum Opfermodell können textuelle adversarial Angriffsmodelle in `gradient`-basierte, `score`-basierte, `decision`-basierte und `blind` Angriffsmodelle kategorisiert werden.

> [TAADPapers](https://github.com/thunlp/TAADpapers) ist eine Papierliste, die fast alle Papiere zu textuellen adversarial Angriffen und Verteidigungen zusammenfasst. Sie können sich diese Liste ansehen, um weitere Angriffsmodelle zu finden.

Derzeit umfasst OpenAttack 15 typische Angriffsmodelle gegen Textklassifikationsmodelle, die **alle** Angriffstypen abdecken.

Hier ist die Liste der derzeit enthaltenen Angriffsmodelle.

- Satzebene
  - (SEA) **Semantically Equivalent Adversarial Rules for Debugging NLP Models**. *Marco Tulio Ribeiro, Sameer Singh, Carlos Guestrin*. ACL 2018. `decision` [[pdf](https://aclweb.org/anthology/P18-1079)] [[code](https://github.com/marcotcr/sears)]
  - (SCPN) **Adversarial Example Generation with Syntactically Controlled Paraphrase Networks**. *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) **Generating Natural Adversarial Examples**. *Zhengli Zhao, Dheeru Dua, Sameer Singh*. ICLR 2018. `decision` [[pdf](https://arxiv.org/pdf/1710.11342.pdf)] [[code](https://github.com/zhengliz/natural-adversary)]
- Wortebene
  - (TextFooler) **Is BERT Really Robust? A Strong Baseline for Natural Language Attack on Text Classification and Entailment**. *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) **Generating Natural Language Adversarial Examples through Probability Weighted Word Saliency**. *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) **Generating Natural Language Adversarial Examples**. *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) **Word-level Textual Adversarial Attacking as Combinatorial Optimization**. *Yuan Zang, Fanchao Qi, Chenghao Yang, Zhiyuan Liu, Meng Zhang, Qun Liu und 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: Adversarial Attack Against BERT Using 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: BERT-based Adversarial Examples for Text Classification**. *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) **Crafting Adversarial Input Sequences For Recurrent Neural Networks**. *Nicolas Papernot, Patrick McDaniel, Ananthram Swami, Richard Harang*. MILCOM 2016. `gradient` [[pdf](https://arxiv.org/pdf/1604.08275.pdf)]
- Wort-/Zeichenebene
  - (TextBugger) **TEXTBUGGER: Generating Adversarial Text Against Real-world Applications**. *Jinfeng Li, Shouling Ji, Tianyu Du, Bo Li, Ting Wang*. NDSS 2019. `gradient` `score` [[pdf](https://arxiv.org/pdf/1812.05271.pdf)]
  - (UAT) **Universal Adversarial Triggers for Attacking and Analyzing 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: White-Box Adversarial Examples for Text Classification**. *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)]
- Zeichenebene
  - (VIPER) **Text Processing Like Humans Do: Visually Attacking and Shielding NLP Systems**. *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) **Black-box Generation of Adversarial Text Sequences to Evade Deep Learning Classifiers**. *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)]

Die folgende Tabelle zeigt den Vergleich der Angriffsmodelle.

|    Modell    |  Zugänglichkeit  | Störung | Hauptidee                                           |
| :---------: | :-------------: | :----------: | :-------------------------------------------------- |
|     SEA     |    Decision     |   Satz   | Regelbasierte Paraphrasierung                             |
|    SCPN     |      Blind      |   Satz   | Paraphrasierung                                        |
|     GAN     |    Decision     |   Satz   | Textgenerierung durch Encoder-Decoder                  |
| TextFooler  |      Score      |     Wort     | Gierige Wortsubstitution                            |
|    PWWS     |      Score      |     Wort     | Gierige Wortsubstitution                            |
|   Genetic   |      Score      |     Wort     | Genetischer Algorithmus-basierte Wortsubstitution           |
|  SememePSO  |      Score      |     Wort     | Partikelschwarmoptimierungs-basierte Wortsubstitution |
|  BERT-ATTACK  |      Score      |     Wort     | Gierige kontextualisierte Wortsubstitution |
|  BAE  |      Score      |     Wort     | Gierige kontextualisierte Wortsubstitution und -einfügung |
|     FD      |    Gradient     |     Wort     | Gradienten-basierte Wortsubstitution                    |
| TextBugger  | Gradient, Score |  Wort+Zeichen   | Gierige Wortsubstitution und Zeichenmanipulation |
|     UAT     |    Gradient     |  Wort, Zeichen  | Gradienten-basierte Wort- oder Zeichenmanipulation       |
|   HotFlip   |    Gradient     |  Wort, Zeichen  | Gradienten-basierte Wort- oder Zeichensubstitution       |
|    VIPER    |      Blind      |     Zeichen     | Visuell ähnliche Zeichensubstitution             |
| DeepWordBug |      Score      |     Zeichen     | Gierige Zeichenmanipulation                       |

## Toolkit-Design

Angesichts der erheblichen Unterschiede zwischen verschiedenen Angriffsmodellen lassen wir dem Skelett-Design der Angriffsmodelle beträchtliche Freiheit und konzentrieren uns mehr auf die Optimierung der allgemeinen Verarbeitung von adversarial Angriffen und der gemeinsamen Komponenten, die in Angriffsmodellen verwendet werden.

OpenAttack hat 7 Hauptmodule:

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

* **TextProcessor**: Verarbeitet die ursprüngliche Textsequenz, um Angriffsmodelle bei der Generierung adversarialer Beispiele zu unterstützen;
* **Victim**: Kapselt Opfermodelle;
* **Attacker**: Enthält verschiedene Angriffsmodelle;
* **AttackAssist**: Bündelt verschiedene Wort-/Zeichenersetzungsmethoden, die in wort-/zeichenebenen Angriffsmodellen verwendet werden, sowie einige andere Komponenten, die in satzebenen Angriffsmodellen verwendet werden, wie das Paraphrasierungsmodell;
* **Metric**: Bietet mehrere Qualitätsmetriken für adversarial Beispiele, die entweder als Beschränkungen für die adversarial Beispiele während des Angriffs oder als Bewertungsmetriken zur Evaluation adversarialer Angriffe dienen können;
* **AttackEval**: Bewertet textuelle adversarial Angriffe hinsichtlich Angriffseffektivität, adversarial Beispielqualität und Angriffseffizienz;
* **DataManager**: Verwaltet alle Daten und gespeicherten Modelle, die in anderen Modulen verwendet werden.

## Zitation

Bitte zitieren Sie unser [Paper](https://aclanthology.org/2021.acl-demo.43.pdf), wenn Sie dieses Toolkit verwenden:```
@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

Beliebteste

Contributors