Documentation • Fonctionnalités et utilisations • Exemples d'utilisation • Modèles d'attaque • Conception de la boîte à outils

OpenAttack est une boîte à outils open source d'attaque adversarial textuelle basée sur Python, qui gère l'ensemble du processus d'attaque adversarial textuelle, y compris le prétraitement du texte, l'accès au modèle victime, la génération d'exemples adversarial et l'évaluation.

Fonctionnalités et utilisations

OpenAttack offre les fonctionnalités suivantes :

⭐️ Prise en charge de tous les types d'attaque. OpenAttack prend en charge tous les types d'attaque, y compris les perturbations au niveau des phrases/mots/caractères et les modèles d'attaque basés sur le gradient/score/décision/aveugle.

⭐️ Multilinguisme. OpenAttack prend actuellement en charge l'anglais et le chinois. Sa conception extensible permet une prise en charge rapide de davantage de langues.

⭐️ Traitement parallèle. OpenAttack offre la possibilité d'exécuter les modèles d'attaque en multi-processus pour améliorer l'efficacité des attaques.

⭐️ Compatibilité avec 🤗 Hugging Face. OpenAttack est entièrement intégré aux bibliothèques 🤗 Transformers et Datasets.

⭐️ Grande extensibilité. Vous pouvez facilement attaquer un modèle victime personnalisé sur n'importe quel jeu de données personnalisé, ou développer et évaluer un modèle d'attaque personnalisé.

OpenAttack a un large éventail d'utilisations, notamment :

✅ Fournir diverses références pratiques pour les modèles d'attaque.

✅ Évaluer de manière exhaustive les modèles d'attaque à l'aide de ses métriques d'évaluation approfondies.

✅ Aider au développement rapide de nouveaux modèles d'attaque grâce à ses composants d'attaque courants.

✅ Évaluer la robustesse d'un modèle d'apprentissage automatique face à diverses attaques adversariales.

✅ Mener un entraînement adversarial pour améliorer la robustesse d'un modèle d'apprentissage automatique en enrichissant les données d'entraînement avec des exemples adversarial générés.

Installation

1. Utilisation de pip (recommandé)```bash

pip install OpenAttack

#### 2. Cloner ce dépôt```bash
git clone https://github.com/thunlp/OpenAttack.git
cd OpenAttack
python setup.py install

Après l'installation, vous pouvez essayer d'exécuter demo.py pour vérifier si OpenAttack fonctionne correctement :``` python demo.py

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

#### Attaquer les modèles victimes intégrés

OpenAttack intègre certains modèles NLP couramment utilisés comme BERT ([Devlin et al. 2018](https://arxiv.org/abs/1810.04805)) et RoBERTa ([Liu et al. 2019](https://arxiv.org/abs/1907.11692)) qui ont été affinés sur des jeux de données courants (comme [SST-2](https://nlp.stanford.edu/sentiment/treebank.html)). Vous pouvez mener sans effort des attaques adverses contre ces modèles victimes intégrés.

L'extrait de code suivant montre comment utiliser PWWS, un modèle d'attaque basé sur un algorithme glouton ([Ren et al., 2019](https://www.aclweb.org/anthology/P19-1103.pdf)), pour attaquer BERT sur le jeu de données SST-2 (le code exécutable complet est [ici](https://github.com/thunlp/openattack/blob/master/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)

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)

</details>


<details>
<summary><strong>Jeu de données personnalisé</strong></summary>