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/master/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)

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)