दस्तावेज़ीकरण • विशेषताएँ और उपयोग • उपयोग उदाहरण • हमला मॉडल • टूलकिट डिज़ाइन

OpenAttack एक ओपन-सोर्स Python-आधारित पाठ्य प्रतिकूल हमला टूलकिट है, जो पाठ्य प्रतिकूल हमले की पूरी प्रक्रिया को संभालता है, जिसमें पाठ का प्रीप्रोसेसिंग, पीड़ित मॉडल तक पहुँचना, प्रतिकूल उदाहरण उत्पन्न करना और मूल्यांकन शामिल है।

विशेषताएँ और उपयोग

OpenAttack में निम्नलिखित विशेषताएँ हैं:

⭐️ सभी हमला प्रकारों के लिए समर्थन। OpenAttack सभी प्रकार के हमलों का समर्थन करता है, जिसमें वाक्य-/शब्द-/वर्ण-स्तरीय गड़बड़ी और ग्रेडिएंट-/स्कोर-/निर्णय-आधारित/अंधा हमला मॉडल शामिल हैं;

⭐️ बहुभाषीयता। OpenAttack अब अंग्रेजी और चीनी का समर्थन करता है। इसका विस्तार योग्य डिज़ाइन अधिक भाषाओं के त्वरित समर्थन को सक्षम बनाता है;

⭐️ समानांतर प्रसंस्करण। OpenAttack हमले की दक्षता में सुधार के लिए हमला मॉडलों के मल्टी-प्रोसेस रनिंग के लिए समर्थन प्रदान करता है;

⭐️ 🤗 Hugging Face के साथ संगतता। OpenAttack 🤗 Transformers और Datasets लाइब्रेरीज़ के साथ पूरी तरह से एकीकृत है;

⭐️ महान विस्तार योग्यता। आप आसानी से किसी भी अनुकूलित पीड़ित मॉडल पर किसी भी अनुकूलित डेटासेट पर हमला कर सकते हैं या एक अनुकूलित हमला मॉडल विकसित और मूल्यांकन कर सकते हैं।

OpenAttack के उपयोगों की एक विस्तृत श्रृंखला है, जिनमें शामिल हैं:

✅ हमला मॉडलों के लिए विभिन्न सुविधाजनक बेसलाइन प्रदान करना;

✅ अपने गहन मूल्यांकन मैट्रिक्स का उपयोग करके हमला मॉडलों का व्यापक रूप से मूल्यांकन करना;

✅ सामान्य हमला घटकों की सहायता से नए हमला मॉडलों के त्वरित विकास में सहायता करना;

✅ विभिन्न प्रतिकूल हमलों के विरुद्ध मशीन लर्निंग मॉडल की मजबूती का मूल्यांकन करना;

✅ उत्पन्न प्रतिकूल उदाहरणों के साथ प्रशिक्षण डेटा को समृद्ध करके मशीन लर्निंग मॉडल की मजबूती में सुधार के लिए प्रतिकूल प्रशिक्षण आयोजित करना।

स्थापना

1. `pip` का उपयोग करके (अनुशंसित)```bash

pip install OpenAttack

#### 2. इस रिपॉजिटरी को क्लोन करना```bash
git clone https://github.com/thunlp/OpenAttack.git
cd OpenAttack
python setup.py install

स्थापना के बाद, आप यह जांचने के लिए demo.py चला सकते हैं कि OpenAttack ठीक से काम कर रहा है या नहीं:``` python demo.py

![demo](https://assets.kitploit.com/production/public/readmes/4421/8322af527eba3c3dcd09c66e50aa3a1229ca0f529018fa6d08b6d8349eb0a51f.gif)
## उपयोग उदाहरण

#### अंतर्निहित पीड़ित मॉडलों पर हमला

OpenAttack में कुछ सामान्यतः उपयोग किए जाने वाले NLP मॉडल जैसे BERT ([Devlin et al. 2018](https://arxiv.org/abs/1810.04805)) और RoBERTa ([Liu et al. 2019](https://arxiv.org/abs/1907.11692)) शामिल हैं, जिन्हें सामान्यतः उपयोग किए जाने वाले डेटासेटों (जैसे [SST-2](https://nlp.stanford.edu/sentiment/treebank.html)) पर फाइन-ट्यून किया गया है। आप इन अंतर्निहित पीड़ित मॉडलों के विरुद्ध सरलता से प्रतिकूल हमले कर सकते हैं।

निम्नलिखित कोड स्निपेट दिखाता है कि कैसे PWWS, एक लालची एल्गोरिथम-आधारित हमला मॉडल ([Ren et al., 2019](https://www.aclweb.org/anthology/P19-1103.pdf)), का उपयोग करके SST-2 डेटासेट पर BERT पर हमला किया जाए (पूर्ण निष्पादन योग्य कोड [यहाँ](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)

अनुकूलित पीड़ित मॉडल

निम्नलिखित कोड स्निपेट बताता है कि SST-2 पर अनुकूलित भावना विश्लेषण मॉडल (NLTK में निर्मित एक सांख्यिकीय मॉडल) पर हमला करने के लिए PWWS का उपयोग कैसे करें (पूर्ण निष्पादन योग्य कोड यहाँ है)।

```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)

def dataset_mapping(x): return { "x": x["sentence"], "y": 1 if x["label"] > 0.5 else 0, }

load some examples of SST-2 for evaluation

dataset = datasets.load_dataset("sst", split="train[:20]").map(function=dataset_mapping)

choose the costomized classifier as the victim model

victim = MyClassifier()

choose PWWS as the attacker and initialize it with default parameters

attacker = oa.attackers.PWWSAttacker()

prepare for attacking

attack_eval = oa.AttackEval(attacker, victim)

launch attacks and print attack results

attack_eval.eval(dataset, visualize=True)

</details>


<details>
<summary><strong>अनुकूलित डेटासेट</strong></summary>

निम्नलिखित कोड स्निपेट दिखाता है कि कैसे PWWS का उपयोग करके एक **अनुकूलित** डेटासेट पर मौजूदा फाइन-ट्यून किए गए भावना विश्लेषण मॉडल पर हमला किया जा सकता है (पूर्ण निष्पादन योग्य कोड [यहाँ](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 प्रतिकूल हमलों की प्रक्रिया को तेज़ करने के लिए सुविधाजनक मल्टीप्रोसेसिंग का समर्थन करता है। निम्नलिखित कोड स्निपेट दिखाता है कि कैसे Genetic (Alzantot et al. 2018), एक आनुवंशिक एल्गोरिथम-आधारित हमला मॉडल, के साथ प्रतिकूल हमलों में मल्टीप्रोसेसिंग का उपयोग किया जाए (पूर्ण निष्पादन योग्य कोड यहाँ है)।```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>चीनी हमला</strong></summary>

OpenAttack अब अंग्रेजी और चीनी पीड़ित मॉडलों के विरुद्ध प्रतिकूल हमलों का समर्थन करता है। [यहाँ](https://github.com/thunlp/openattack/blob/HEAD/examples/chinese.py) PWWS का उपयोग करके चीनी समीक्षा वर्गीकरण मॉडल के विरुद्ध प्रतिकूल हमले करने का एक उदाहरण कोड है।
</details>

<details>
<summary><strong>अनुकूलित आक्रमण मॉडल</strong></summary>

OpenAttack में कई उपयोगी घटक शामिल हैं जिन्हें आसानी से नए आक्रमण मॉडलों में जोड़ा जा सकता है। [यहाँ](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_attacker.py) एक सरल आक्रमण मॉडल डिजाइन करने का उदाहरण दिया गया है जो मूल वाक्य में टोकनों को फेरबदल करता है।
</details>

<details>
<summary><strong>प्रतिकूल प्रशिक्षण</strong></summary>

OpenAttack प्रशिक्षण सेट में उदाहरणों पर हमला करके आसानी से प्रतिकूल उदाहरण उत्पन्न कर सकता है, जिन्हें मूल प्रशिक्षण डेटा सेट में जोड़कर अधिक मजबूत पीड़ित मॉडल को पुनःप्रशिक्षित किया जा सकता है, अर्थात प्रतिकूल प्रशिक्षण। [यहाँ](https://github.com/thunlp/openattack/blob/HEAD/examples/adversarial_training.py) OpenAttack के साथ प्रतिकूल प्रशिक्षण करने का एक उदाहरण दिया गया है।
</details>

<details>
<summary><strong>अधिक उदाहरण</strong></summary>

- वाक्य युग्म वर्गीकरण मॉडलों पर हमला। एकल वाक्य वर्गीकरण मॉडलों के अलावा, OpenAttack वाक्य युग्म वर्गीकरण मॉडलों के विरुद्ध हमलों का समर्थन करता है। [यहाँ](https://github.com/thunlp/openattack/blob/HEAD/examples/nli_attack.py) OpenAttack के साथ एक NLI मॉडल के विरुद्ध प्रतिकूल हमले करने का उदाहरण कोड है।

- अनुकूलित मूल्यांकन मीट्रिक। OpenAttack एक अनुकूलित प्रतिकूल हमला मूल्यांकन मीट्रिक डिजाइन करने का समर्थन करता है। [यहाँ](https://github.com/thunlp/openattack/blob/HEAD/examples/custom_eval.py) एक अनुकूलित मूल्यांकन मीट्रिक जोड़ने और उसका उपयोग प्रतिकूल हमलों का मूल्यांकन करने के लिए करने का उदाहरण दिया गया है।


</details>

## आक्रमण मॉडल

मूल इनपुट पर लगाए गए व्यवधानों के स्तर के अनुसार, पाठ्य प्रतिकूल आक्रमण मॉडलों को वाक्य-स्तर, शब्द-स्तर, वर्ण-स्तर आक्रमण मॉडलों में वर्गीकृत किया जा सकता है। 

पीड़ित मॉडल तक पहुंच के अनुसार, पाठ्य प्रतिकूल आक्रमण मॉडलों को `gradient`-आधारित, `score`-आधारित, `decision`-आधारित और `blind` आक्रमण मॉडलों में वर्गीकृत किया जा सकता है।

> [TAADPapers](https://github.com/thunlp/TAADpapers) एक पेपर सूची है जो पाठ्य प्रतिकूल आक्रमण और बचाव से संबंधित लगभग सभी पेपरों का सारांश प्रस्तुत करती है। आप अधिक आक्रमण मॉडल खोजने के लिए इस सूची को देख सकते हैं।

वर्तमान में OpenAttack में पाठ वर्गीकरण मॉडलों के विरुद्ध 15 विशिष्ट आक्रमण मॉडल शामिल हैं जो **सभी** आक्रमण प्रकारों को कवर करते हैं। 

यहाँ वर्तमान में शामिल आक्रमण मॉडलों की सूची है।

- Sentence-level
  - (SEA) **Semantically Equivalent Adversarial Rules for Debugging NLP Models**. *Marco Tulio Ribeiro, Sameer Singh, Carlos Guestrin*. ACL 2018. `decision` [[pdf](https://aclweb.org/anthology/P18-1079)] [[code](https://github.com/marcotcr/sears)]
  - (SCPN) **Adversarial Example Generation with Syntactically Controlled Paraphrase Networks**. *Mohit Iyyer, John Wieting, Kevin Gimpel, Luke Zettlemoyer*. NAACL-HLT 2018. `blind` [[pdf](https://www.aclweb.org/anthology/N18-1170)] [[code&data](https://github.com/miyyer/scpn)]
  - (GAN) **Generating Natural Adversarial Examples**. *Zhengli Zhao, Dheeru Dua, Sameer Singh*. ICLR 2018. `decision` [[pdf](https://arxiv.org/pdf/1710.11342.pdf)] [[code](https://github.com/zhengliz/natural-adversary)]
- Word-level
  - (TextFooler) **Is BERT Really Robust? A Strong Baseline for Natural Language Attack on Text Classification and Entailment**. *Di Jin, Zhijing Jin, Joey Tianyi Zhou, Peter Szolovits*. AAAI-20. `score` [[pdf](https://arxiv.org/pdf/1907.11932v4)] [[code](https://github.com/wqj111186/TextFooler)]
  - (PWWS) **Generating Natural Language Adversarial Examples through Probability Weighted Word Saliency**. *Shuhuai Ren, Yihe Deng, Kun He, Wanxiang Che*. ACL 2019. `score` [[pdf](https://www.aclweb.org/anthology/P19-1103.pdf)] [[code](https://github.com/JHL-HUST/PWWS/)]
  - (Genetic) **Generating Natural Language Adversarial Examples**. *Moustafa Alzantot, Yash Sharma, Ahmed Elgohary, Bo-Jhang Ho, Mani Srivastava, Kai-Wei Chang*. EMNLP 2018. `score` [[pdf](https://www.aclweb.org/anthology/D18-1316)] [[code](https://github.com/nesl/nlp_adversarial_examples)]
  - (SememePSO) **Word-level Textual Adversarial Attacking as Combinatorial Optimization**. *Yuan Zang, Fanchao Qi, Chenghao Yang, Zhiyuan Liu, Meng Zhang, Qun Liu and Maosong Sun*. ACL 2020. `score` [[pdf](https://www.aclweb.org/anthology/2020.acl-main.540.pdf)] [[code](https://github.com/thunlp/SememePSO-Attack)]
  - (BERT-ATTACK) **BERT-ATTACK: Adversarial Attack Against BERT Using BERT**. *Linyang Li, Ruotian Ma, Qipeng Guo, Xiangyang Xue, Xipeng Qiu*. EMNLP 2020. `score` [[pdf](https://www.aclweb.org/anthology/2020.emnlp-main.500.pdf)] [[code](https://github.com/LinyangLee/BERT-Attack)]
  - (BAE) **BAE: BERT-based Adversarial Examples for Text Classification**. *Siddhant Garg, Goutham Ramakrishnan. EMNLP 2020*. `score` [[pdf](https://www.aclweb.org/anthology/2020.emnlp-main.498.pdf)] [[code](https://github.com/QData/TextAttack/blob/master/textattack/attack_recipes/bae_garg_2019.py)]
  - (FD) **Crafting Adversarial Input Sequences For Recurrent Neural Networks**. *Nicolas Papernot, Patrick McDaniel, Ananthram Swami, Richard Harang*. MILCOM 2016. `gradient` [[pdf](https://arxiv.org/pdf/1604.08275.pdf)]
- Word/Char-level
  - (TextBugger) **TEXTBUGGER: Generating Adversarial Text Against Real-world Applications**. *Jinfeng Li, Shouling Ji, Tianyu Du, Bo Li, Ting Wang*. NDSS 2019. `gradient` `score` [[pdf](https://arxiv.org/pdf/1812.05271.pdf)]
  - (UAT) **Universal Adversarial Triggers for Attacking and Analyzing NLP.** *Eric Wallace, Shi Feng, Nikhil Kandpal, Matt Gardner, Sameer Singh*. EMNLP-IJCNLP 2019. `gradient` [[pdf](https://arxiv.org/pdf/1908.07125.pdf)] [[code](https://github.com/Eric-Wallace/universal-triggers)] [[website](http://www.ericswallace.com/triggers)]
  - (HotFlip) **HotFlip: White-Box Adversarial Examples for Text Classification**. *Javid Ebrahimi, Anyi Rao, Daniel Lowd, Dejing Dou*. ACL 2018. `gradient` [[pdf](https://www.aclweb.org/anthology/P18-2006)] [[code](https://github.com/AnyiRao/WordAdver)]
- Char-level
  - (VIPER) **Text Processing Like Humans Do: Visually Attacking and Shielding NLP Systems**. *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. `score` [[pdf](https://www.aclweb.org/anthology/N19-1165)] [[code&data](https://github.com/UKPLab/naacl2019-like-humans-visual-attacks)]
  - (DeepWordBug) **Black-box Generation of Adversarial Text Sequences to Evade Deep Learning Classifiers**. *Ji Gao, Jack Lanchantin, Mary Lou Soffa, Yanjun Qi*. IEEE SPW 2018. `score` [[pdf](https://ieeexplore.ieee.org/document/8424632)] [[code](https://github.com/QData/deepWordBug)]

निम्नलिखित तालिका आक्रमण मॉडलों की तुलना दर्शाती है।

|    मॉडल    |  पहुंच  | व्यवधान | मुख्य विचार                                           |
| :---------: | :-------------: | :----------: | :-------------------------------------------------- |
|     SEA     |    निर्णय     |   वाक्य   | नियम-आधारित पैराफ्रेज़िंग                             |
|    SCPN     |      ब्लाइंड      |   वाक्य   | पैराफ्रेज़िंग                                        |
|     GAN     |    निर्णय     |   वाक्य   | एन्कोडर-डिकोडर द्वारा पाठ निर्माण                  |
| TextFooler  |      स्कोर      |     शब्द     | लालची शब्द प्रतिस्थापन                            |
|    PWWS     |      स्कोर      |     शब्द     | लालची शब्द प्रतिस्थापन                            |
|   Genetic   |      स्कोर      |     शब्द     | आनुवंशिक एल्गोरिथम-आधारित शब्द प्रतिस्थापन           |
|  SememePSO  |      स्कोर      |     शब्द     | कण झुंड अनुकूलन-आधारित शब्द प्रतिस्थापन |
|  BERT-ATTACK  |      स्कोर      |     शब्द     | लालची संदर्भित शब्द प्रतिस्थापन |
|  BAE  |      स्कोर      |     शब्द     | लालची संदर्भित शब्द प्रतिस्थापन और सम्मिलन |
|     FD      |    ग्रेडिएंट     |     शब्द     | ग्रेडिएंट-आधारित शब्द प्रतिस्थापन                    |
| TextBugger  | ग्रेडिएंट, स्कोर |  शब्द+वर्ण   | लालची शब्द प्रतिस्थापन और वर्ण हेरफेर |
|     UAT     |    ग्रेडिएंट     |  शब्द, वर्ण  | ग्रेडिएंट-आधारित शब्द या वर्ण हेरफेर       |
|   HotFlip   |    ग्रेडिएंट     |  शब्द, वर्ण  | ग्रेडिएंट-आधारित शब्द या वर्ण प्रतिस्थापन       |
|    VIPER    |      ब्लाइंड      |     वर्ण     | दृष्टिगत समान वर्ण प्रतिस्थापन             |
| DeepWordBug |      स्कोर      |     वर्ण     | लालची वर्ण हेरफेर                       |

## टूलकिट डिज़ाइन

विभिन्न आक्रमण मॉडलों के बीच महत्वपूर्ण अंतरों को ध्यान में रखते हुए, हम आक्रमण मॉडलों के कंकाल डिज़ाइन के लिए काफी स्वतंत्रता छोड़ते हैं, और प्रतिकूल हमले की सामान्य प्रक्रिया और आक्रमण मॉडलों में उपयोग किए जाने वाले सामान्य घटकों को सुव्यवस्थित करने पर अधिक ध्यान केंद्रित करते हैं।

OpenAttack में 7 मुख्य मॉड्यूल हैं: 

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

* **TextProcessor**: आक्रमण मॉडलों को प्रतिकूल उदाहरण उत्पन्न करने में सहायता करने के लिए मूल पाठ अनुक्रम को संसाधित करना;
* **Victim**: पीड़ित मॉडलों को लपेटना;
* **Attacker**: विभिन्न आक्रमण मॉडलों को शामिल करना;
* **AttackAssist**: विभिन्न शब्द/वर्ण प्रतिस्थापन विधियों को पैकेज करना जो शब्द-/वर्ण-स्तर आक्रमण मॉडलों में उपयोग की जाती हैं और कुछ अन्य घटक जो वाक्य-स्तर आक्रमण मॉडलों में उपयोग किए जाते हैं जैसे पैराफ्रेज़िंग मॉडल;
* **Metric**: कई प्रतिकूल उदाहरण गुणवत्ता मीट्रिक प्रदान करना जो हमले के दौरान प्रतिकूल उदाहरणों पर बाधाओं के रूप में या प्रतिकूल हमलों का मूल्यांकन करने के लिए मूल्यांकन मीट्रिक के रूप में काम कर सकते हैं;
* **AttackEval**: आक्रमण प्रभावशीलता, प्रतिकूल उदाहरण गुणवत्ता और आक्रमण दक्षता से पाठ्य प्रतिकूल हमलों का मूल्यांकन करना;
* **DataManager**: अन्य मॉड्यूलों में उपयोग किए जाने वाले सभी डेटा और सहेजे गए मॉडलों का प्रबंधन करना।

## उद्धरण

कृपया हमारे [पेपर](https://aclanthology.org/2021.acl-demo.43.pdf) का हवाला दें यदि आप इस टूलकिट का उपयोग करते हैं:```
@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

सबसे लोकप्रिय

योगदानकर्ता