thunlp/openattackUm Pacote Open-Source para Ataque Adversarial Textual.
Documentação • Recursos e Usos • Exemplos de Uso • Modelos de Ataque • Design do Toolkit
O OpenAttack é um toolkit de ataque adversarial textual de código aberto baseado em Python, que lida com todo o processo de ataque adversarial textual, incluindo pré-processamento de texto, acesso ao modelo vítima, geração de exemplos adversariais e avaliação.
⭐️ Suporte para todos os tipos de ataque. O OpenAttack suporta todos os tipos de ataque, incluindo perturbações em nível de sentença/palavra/caractere e modelos de ataque baseados em gradiente/pontuação/decisão/cego;
⭐️ Multilinguidade. O OpenAttack suporta inglês e chinês atualmente. Seu design extensível permite suporte rápido para mais idiomas;
⭐️ Processamento paralelo. O OpenAttack fornece suporte para execução multi-processo de modelos de ataque para melhorar a eficiência;
⭐️ Compatibilidade com 🤗 Hugging Face. O OpenAttack é totalmente integrado com as bibliotecas 🤗 Transformers e Datasets;
⭐️ Grande extensibilidade. Você pode facilmente atacar um modelo vítima personalizado em qualquer conjunto de dados personalizado ou desenvolver e avaliar um modelo de ataque personalizado.
✅ Fornecer várias linhas de base úteis para modelos de ataque;
✅ Avaliar modelos de ataque de forma abrangente usando suas métricas de avaliação completas;
✅ Auxiliar no rápido desenvolvimento de novos modelos de ataque com a ajuda de seus componentes comuns de ataque;
✅ Avaliar a robustez de um modelo de aprendizado de máquina contra vários ataques adversariais;
✅ Realizar treinamento adversarial para melhorar a robustez de um modelo de aprendizado de máquina, enriquecendo os dados de treinamento com exemplos adversariais gerados.
pip (recomendado)```bashpip install OpenAttack
#### 2. Clonando este repositório```bash
git clone https://github.com/thunlp/OpenAttack.git
cd OpenAttack
python setup.py install
Após a instalação, você pode tentar executar demo.py para verificar se o OpenAttack funciona bem:```
python demo.py
## Exemplos de Uso
#### Atacar Modelos de Vítima Integrados
O OpenAttack incorpora alguns modelos de NLP comumente usados, como BERT ([Devlin et al. 2018](https://arxiv.org/abs/1810.04805)) e RoBERTa ([Liu et al. 2019](https://arxiv.org/abs/1907.11692)), que foram ajustados (fine-tuned) em alguns conjuntos de dados comuns (como [SST-2](https://nlp.stanford.edu/sentiment/treebank.html)). Você pode realizar ataques adversariais sem esforço contra esses modelos de vítima integrados.
O trecho de código a seguir mostra como usar o PWWS, um modelo de ataque baseado em algoritmo guloso ([Ren et al., 2019](https://www.aclweb.org/anthology/P19-1103.pdf)), para atacar o BERT no conjunto de dados SST-2 (o código executável completo está [aqui](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)
O trecho de código a seguir mostra como usar o PWWS para atacar um modelo de análise de sentimentos personalizado (um modelo estatístico construído no NLTK) no SST-2 (o código executável completo está aqui).
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, }
dataset = datasets.load_dataset("sst", split="train[:20]").map(function=dataset_mapping)
victim = MyClassifier()
attacker = oa.attackers.PWWSAttacker()
attack_eval = oa.AttackEval(attacker, victim)
attack_eval.eval(dataset, visualize=True)
</details>
<details>
<summary><strong>Dataset Personalizado</strong></summary>
O seguinte trecho de código mostra como usar PWWS para atacar um modelo de análise de sentimentos ajustado existente em um conjunto de dados **personalizado** (o código executável completo está [aqui](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)
OpenAttack suporta multiprocessamento conveniente para acelerar o processo de ataques adversariais. O seguinte trecho de código mostra como usar multiprocessamento em ataques adversariais com Genetic (Alzantot et al. 2018), um modelo de ataque baseado em algoritmo genético (o código executável completo está aqui).```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)
attack_eval.eval(dataset, visualize=True, num_workers=4)
</details>
<details>
<summary><strong>Ataque em Chinês</strong></summary>
O OpenAttack agora suporta ataques adversariais contra modelos vítima em inglês e chinês. [Aqui](https://github.com/thunlp/openattack/blob/HEAD/examples/chinese.py) está um exemplo de código para realizar ataques adversariais contra um modelo de classificação de revisões em chinês usando PWWS.
</details>
<details>
<summary><strong>Modelo de Ataque Personalizado</strong></summary>
O OpenAttack incorpora muitos componentes úteis que podem ser facilmente montados em novos modelos de ataque. [Aqui](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_attacker.py) é fornecido um exemplo de como projetar um modelo de ataque simples que embaralha os tokens na frase original.
</details>
<details>
<summary><strong>Treinamento Adversarial</strong></summary>
O OpenAttack pode gerar facilmente exemplos adversariais atacando instâncias no conjunto de treino, que podem ser adicionados ao conjunto de dados de treino original para retreinar um modelo vítima mais robusto, ou seja, treinamento adversarial. [Aqui](https://github.com/thunlp/openattack/blob/HEAD/examples/adversarial_training.py) é fornecido um exemplo de como realizar treinamento adversarial com OpenAttack.
</details>
<details>
<summary><strong>Mais Exemplos</strong></summary>
- Ataque a Modelos de Classificação de Pares de Frases. Além de modelos de classificação de frases únicas, o OpenAttack suporta ataques contra modelos de classificação de pares de frases. [Aqui](https://github.com/thunlp/openattack/blob/HEAD/examples/nli_attack.py) está um exemplo de código para realizar ataques adversariais contra um modelo NLI com OpenAttack.
- Métrica de Avaliação Personalizada. O OpenAttack suporta a criação de uma métrica de avaliação de ataque adversarial personalizada. [Aqui](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_eval.py) é fornecido um exemplo de como adicionar uma métrica de avaliação personalizada e usá-la para avaliar ataques adversariais.
</details>
## Modelos de Ataque
De acordo com o nível de perturbações impostas à entrada original, os modelos de ataque adversarial textual podem ser categorizados em modelos de ataque de nível de frase, nível de palavra e nível de caractere.
De acordo com a acessibilidade ao modelo vítima, os modelos de ataque adversarial textual podem ser categorizados em modelos de ataque baseados em `gradiente`, baseados em `pontuação`, baseados em `decisão` e `cegos`.
> [TAADPapers](https://github.com/thunlp/TAADpapers) é uma lista de artigos que resume quase todos os artigos sobre ataque e defesa adversarial textual. Você pode dar uma olhada nesta lista para encontrar mais modelos de ataque.
Atualmente, o OpenAttack inclui 15 modelos de ataque típicos contra modelos de classificação de texto que cobrem **todos** os tipos de ataque.
Aqui está a lista dos modelos de ataque atualmente incluídos.
- Nível de Frase
- (SEA) **Regras Adversariais Semanticamente Equivalentes para Depuração de Modelos PLN**. *Marco Tulio Ribeiro, Sameer Singh, Carlos Guestrin*. ACL 2018. `decisão` [[pdf](https://aclweb.org/anthology/P18-1079)] [[código](https://github.com/marcotcr/sears)]
- (SCPN) **Geração de Exemplos Adversariais com Redes de Paráfrase Sintaticamente Controladas**. *Mohit Iyyer, John Wieting, Kevin Gimpel, Luke Zettlemoyer*. NAACL-HLT 2018. `cego` [[pdf](https://www.aclweb.org/anthology/N18-1170)] [[código&dados](https://github.com/miyyer/scpn)]
- (GAN) **Gerando Exemplos Adversariais Naturais**. *Zhengli Zhao, Dheeru Dua, Sameer Singh*. ICLR 2018. `decisão` [[pdf](https://arxiv.org/pdf/1710.11342.pdf)] [[código](https://github.com/zhengliz/natural-adversary)]
- Nível de Palavra
- (TextFooler) **O BERT é Realmente Robusto? Uma Forte Base para Ataque de Linguagem Natural em Classificação de Texto e Implicação**. *Di Jin, Zhijing Jin, Joey Tianyi Zhou, Peter Szolovits*. AAAI-20. `pontuação` [[pdf](https://arxiv.org/pdf/1907.11932v4)] [[código](https://github.com/wqj111186/TextFooler)]
- (PWWS) **Gerando Exemplos Adversariais de Linguagem Natural Através da Salência de Palavras Ponderada por Probabilidade**. *Shuhuai Ren, Yihe Deng, Kun He, Wanxiang Che*. ACL 2019. `pontuação` [[pdf](https://www.aclweb.org/anthology/P19-1103.pdf)] [[código](https://github.com/JHL-HUST/PWWS/)]
- (Genético) **Gerando Exemplos Adversariais de Linguagem Natural**. *Moustafa Alzantot, Yash Sharma, Ahmed Elgohary, Bo-Jhang Ho, Mani Srivastava, Kai-Wei Chang*. EMNLP 2018. `pontuação` [[pdf](https://www.aclweb.org/anthology/D18-1316)] [[código](https://github.com/nesl/nlp_adversarial_examples)]
- (SememePSO) **Ataque Adversarial Textual em Nível de Palavra como Otimização Combinatória**. *Yuan Zang, Fanchao Qi, Chenghao Yang, Zhiyuan Liu, Meng Zhang, Qun Liu e Maosong Sun*. ACL 2020. `pontuação` [[pdf](https://www.aclweb.org/anthology/2020.acl-main.540.pdf)] [[código](https://github.com/thunlp/SememePSO-Attack)]
- (BERT-ATTACK) **BERT-ATTACK: Ataque Adversarial Contra BERT Usando BERT**. *Linyang Li, Ruotian Ma, Qipeng Guo, Xiangyang Xue, Xipeng Qiu*. EMNLP 2020. `pontuação` [[pdf](https://www.aclweb.org/anthology/2020.emnlp-main.500.pdf)] [[código](https://github.com/LinyangLee/BERT-Attack)]
- (BAE) **BAE: Exemplos Adversariais Baseados em BERT para Classificação de Texto**. *Siddhant Garg, Goutham Ramakrishnan. EMNLP 2020*. `pontuação` [[pdf](https://www.aclweb.org/anthology/2020.emnlp-main.498.pdf)] [[código](https://github.com/QData/TextAttack/blob/master/textattack/attack_recipes/bae_garg_2019.py)]
- (FD) **Criando Sequências de Entrada Adversariais para Redes Neurais Recorrentes**. *Nicolas Papernot, Patrick McDaniel, Ananthram Swami, Richard Harang*. MILCOM 2016. `gradiente` [[pdf](https://arxiv.org/pdf/1604.08275.pdf)]
- Nível de Palavra/Caractere
- (TextBugger) **TEXTBUGGER: Gerando Texto Adversarial Contra Aplicações do Mundo Real**. *Jinfeng Li, Shouling Ji, Tianyu Du, Bo Li, Ting Wang*. NDSS 2019. `gradiente` `pontuação` [[pdf](https://arxiv.org/pdf/1812.05271.pdf)]
- (UAT) **Gatilhos Adversariais Universais para Atacar e Analisar PLN.** *Eric Wallace, Shi Feng, Nikhil Kandpal, Matt Gardner, Sameer Singh*. EMNLP-IJCNLP 2019. `gradiente` [[pdf](https://arxiv.org/pdf/1908.07125.pdf)] [[código](https://github.com/Eric-Wallace/universal-triggers)] [[site](http://www.ericswallace.com/triggers)]
- (HotFlip) **HotFlip: Exemplos Adversariais White-Box para Classificação de Texto**. *Javid Ebrahimi, Anyi Rao, Daniel Lowd, Dejing Dou*. ACL 2018. `gradiente` [[pdf](https://www.aclweb.org/anthology/P18-2006)] [[código](https://github.com/AnyiRao/WordAdver)]
- Nível de Caractere
- (VIPER) **Processamento de Texto Como Humanos Fazem: Atacando e Protegendo Sistemas PLN Visualmente**. *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. `pontuação` [[pdf](https://www.aclweb.org/anthology/N19-1165)] [[código&dados](https://github.com/UKPLab/naacl2019-like-humans-visual-attacks)]
- (DeepWordBug) **Geração Black-box de Sequências de Texto Adversariais para Evitar Classificadores de Aprendizagem Profunda**. *Ji Gao, Jack Lanchantin, Mary Lou Soffa, Yanjun Qi*. IEEE SPW 2018. `pontuação` [[pdf](https://ieeexplore.ieee.org/document/8424632)] [[código](https://github.com/QData/deepWordBug)]
A tabela a seguir ilustra a comparação dos modelos de ataque.
| Modelo | Acessibilidade | Perturbação | Ideia Principal |
| :---------: | :-------------: | :----------: | :-------------------------------------------------- |
| SEA | Decisão | Frase | Paráfrase baseada em regras |
| SCPN | Cego | Frase | Paráfrase |
| GAN | Decisão | Frase | Geração de texto por codificador-decodificador |
| TextFooler | Pontuação | Palavra | Substituição gulosa de palavras |
| PWWS | Pontuação | Palavra | Substituição gulosa de palavras |
| Genetic | Pontuação | Palavra | Substituição de palavras baseada em algoritmo genético |
| SememePSO | Pontuação | Palavra | Substituição de palavras baseada em Otimização por Enxame de Partículas |
| BERT-ATTACK | Pontuação | Palavra | Substituição gulosa contextualizada de palavras |
| BAE | Pontuação | Palavra | Substituição e inserção gulosa contextualizada de palavras |
| FD | Gradiente | Palavra | Substituição de palavras baseada em gradiente |
| TextBugger | Gradiente, Pontuação | Palavra+Caractere | Substituição gulosa de palavras e manipulação de caracteres |
| UAT | Gradiente | Palavra, Caractere | Manipulação de palavras ou caracteres baseada em gradiente |
| HotFlip | Gradiente | Palavra, Caractere | Substituição de palavras ou caracteres baseada em gradiente |
| VIPER | Cego | Caractere | Substituição visualmente semelhante de caracteres |
| DeepWordBug | Pontuação | Caractere | Manipulação gulosa de caracteres |
## Design do Toolkit
Considerando as distinções significativas entre diferentes modelos de ataque, deixamos considerável liberdade para o design da estrutura dos modelos de ataque, e focamos mais em simplificar o processamento geral de ataque adversarial e os componentes comuns usados nos modelos de ataque.
O OpenAttack possui 7 módulos principais:
<img src="https://assets.kitploit.com/production/public/readmes/4421/3c70579cf4ea406c82bd3bf407eb9c1e1e8b8ffb3b3c4eede4fe2812ff76eebf.png" alt="toolkit_framework" style="zoom:40%;" />
* **TextProcessor**: processa a sequência de texto original para auxiliar modelos de ataque na geração de exemplos adversariais;
* **Victim**: encapsula modelos vítima;
* **Attacker**: compreende vários modelos de ataque;
* **AttackAssist**: empacota diferentes métodos de substituição de palavras/caracteres usados em modelos de ataque de nível de palavra/caractere e alguns outros componentes usados em modelos de ataque de nível de frase, como o modelo de paráfrase;
* **Metric**: fornece várias métricas de qualidade de exemplo adversarial que podem servir como restrições nos exemplos adversariais durante o ataque ou como métricas de avaliação para avaliar ataques adversariais;
* **AttackEval**: avalia ataques adversariais textuais quanto à eficácia do ataque, qualidade do exemplo adversarial e eficiência do ataque;
* **DataManager**: gerencia todos os dados e modelos salvos usados em outros módulos.
## Citação
Por favor, cite nosso [artigo](https://aclanthology.org/2021.acl-demo.43.pdf) se você usar este 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}
}
Agradecemos a todos os contribuidores deste projeto. E mais contribuições são muito bem-vindas.