Documentación • Características y Usos • Ejemplos de Uso • Modelos de Ataque • Diseño del Toolkit

OpenAttack es un kit de herramientas de ataque adversarial textual de código abierto basado en Python, que maneja todo el proceso de ataque adversarial textual, incluyendo preprocesamiento de texto, acceso al modelo víctima, generación de ejemplos adversariales y evaluación.

Características y Usos

OpenAttack tiene las siguientes características:

⭐️ Soporte para todos los tipos de ataque. OpenAttack soporta todos los tipos de ataque, incluyendo perturbaciones a nivel de oración/palabra/carácter y modelos de ataque basados en gradiente/puntuación/decisión/cegados;

⭐️ Multilingüismo. OpenAttack soporta actualmente inglés y chino. Su diseño extensible permite un soporte rápido para más idiomas;

⭐️ Procesamiento paralelo. OpenAttack proporciona soporte para la ejecución multiproceso de modelos de ataque para mejorar la eficiencia del ataque;

⭐️ Compatibilidad con 🤗 Hugging Face. OpenAttack está completamente integrado con las bibliotecas 🤗 Transformers y Datasets;

⭐️ Gran extensibilidad. Puedes atacar fácilmente un modelo víctima personalizado en cualquier conjunto de datos personalizado, o desarrollar y evaluar un modelo de ataque personalizado.

OpenAttack tiene una amplia gama de usos, incluyendo:

✅ Proporcionar diversas líneas base prácticas para modelos de ataque;

✅ Evaluar de manera exhaustiva los modelos de ataque utilizando sus métricas de evaluación detalladas;

✅ Asistir en el desarrollo rápido de nuevos modelos de ataque con la ayuda de sus componentes de ataque comunes;

✅ Evaluar la robustez de un modelo de aprendizaje automático frente a varios ataques adversariales;

✅ Realizar entrenamiento adversarial para mejorar la robustez de un modelo de aprendizaje automático enriqueciendo los datos de entrenamiento con ejemplos adversariales generados.

Instalación

1. Usando `pip` (recomendado)```bash

pip install OpenAttack

#### 2. Clonando este repositorio```bash
git clone https://github.com/thunlp/OpenAttack.git
cd OpenAttack
python setup.py install

Después de la instalación, puedes intentar ejecutar demo.py para comprobar si OpenAttack funciona correctamente:``` python demo.py

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

#### Atacar Modelos Víctima Integrados

OpenAttack integra algunos modelos de PNL comúnmente utilizados como BERT ([Devlin et al. 2018](https://arxiv.org/abs/1810.04805)) y RoBERTa ([Liu et al. 2019](https://arxiv.org/abs/1907.11692)) que han sido ajustados en algunos conjuntos de datos comúnmente utilizados (como [SST-2](https://nlp.stanford.edu/sentiment/treebank.html)). Puedes realizar ataques adversariales contra estos modelos víctima integrados sin esfuerzo.

El siguiente fragmento de código muestra cómo usar PWWS, un modelo de ataque basado en algoritmo greedy ([Ren et al., 2019](https://www.aclweb.org/anthology/P19-1103.pdf)), para atacar BERT en el conjunto de datos SST-2 (el código ejecutable completo está [aquí](https://github.com/thunlp/openattack/blob/master/examples/workflow.py)).

```python
import os
import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

import OpenAttack
import datasets

def main():
    # Load the SST-2 dataset
    dataset = datasets.load_dataset("sst2", split="train[:100]")
    
    # Choose a victim model
    victim = OpenAttack.loadVictim("BERT.SST")
    
    # Choose an attacker
    attacker = OpenAttack.attackers.PWWSAttacker()
    
    # Prepare for attack
    attack_eval = OpenAttack.attack_eval(attacker, victim)
    
    # Launch attack
    result = attack_eval.eval(dataset, visualize=True)
    
    print("Attack result:")
    print("Success rate: %s%%" % (result["success_rate"] * 100))
    print("Average query: %s" % result["avg_query"])

if __name__ == "__main__":
    main()
``````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)

Modelo de Víctima Personalizado

El siguiente fragmento de código muestra cómo usar PWWS para atacar un modelo de análisis de sentimientos personalizado (un modelo estadístico construido en NLTK) en SST-2 (el código ejecutable completo está aquí).```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)

Multiprocesamiento

OpenAttack admite un multiprocesamiento conveniente para acelerar el proceso de ataques adversarios. El siguiente fragmento de código muestra cómo usar el multiprocesamiento en ataques adversarios con Genetic (Alzantot et al. 2018), un modelo de ataque basado en algoritmos genéticos (el código ejecutable completo está aquí).```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>Ataque en chino</strong></summary>

OpenAttack ahora soporta ataques adversariales contra modelos víctima en inglés y chino. [Aquí](https://github.com/thunlp/openattack/blob/master/examples/chinese.py) hay un ejemplo de código para realizar ataques adversariales contra un modelo de clasificación de reseñas en chino usando PWWS.
</details>

<details>
<summary><strong>Modelo de ataque personalizado</strong></summary>

OpenAttack incorpora muchos componentes útiles que se pueden ensamblar fácilmente en nuevos modelos de ataque. [Aquí](https://github.com/thunlp/openattack/blob/master/examples/custom_attacker.py) se muestra un ejemplo de cómo diseñar un modelo de ataque simple que mezcla los tokens en la oración original.
</details>

<details>
<summary><strong>Entrenamiento adversarial</strong></summary>

OpenAttack puede generar fácilmente ejemplos adversariales atacando instancias en el conjunto de entrenamiento, los cuales se pueden agregar al conjunto de datos de entrenamiento original para reentrenar un modelo víctima más robusto, es decir, entrenamiento adversarial. [Aquí](https://github.com/thunlp/openattack/blob/master/examples/adversarial_training.py) se da un ejemplo de cómo realizar entrenamiento adversarial con OpenAttack.
</details>

<details>
<summary><strong>Más ejemplos</strong></summary>

- Ataque a modelos de clasificación de pares de oraciones. Además de los modelos de clasificación de oraciones individuales, OpenAttack soporta ataques contra modelos de clasificación de pares de oraciones. [Aquí](https://github.com/thunlp/openattack/blob/master/examples/nli_attack.py) hay un ejemplo de código para realizar ataques adversariales contra un modelo NLI con OpenAttack.

- Métrica de evaluación personalizada. OpenAttack soporta el diseño de una métrica de evaluación de ataques adversariales personalizada. [Aquí](https://github.com/thunlp/openattack/blob/master/examples/custom_eval.py) se da un ejemplo de cómo agregar una métrica de evaluación personalizada y usarla para evaluar ataques adversariales.

</details>


## Modelos de ataque

Según el nivel de perturbaciones impuestas en la entrada original, los modelos de ataque adversarial textual se pueden categorizar en modelos de ataque a nivel de oración, a nivel de palabra y a nivel de carácter.

Según la accesibilidad al modelo víctima, los modelos de ataque adversarial textual se pueden categorizar en modelos de ataque basados en `gradiente`, basados en `puntuación`, basados en `decisión` y `ciegos`.

> [TAADPapers](https://github.com/thunlp/TAADpapers) es una lista de artículos que resume casi todos los artículos relacionados con el ataque y la defensa adversarial textual. Puedes echar un vistazo a esta lista para encontrar más modelos de ataque.

Actualmente OpenAttack incluye 15 modelos de ataque típicos contra modelos de clasificación de texto que cubren **todos** los tipos de ataque.

Aquí está la lista de los modelos de ataque actualmente incluidos.

- Nivel de oración
  - (SEA) **Reglas adversariales semánticamente equivalentes para depurar modelos de PNL**. *Marco Tulio Ribeiro, Sameer Singh, Carlos Guestrin*. ACL 2018. `decisión` [[pdf](https://aclweb.org/anthology/P18-1079)] [[código](https://github.com/marcotcr/sears)]
  - (SCPN) **Generación de ejemplos adversariales con redes de paráfrasis controladas sintácticamente**. *Mohit Iyyer, John Wieting, Kevin Gimpel, Luke Zettlemoyer*. NAACL-HLT 2018. `ciego` [[pdf](https://www.aclweb.org/anthology/N18-1170)] [[código&datos](https://github.com/miyyer/scpn)]
  - (GAN) **Generación de ejemplos adversariales naturales**. *Zhengli Zhao, Dheeru Dua, Sameer Singh*. ICLR 2018. `decisión` [[pdf](https://arxiv.org/pdf/1710.11342.pdf)] [[código](https://github.com/zhengliz/natural-adversary)]
- Nivel de palabra
  - (TextFooler) **¿Es BERT realmente robusto? Una línea base fuerte para el ataque de lenguaje natural en clasificación de texto y deducción**. *Di Jin, Zhijing Jin, Joey Tianyi Zhou, Peter Szolovits*. AAAI-20. `puntuación` [[pdf](https://arxiv.org/pdf/1907.11932v4)] [[código](https://github.com/wqj111186/TextFooler)]
  - (PWWS) **Generación de ejemplos adversariales de lenguaje natural mediante saliencia de palabras ponderada por probabilidad**. *Shuhuai Ren, Yihe Deng, Kun He, Wanxiang Che*. ACL 2019. `puntuación` [[pdf](https://www.aclweb.org/anthology/P19-1103.pdf)] [[código](https://github.com/JHL-HUST/PWWS/)]
  - (Genetic) **Generación de ejemplos adversariales de lenguaje natural**. *Moustafa Alzantot, Yash Sharma, Ahmed Elgohary, Bo-Jhang Ho, Mani Srivastava, Kai-Wei Chang*. EMNLP 2018. `puntuación` [[pdf](https://www.aclweb.org/anthology/D18-1316)] [[código](https://github.com/nesl/nlp_adversarial_examples)]
  - (SememePSO) **Ataque adversarial textual a nivel de palabra como optimización combinatoria**. *Yuan Zang, Fanchao Qi, Chenghao Yang, Zhiyuan Liu, Meng Zhang, Qun Liu y Maosong Sun*. ACL 2020. `puntuación` [[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. `puntuación` [[pdf](https://www.aclweb.org/anthology/2020.emnlp-main.500.pdf)] [[código](https://github.com/LinyangLee/BERT-Attack)]
  - (BAE) **BAE: Ejemplos adversariales basados en BERT para clasificación de texto**. *Siddhant Garg, Goutham Ramakrishnan. EMNLP 2020*. `puntuación` [[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) **Elaboración de secuencias de entrada adversariales para redes neuronales recurrentes**. *Nicolas Papernot, Patrick McDaniel, Ananthram Swami, Richard Harang*. MILCOM 2016. `gradiente` [[pdf](https://arxiv.org/pdf/1604.08275.pdf)]
- Nivel de palabra/carácter
  - (TextBugger) **TEXTBUGGER: Generación de texto adversarial contra aplicaciones del mundo real**. *Jinfeng Li, Shouling Ji, Tianyu Du, Bo Li, Ting Wang*. NDSS 2019. `gradiente` `puntuación` [[pdf](https://arxiv.org/pdf/1812.05271.pdf)]
  - (UAT) **Disparadores adversariales universales para atacar y analizar PNL.** *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)] [[sitio web](http://www.ericswallace.com/triggers)]
  - (HotFlip) **HotFlip: Ejemplos adversariales de caja blanca para clasificación 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)]
- Nivel de carácter
  - (VIPER) **Procesamiento de texto como humanos: Atacando y protegiendo visualmente sistemas de PNL**. *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. `puntuación` [[pdf](https://www.aclweb.org/anthology/N19-1165)] [[código&datos](https://github.com/UKPLab/naacl2019-like-humans-visual-attacks)]
  - (DeepWordBug) **Generación de caja negra de secuencias de texto adversariales para evadir clasificadores de aprendizaje profundo**. *Ji Gao, Jack Lanchantin, Mary Lou Soffa, Yanjun Qi*. IEEE SPW 2018. `puntuación` [[pdf](https://ieeexplore.ieee.org/document/8424632)] [[código](https://github.com/QData/deepWordBug)]

La siguiente tabla ilustra la comparación de los modelos de ataque.

|    Modelo    |  Accesibilidad  | Perturbación | Idea principal                                           |
| :---------: | :-------------: | :----------: | :-------------------------------------------------- |
|     SEA     |    Decisión     |   Oración    | Paráfrasis basada en reglas                             |
|    SCPN     |      Ciego      |   Oración    | Paráfrasis                                        |
|     GAN     |    Decisión     |   Oración    | Generación de texto mediante codificador-decodificador                  |
| TextFooler  |    Puntuación   |    Palabra   | Sustitución greedy de palabras                            |
|    PWWS     |    Puntuación   |    Palabra   | Sustitución greedy de palabras                            |
|   Genetic   |    Puntuación   |    Palabra   | Sustitución de palabras basada en algoritmo genético           |
|  SememePSO  |    Puntuación   |    Palabra   | Sustitución de palabras basada en optimización por enjambre de partículas |
|  BERT-ATTACK  |    Puntuación   |    Palabra   | Sustitución greedily contextualizada de palabras |
|  BAE  |    Puntuación   |    Palabra   | Sustitución e inserción greedily contextualizada de palabras |
|     FD      |    Gradiente    |    Palabra   | Sustitución de palabras basada en gradiente                    |
| TextBugger  | Gradiente, Puntuación |  Palabra+Carácter   | Sustitución greedy de palabras y manipulación de caracteres |
|     UAT     |    Gradiente    |  Palabra, Carácter  | Manipulación de palabras o caracteres basada en gradiente       |
|   HotFlip   |    Gradiente    |  Palabra, Carácter  | Sustitución de palabras o caracteres basada en gradiente       |
|    VIPER    |      Ciego      |   Carácter   | Sustitución de caracteres visualmente similares             |
| DeepWordBug |    Puntuación   |   Carácter   | Manipulación greedy de caracteres                       |

## Diseño del kit de herramientas

Considerando las distinciones significativas entre los diferentes modelos de ataque, dejamos considerable libertad para el diseño del esqueleto de los modelos de ataque, y nos enfocamos más en optimizar el procesamiento general del ataque adversarial y los componentes comunes utilizados en los modelos de ataque.

OpenAttack tiene 7 módulos principales:

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

* **TextProcessor**: procesa la secuencia de texto original para ayudar a los modelos de ataque a generar ejemplos adversariales;
* **Victim**: envuelve los modelos víctima;
* **Attacker**: comprende varios modelos de ataque;
* **AttackAssist**: empaqueta diferentes métodos de sustitución de palabras/caracteres que se utilizan en modelos de ataque a nivel de palabra/carácter y otros componentes utilizados en modelos de ataque a nivel de oración, como el modelo de paráfrasis;
* **Metric**: proporciona varias métricas de calidad de ejemplos adversariales que pueden servir como restricciones en los ejemplos adversariales durante el ataque o como métricas de evaluación para evaluar ataques adversariales;
* **AttackEval**: evalúa ataques adversariales textuales desde la efectividad del ataque, la calidad de los ejemplos adversariales y la eficiencia del ataque;
* **DataManager**: gestiona todos los datos y modelos guardados que se utilizan en otros módulos.

## Citación

Por favor, cite nuestro [artículo](https://aclanthology.org/2021.acl-demo.43.pdf) si utiliza este kit de herramientas:```
@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

Más Populares

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

Colaboradores