Documentazione • Caratteristiche e usi • Esempi di utilizzo • Modelli di attacco • Progettazione del toolkit

OpenAttack è un toolkit open-source basato su Python per attacchi avversari testuali, che gestisce l'intero processo di attacco avversario testuale, inclusa la pre-elaborazione del testo, l'accesso al modello vittima, la generazione di esempi avversari e la valutazione.

Caratteristiche e usi

OpenAttack offre le seguenti caratteristiche:

⭐️ Supporto per tutti i tipi di attacco. OpenAttack supporta tutti i tipi di attacchi, incluse perturbazioni a livello di frase/parola/carattere e modelli di attacco basati su gradiente/punteggio/decisione/black-box;

⭐️ Multilingualità. OpenAttack attualmente supporta inglese e cinese. Il suo design estensibile consente un rapido supporto per più lingue;

⭐️ Elaborazione parallela. OpenAttack fornisce supporto per l'esecuzione multi-processo dei modelli di attacco per migliorare l'efficienza;

⭐️ Compatibilità con 🤗 Hugging Face. OpenAttack è completamente integrato con le librerie 🤗 Transformers e Datasets;

⭐️ Grande estensibilità. Puoi facilmente attaccare un modello vittima personalizzato su qualsiasi dataset personalizzato, oppure sviluppare e valutare un modello di attacco personalizzato.

OpenAttack ha un'ampia gamma di usi, tra cui:

✅ Fornire vari riferimenti (baseline) utili per i modelli di attacco;

✅ Valutare in modo completo i modelli di attacco utilizzando le sue metriche di valutazione approfondite;

✅ Assistere nello sviluppo rapido di nuovi modelli di attacco grazie ai suoi componenti di attacco comuni;

✅ Valutare la robustezza di un modello di machine learning contro vari attacchi avversari;

✅ Condurre training avversario per migliorare la robustezza di un modello di machine learning arricchendo i dati di training con esempi avversari generati.

Installazione

1. Utilizzo di `pip` (consigliato)```bash

pip install OpenAttack

#### 2. Clonare questo repository```bash
git clone https://github.com/thunlp/OpenAttack.git
cd OpenAttack
python setup.py install

Dopo l'installazione, puoi provare a eseguire demo.py per verificare se OpenAttack funziona correttamente:``` python demo.py

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

#### Attaccare i Modelli Vittima Integrati

OpenAttack integra alcuni modelli NLP comunemente usati come BERT ([Devlin et al. 2018](https://arxiv.org/abs/1810.04805)) e RoBERTa ([Liu et al. 2019](https://arxiv.org/abs/1907.11692)) che sono stati messi a punto su alcuni dataset comunemente usati (come [SST-2](https://nlp.stanford.edu/sentiment/treebank.html)). Puoi condurre facilmente attacchi avversari contro questi modelli vittima integrati.

Il seguente snippet di codice mostra come utilizzare PWWS, un modello di attacco basato su algoritmo greedy ([Ren et al., 2019](https://www.aclweb.org/anthology/P19-1103.pdf)), per attaccare BERT sul dataset SST-2 (il codice eseguibile completo è [qui](https://github.com/thunlp/openattack/blob/HEAD/examples/workflow.py)).

```python
def test_workflow():
    import OpenAttack
    # choose a trained victim model
    victim = OpenAttack.loadAttacker("Bert").loadVictim()
    # choose a dataset to evaluate
    dataset = OpenAttack.loadDataset("SST-2")[:10]
    # choose a custom attacker (PWWS)
    attacker = OpenAttack.loadAttacker("PWWS")
    # prepare for attack
    attack_eval = OpenAttack.loadAttackEval(attacker, victim, dataset)
    # launch attack
    attack_eval.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)

Modello Vittima Personalizzato

Il seguente frammento di codice mostra come utilizzare PWWS per attaccare un modello di analisi del sentimento personalizzato (un modello statistico costruito con NLTK) su SST-2 (il codice eseguibile completo è qui).```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)

Multiprocesso

OpenAttack supporta il multiprocesso per accelerare il processo degli attacchi avversari. Il seguente snippet di codice mostra come utilizzare il multiprocesso negli attacchi avversari con Genetic (Alzantot et al. 2018), un modello di attacco basato su algoritmi genetici (il codice eseguibile completo è qui).```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>Attacco Cinese</strong></summary>

OpenAttack ora supporta attacchi avversari contro modelli vittima in inglese e cinese. [Qui](https://github.com/thunlp/openattack/blob/HEAD/examples/chinese.py) è un esempio di codice per condurre attacchi avversari contro un modello di classificazione delle recensioni cinese utilizzando PWWS.
</details>

<details>
<summary><strong>Modello di Attacco Personalizzato</strong></summary>

OpenAttack incorpora molti componenti utili che possono essere facilmente assemblati in nuovi modelli di attacco. [Qui](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_attacker.py) viene fornito un esempio di come progettare un semplice modello di attacco che mescola i token nella frase originale.
</details>

<details>
<summary><strong>Addestramento Avversario</strong></summary>

OpenAttack può facilmente generare esempi avversari attaccando istanze nel set di addestramento, che possono essere aggiunti al set di dati di addestramento originale per riaddestrare un modello vittima più robusto, ovvero l'addestramento avversario. [Qui](https://github.com/thunlp/openattack/blob/HEAD/examples/adversarial_training.py) viene fornito un esempio di come condurre l'addestramento avversario con OpenAttack.
</details>

<details>
<summary><strong>Altri Esempi</strong></summary>

- Attacco a modelli di classificazione di coppie di frasi. Oltre ai modelli di classificazione a frase singola, OpenAttack supporta attacchi contro modelli di classificazione di coppie di frasi. [Qui](https://github.com/thunlp/openattack/blob/HEAD/examples/nli_attack.py) è un esempio di codice per condurre attacchi avversari contro un modello NLI con OpenAttack.

- Metrica di valutazione personalizzata. OpenAttack supporta la progettazione di una metrica di valutazione personalizzata per attacchi avversari. [Qui](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_eval.py) viene fornito un esempio di come aggiungere una metrica di valutazione personalizzata e usarla per valutare attacchi avversari.


</details>


## Modelli di Attacco

In base al livello di perturbazione imposto all'input originale, i modelli di attacco avversario testuale possono essere categorizzati in modelli a livello di frase, parola e carattere.

In base all'accessibilità al modello vittima, i modelli di attacco avversario testuale possono essere categorizzati in modelli di attacco basati su `gradiente`, su `punteggio`, su `decisione` e `ciechi`.

> [TAADPapers](https://github.com/thunlp/TAADpapers) è una lista di articoli che riassume quasi tutti i lavori riguardanti l'attacco e la difesa avversaria testuale. Puoi dare un'occhiata a questa lista per trovare più modelli di attacco.

Attualmente OpenAttack include 15 modelli di attacco tipici contro modelli di classificazione del testo che coprono **tutti** i tipi di attacco.

Ecco l'elenco dei modelli di attacco attualmente inclusi.

- A livello di frase
  - (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)]
- A livello di parola
  - (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 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: 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)]
- A livello di parola/carattere
  - (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)]
- A livello di carattere
  - (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)]

La tabella seguente illustra il confronto dei modelli di attacco.

|    Modello    |  Accessibilità  | Perturbazione | Idea Principale                                     |
| :-----------: | :-------------: | :-----------: | :-------------------------------------------------- |
|     SEA       |    Decisione    |   Frase       | Parafrasi basata su regole                         |
|    SCPN       |     Cieco       |   Frase       | Parafrasi                                           |
|     GAN       |    Decisione    |   Frase       | Generazione di testo tramite codificatore-decodificatore |
|  TextFooler   |    Punteggio    |   Parola      | Sostituzione greedy di parole                       |
|    PWWS       |    Punteggio    |   Parola      | Sostituzione greedy di parole                       |
|   Genetic     |    Punteggio    |   Parola      | Sostituzione di parole basata su algoritmo genetico |
|  SememePSO    |    Punteggio    |   Parola      | Sostituzione di parole basata su Particle Swarm Optimization |
|  BERT-ATTACK  |    Punteggio    |   Parola      | Sostituzione contestuale greedy di parole           |
|  BAE          |    Punteggio    |   Parola      | Sostituzione e inserimento contestuale greedy di parole |
|     FD        |    Gradiente    |   Parola      | Sostituzione di parole basata su gradiente          |
| TextBugger    | Gradiente, Punteggio | Parola+Carattere | Sostituzione greedy di parole e manipolazione di caratteri |
|     UAT       |    Gradiente    | Parola, Carattere | Manipolazione di parole o caratteri basata su gradiente |
|   HotFlip     |    Gradiente    | Parola, Carattere | Sostituzione di parole o caratteri basata su gradiente |
|    VIPER      |     Cieco       |   Carattere   | Sostituzione di caratteri visivamente simili        |
| DeepWordBug   |    Punteggio    |   Carattere   | Manipolazione greedy di caratteri                   |

## Progettazione del Toolkit

Considerando le notevoli differenze tra i vari modelli di attacco, lasciamo ampia libertà nella progettazione dell'architettura dei modelli di attacco, concentrandoci maggiormente sulla razionalizzazione dell'elaborazione generale dell'attacco avversario e dei componenti comuni utilizzati nei modelli di attacco.

OpenAttack ha 7 moduli principali:

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

* **TextProcessor**: elabora la sequenza di testo originale per assistere i modelli di attacco nella generazione di esempi avversari;
* **Victim**: incapsula i modelli vittima;
* **Attacker**: comprende vari modelli di attacco;
* **AttackAssist**: raggruppa diversi metodi di sostituzione di parole/caratteri utilizzati nei modelli di attacco a livello di parola/carattere e altri componenti utilizzati nei modelli di attacco a livello di frase come il modello di parafrasi;
* **Metric**: fornisce diverse metriche di qualità per esempi avversari che possono servire sia come vincoli sugli esempi avversari durante l'attacco sia come metriche di valutazione per valutare gli attacchi avversari;
* **AttackEval**: valuta gli attacchi avversari testuali in termini di efficacia dell'attacco, qualità degli esempi avversari ed efficienza dell'attacco;
* **DataManager**: gestisce tutti i dati e i modelli salvati utilizzati negli altri moduli.

## Citazione

Si prega di citare il nostro [articolo](https://aclanthology.org/2021.acl-demo.43.pdf) se si utilizza questo toolkit:```
@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

Più Popolari

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

Contributori