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)

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)