".format(html_style_from_dict(style_dict))
else:
table_html = "
"
# Print the title string.
@@ -78,6 +78,8 @@ def load_textattack_model_from_path(model_name, model_path):
model = textattack.models.helpers.BERTForClassification(
model_path=model_path, num_labels=num_labels
)
+ elif model_name.startswith("t5"):
+ model = textattack.models.helpers.T5ForTextToText(model_path)
else:
raise ValueError(f"Unknown textattack model {model_path}")
return model
diff --git a/textattack/shared/utils/strings.py b/textattack/shared/utils/strings.py
index 359fedcd..9466641a 100644
--- a/textattack/shared/utils/strings.py
+++ b/textattack/shared/utils/strings.py
@@ -1,11 +1,17 @@
def has_letter(word):
- """ Returns true if `word` contains at least one character in [A-Za-z]. """
+ """ Returns true if `word` contains at least one character in [A-Za-z].
+ """
+ # TODO implement w regex
for c in word:
if c.isalpha():
return True
return False
+def is_one_word(word):
+ return len(words_from_text(word)) == 1
+
+
def add_indent(s_, numSpaces):
s = s_.split("\n")
# don't do anything for single-line stuff
@@ -21,10 +27,15 @@ def add_indent(s_, numSpaces):
def words_from_text(s, words_to_ignore=[]):
""" Lowercases a string, removes all non-alphanumeric characters,
and splits into words. """
+ # TODO implement w regex
words = []
word = ""
for c in " ".join(s.split()):
- if c.isalpha():
+ if c.isalnum():
+ word += c
+ elif c in "'-" and len(word) > 0:
+ # Allow apostrophes and hyphens as long as they don't begin the
+ # word.
word += c
elif word:
if word not in words_to_ignore:
diff --git a/textattack/shared/validators.py b/textattack/shared/validators.py
index 0347be1e..612c3ff7 100644
--- a/textattack/shared/validators.py
+++ b/textattack/shared/validators.py
@@ -8,7 +8,7 @@ from . import logger
# A list of goal functions and the corresponding available models.
MODELS_BY_GOAL_FUNCTIONS = {
- (TargetedClassification, UntargetedClassification): [
+ (TargetedClassification, UntargetedClassification, InputReduction): [
r"^textattack.models.classification.*",
r"^textattack.models.entailment.*",
r"^transformers.modeling_\w*\.\w*ForSequenceClassification$",
@@ -108,3 +108,14 @@ def transformation_consists_of_word_swaps(transformation):
from textattack.transformations import WordSwap, WordSwapGradientBased
return transformation_consists_of(transformation, [WordSwap, WordSwapGradientBased])
+
+
+def transformation_consists_of_word_swaps_and_deletions(transformation):
+ """
+ Determines if ``transformation`` is a word swap or consists of only word swaps and deletions.
+ """
+ from textattack.transformations import WordDeletion, WordSwap, WordSwapGradientBased
+
+ return transformation_consists_of(
+ transformation, [WordDeletion, WordSwap, WordSwapGradientBased]
+ )
diff --git a/textattack/shared/word_embedding.py b/textattack/shared/word_embedding.py
index 2c34a392..cdd553a4 100644
--- a/textattack/shared/word_embedding.py
+++ b/textattack/shared/word_embedding.py
@@ -24,7 +24,7 @@ class WordEmbedding:
mse_dist_file = "mse_dist.p"
cos_sim_file = "cos_sim.p"
else:
- raise ValueError(f"Could not find word embedding {word_embedding}")
+ raise ValueError(f"Could not find word embedding {embedding_type}")
# Download embeddings if they're not cached.
word_embeddings_root_path = textattack.shared.utils.download_if_needed(
diff --git a/textattack/transformations/__init__.py b/textattack/transformations/__init__.py
index e9c20c9c..368c2aa2 100644
--- a/textattack/transformations/__init__.py
+++ b/textattack/transformations/__init__.py
@@ -5,6 +5,7 @@ from .word_swap import WordSwap
# Black-box transformations
from .word_deletion import WordDeletion
from .word_swap_embedding import WordSwapEmbedding
+from .word_swap_hownet import WordSwapHowNet
from .word_swap_homoglyph_swap import WordSwapHomoglyphSwap
from .word_swap_neighboring_character_swap import WordSwapNeighboringCharacterSwap
from .word_swap_random_character_deletion import WordSwapRandomCharacterDeletion
diff --git a/textattack/transformations/composite_transformation.py b/textattack/transformations/composite_transformation.py
index f0030627..fda8a089 100644
--- a/textattack/transformations/composite_transformation.py
+++ b/textattack/transformations/composite_transformation.py
@@ -21,6 +21,14 @@ class CompositeTransformation(Transformation):
raise ValueError("transformations cannot be empty")
self.transformations = transformations
+ def _get_transformations(self, *_):
+ """ Placeholder method that would throw an error if a user tried to
+ treat the CompositeTransformation as a 'normal' transformation.
+ """
+ raise RuntimeError(
+ "CompositeTransformation does not support _get_transformations()."
+ )
+
def __call__(self, *args, **kwargs):
new_attacked_texts = set()
for transformation in self.transformations:
diff --git a/textattack/transformations/transformation.py b/textattack/transformations/transformation.py
index 087708aa..b756a268 100644
--- a/textattack/transformations/transformation.py
+++ b/textattack/transformations/transformation.py
@@ -1,7 +1,9 @@
+from abc import ABC, abstractmethod
+
from textattack.shared.utils import default_class_repr
-class Transformation:
+class Transformation(ABC):
"""
An abstract class for transforming a sequence of text to produce
a potential adversarial example.
@@ -44,6 +46,7 @@ class Transformation:
text.attack_attrs["last_transformation"] = self
return transformed_texts
+ @abstractmethod
def _get_transformations(self, current_text, indices_to_modify):
"""
Returns a list of all possible transformations for ``current_text``, only modifying
diff --git a/textattack/transformations/word_swap_hownet.py b/textattack/transformations/word_swap_hownet.py
new file mode 100644
index 00000000..7a0b4bdc
--- /dev/null
+++ b/textattack/transformations/word_swap_hownet.py
@@ -0,0 +1,106 @@
+import pickle
+
+from flair.data import Sentence
+from flair.models import SequenceTagger
+
+from textattack.shared import utils
+from textattack.transformations.word_swap import WordSwap
+
+
+class WordSwapHowNet(WordSwap):
+ """ Transforms an input by replacing its words with synonyms in the stored synonyms bank
+ generated by the OpenHowNet. """
+
+ PATH = "transformations/hownet"
+
+ def __init__(self, max_candidates=-1, **kwargs):
+ super().__init__(**kwargs)
+ self.max_candidates = max_candidates
+
+ # Download synonym candidates bank if they're not cached.
+ cache_path = utils.download_if_needed(
+ "{}/{}".format(WordSwapHowNet.PATH, "word_candidates_sense.pkl")
+ )
+
+ # Actually load the files from disk.
+ with open(cache_path, "rb") as fp:
+ self.candidates_bank = pickle.load(fp)
+
+ self._flair_pos_tagger = SequenceTagger.load("pos-fast")
+ self.pos_dict = {"JJ": "adj", "NN": "noun", "RB": "adv", "VB": "verb"}
+
+ def _get_replacement_words(self, word, word_pos):
+ """ Returns a list of possible 'candidate words' to replace a word in a sentence
+ or phrase. Based on nearest neighbors selected word embeddings.
+ """
+ word_pos = self.pos_dict.get(word_pos, None)
+ if word_pos is None:
+ return []
+
+ try:
+ candidate_words = self.candidates_bank[word.lower()][word_pos]
+ if self.max_candidates > 0:
+ candidate_words = candidate_words[: self.max_candidates]
+ return [
+ recover_word_case(candidate_word, word)
+ for candidate_word in candidate_words
+ ]
+ except KeyError:
+ # This word is not in our synonym bank, so return an empty list.
+ return []
+
+ def _get_transformations(self, current_text, indices_to_modify):
+ words = current_text.words
+ words_str = " ".join(words)
+ word_list, pos_list = zip_flair_result(
+ self._flair_pos_tagger.predict(words_str)[0]
+ )
+ assert len(words) == len(
+ word_list
+ ), "Part-of-speech tagger returned incorrect number of tags"
+ transformed_texts = []
+
+ for i in indices_to_modify:
+ word_to_replace = words[i]
+ word_to_replace_pos = pos_list[i][:2] # get the root POS
+ replacement_words = self._get_replacement_words(
+ word_to_replace, word_to_replace_pos
+ )
+ transformed_texts_idx = []
+ for r in replacement_words:
+ transformed_texts_idx.append(current_text.replace_word_at_index(i, r))
+ transformed_texts.extend(transformed_texts_idx)
+
+ return transformed_texts
+
+ def extra_repr_keys(self):
+ return ["max_candidates"]
+
+
+def recover_word_case(word, reference_word):
+ """ Makes the case of `word` like the case of `reference_word`. Supports
+ lowercase, UPPERCASE, and Capitalized. """
+ if reference_word.islower():
+ return word.lower()
+ elif reference_word.isupper() and len(reference_word) > 1:
+ return word.upper()
+ elif reference_word[0].isupper() and reference_word[1:].islower():
+ return word.capitalize()
+ else:
+ # if other, just do not alter the word's case
+ return word
+
+
+def zip_flair_result(pred):
+ """Parse the output from the FLAIR POS tagger"""
+ if not isinstance(pred, Sentence):
+ raise TypeError(f"Result from Flair POS tagger must be a `Sentence` object.")
+
+ tokens = pred.tokens
+ word_list = []
+ pos_list = []
+ for token in tokens:
+ word_list.append(token.text)
+ pos_list.append(token.annotation_layers["pos"][0]._value)
+
+ return word_list, pos_list
diff --git a/textattack/transformations/word_swap_masked_lm.py b/textattack/transformations/word_swap_masked_lm.py
index 5e8fc2b6..d2c91047 100644
--- a/textattack/transformations/word_swap_masked_lm.py
+++ b/textattack/transformations/word_swap_masked_lm.py
@@ -58,7 +58,8 @@ class WordSwapMaskedLM(WordSwap):
encoding = self._lm_tokenizer.encode_plus(
text,
max_length=self.max_length,
- pad_to_max_length=True,
+ truncation=True,
+ padding="max_length",
return_tensors="pt",
)
return {k: v.to(utils.device) for k, v in encoding.items()}
@@ -93,7 +94,7 @@ class WordSwapMaskedLM(WordSwap):
replacement_words = []
for id in top_ids:
token = self._lm_tokenizer.convert_ids_to_tokens(id)
- if check_if_word(token):
+ if utils.is_one_word(token):
replacement_words.append(token)
return replacement_words
@@ -140,7 +141,7 @@ class WordSwapMaskedLM(WordSwap):
replacement_words = []
for id in top_preds:
token = self._lm_tokenizer.convert_ids_to_tokens(id)
- if check_if_word(token):
+ if utils.is_one_word(token):
replacement_words.append(token)
return replacement_words
else:
@@ -162,7 +163,7 @@ class WordSwapMaskedLM(WordSwap):
word = "".join(
self._lm_tokenizer.convert_ids_to_tokens(word_tensor)
).replace("##", "")
- if check_if_word(word):
+ if utils.is_one_word(word):
combination_results.append((word, perplexity))
# Sort to get top-K results
sorted(combination_results, key=lambda x: x[1])
@@ -228,10 +229,3 @@ def recover_word_case(word, reference_word):
else:
# if other, just do not alter the word's case
return word
-
-
-def check_if_word(word):
- for c in word:
- if not c.isalpha():
- return False
- return True
diff --git a/textattack/transformations/word_swap_wordnet.py b/textattack/transformations/word_swap_wordnet.py
index 38ddcadb..b5bdd17c 100644
--- a/textattack/transformations/word_swap_wordnet.py
+++ b/textattack/transformations/word_swap_wordnet.py
@@ -1,5 +1,6 @@
from nltk.corpus import wordnet
+import textattack
from textattack.transformations.word_swap import WordSwap
@@ -13,14 +14,12 @@ class WordSwapWordNet(WordSwap):
synonyms = set()
for syn in wordnet.synsets(word):
for l in syn.lemmas():
- if l.name() != word and check_if_one_word(l.name()):
+ syn_word = l.name()
+ if (
+ (syn_word != word)
+ and ("_" not in syn_word)
+ and (textattack.shared.utils.is_one_word(syn_word))
+ ):
# WordNet can suggest phrases that are joined by '_' but we ignore phrases.
- synonyms.add(l.name())
+ synonyms.add(syn_word)
return list(synonyms)
-
-
-def check_if_one_word(word):
- for c in word:
- if not c.isalpha():
- return False
- return True
+
## About
@@ -97,18 +97,19 @@ We include attack recipes which implement attacks from the literature. You can l
To run an attack recipe: `textattack attack --recipe [recipe_name]`
-These attacks are for classification tasks, like sentiment classification and entailment:
+Attacks on classification tasks, like sentiment classification and entailment:
- **alzantot**: Genetic algorithm attack from (["Generating Natural Language Adversarial Examples" (Alzantot et al., 2018)](https://arxiv.org/abs/1804.07998)).
- **bae**: BERT masked language model transformation attack from (["BAE: BERT-based Adversarial Examples for Text Classification" (Garg & Ramakrishnan, 2019)](https://arxiv.org/abs/2004.01970)).
- **bert-attack**: BERT masked language model transformation attack with subword replacements (["BERT-ATTACK: Adversarial Attack Against BERT Using BERT" (Li et al., 2020)](https://arxiv.org/abs/2004.09984)).
- **deepwordbug**: Greedy replace-1 scoring and multi-transformation character-swap attack (["Black-box Generation of Adversarial Text Sequences to Evade Deep Learning Classifiers" (Gao et al., 2018)](https://arxiv.org/abs/1801.04354)).
- **hotflip**: Beam search and gradient-based word swap (["HotFlip: White-Box Adversarial Examples for Text Classification" (Ebrahimi et al., 2017)](https://arxiv.org/abs/1712.06751)).
+- **input-reduction**: Reducing the input while maintaining the prediction through word importance ranking (["Pathologies of Neural Models Make Interpretation Difficult" (Feng et al., 2018)](https://arxiv.org/pdf/1804.07781.pdf)).
- **kuleshov**: Greedy search and counterfitted embedding swap (["Adversarial Examples for Natural Language Classification Problems" (Kuleshov et al., 2018)](https://openreview.net/pdf?id=r1QZ3zbAZ)).
- **pwws**: Greedy attack with word importance ranking based on word saliency and synonym swap scores (["Generating Natural Language Adversarial Examples through Probability Weighted Word Saliency" (Ren et al., 2019)](https://www.aclweb.org/anthology/P19-1103/)).
- **textbugger**: Greedy attack with word importance ranking and character-based swaps ([(["TextBugger: Generating Adversarial Text Against Real-world Applications" (Li et al., 2018)](https://arxiv.org/abs/1812.05271)).
- **textfooler**: Greedy attack with word importance ranking and counter-fitted embedding swap (["Is Bert Really Robust?" (Jin et al., 2019)](https://arxiv.org/abs/1907.11932)).
-The final is for sequence-to-sequence models:
+Attacks on sequence-to-sequence models:
- **seq2sick**: Greedy attack with goal of changing every word in the output translation. Currently implemented as black-box with plans to change to white-box as done in paper (["Seq2Sick: Evaluating the Robustness of Sequence-to-Sequence Models with Adversarial Examples" (Cheng et al., 2018)](https://arxiv.org/abs/1803.01128)).
#### Recipe Usage Examples
@@ -122,7 +123,7 @@ textattack attack --model bert-base-uncased-sst2 --recipe textfooler --num-examp
*seq2sick (black-box) against T5 fine-tuned for English-German translation:*
```bash
-textattack attack --recipe seq2sick --model t5-en2de --num-examples 100
+ textattack attack --model t5-en-de --recipe seq2sick --num-examples 100
```
### Augmenting Text
@@ -284,7 +285,7 @@ The `attack_one` method in an `Attack` takes as input an `AttackedText`, and out
### Goal Functions
-A `GoalFunction` takes as input an `AttackedText` object and the ground truth output, and determines whether the attack has succeeded, returning a `GoalFunctionResult`.
+A `GoalFunction` takes as input an `AttackedText` object, scores it, and determines whether the attack has succeeded, returning a `GoalFunctionResult`.
### Constraints
@@ -303,6 +304,8 @@ A `SearchMethod` takes as input an initial `GoalFunctionResult` and returns a fi
We welcome suggestions and contributions! Submit an issue or pull request and we will do our best to respond in a timely manner. TextAttack is currently in an "alpha" stage in which we are working to improve its capabilities and design.
+See [CONTRIBUTING.md](https://github.com/QData/TextAttack/blob/master/CONTRIBUTING.md) for detailed information on contributing.
+
## Citing TextAttack
If you use TextAttack for your research, please cite [TextAttack: A Framework for Adversarial Attacks in Natural Language Processing](https://arxiv.org/abs/2005.05909).
diff --git a/docs/attacks/attack_recipes.rst b/docs/attacks/attack_recipes.rst
index f53a349c..e1499532 100644
--- a/docs/attacks/attack_recipes.rst
+++ b/docs/attacks/attack_recipes.rst
@@ -6,67 +6,81 @@ We provide a number of pre-built attack recipes. To run an attack recipe, run::
textattack attack --recipe [recipe_name]
Alzantot Genetic Algorithm (Generating Natural Language Adversarial Examples)
-###########
+###################################################################################
.. automodule:: textattack.attack_recipes.genetic_algorithm_alzantot_2018
:members:
Faster Alzantot Genetic Algorithm (Certified Robustness to Adversarial Word Substitutions)
-###########
+##############################################################################################
.. automodule:: textattack.attack_recipes.faster_genetic_algorithm_jia_2019
:members:
BAE (BAE: BERT-Based Adversarial Examples)
-############
+#############################################
-.. automodule:: textattack.attack_recipes.deepwordbug_gao_2018
+.. automodule:: textattack.attack_recipes.bae_garg_2019
+ :members:
BERT-Attack: (BERT-Attack: Adversarial Attack Against BERT Using BERT)
-############
+#########################################################################
-.. automodule:: textattack.attack_recipes.deepwordbug_gao_2018
+.. automodule:: textattack.attack_recipes.bert_attack_li_2020
+ :members:
DeepWordBug (Black-box Generation of Adversarial Text Sequences to Evade Deep Learning Classifiers)
-############
+######################################################################################################
.. automodule:: textattack.attack_recipes.deepwordbug_gao_2018
:members:
HotFlip (HotFlip: White-Box Adversarial Examples for Text Classification)
-###########
+##############################################################################
+
+.. automodule:: textattack.attack_recipes.hotflip_ebrahimi_2017
+ :members:
+
+Input Reduction
+################
.. automodule:: textattack.attack_recipes.input_reduction_feng_2018
:members:
Kuleshov (Adversarial Examples for Natural Language Classification Problems)
-###########
+##############################################################################
.. automodule:: textattack.attack_recipes.kuleshov_2017
:members:
+Particle Swarm Optimization (Word-level Textual Adversarial Attacking as Combinatorial Optimization)
+#####################################################################################################
+
+.. automodule:: textattack.attack_recipes.PSO_zang_2020
+ :members:
+
PWWS (Generating Natural Language Adversarial Examples through Probability Weighted Word Saliency)
-###########
+###################################################################################################
.. automodule:: textattack.attack_recipes.pwws_ren_2019
:members:
Seq2Sick (Seq2Sick: Evaluating the Robustness of Sequence-to-Sequence Models with Adversarial Examples)
-###########
+#########################################################################################################
.. automodule:: textattack.attack_recipes.seq2sick_cheng_2018_blackbox
:members:
TextFooler (Is BERT Really Robust? A Strong Baseline for Natural Language Attack on Text Classification and Entailment)
-###########
+########################################################################################################################
.. automodule:: textattack.attack_recipes.textfooler_jin_2019
:members:
TextBugger (TextBugger: Generating Adversarial Text Against Real-world Applications)
-###########
+########################################################################################
.. automodule:: textattack.attack_recipes.textbugger_li_2018
:members:
diff --git a/docs/attacks/constraint.rst b/docs/attacks/constraint.rst
index 9af35f0d..db11f159 100644
--- a/docs/attacks/constraint.rst
+++ b/docs/attacks/constraint.rst
@@ -85,7 +85,7 @@ GPT-2
:members:
"Learning To Write" Language Model
-*******
+************************************
.. automodule:: textattack.constraints.grammaticality.language_models.learning_to_write.learning_to_write
:members:
@@ -142,7 +142,7 @@ Maximum Words Perturbed
.. _pre_transformation:
Pre-Transformation
-----------
+-------------------------
Pre-transformation constraints determine if a transformation is valid based on
only the original input and the position of the replacement. These constraints
@@ -151,7 +151,7 @@ constraints can prevent search methods from swapping words at the same index
twice, or from replacing stopwords.
Pre-Transformation Constraint
-########################
+###############################
.. automodule:: textattack.constraints.pre_transformation.pre_transformation_constraint
:special-members: __call__
:private-members:
@@ -166,3 +166,13 @@ Repeat Modification
########################
.. automodule:: textattack.constraints.pre_transformation.repeat_modification
:members:
+
+Input Column Modification
+#############################
+.. automodule:: textattack.constraints.pre_transformation.input_column_modification
+ :members:
+
+Max Word Index Modification
+###############################
+.. automodule:: textattack.constraints.pre_transformation.max_word_index_modification
+ :members:
diff --git a/docs/attacks/transformation.rst b/docs/attacks/transformation.rst
index d37f205a..b61a8eab 100644
--- a/docs/attacks/transformation.rst
+++ b/docs/attacks/transformation.rst
@@ -69,7 +69,7 @@ Word Swap by Random Character Insertion
:members:
Word Swap by Random Character Substitution
----------------------------------------
+-------------------------------------------
.. automodule:: textattack.transformations.word_swap_random_character_substitution
:members:
diff --git a/docs/conf.py b/docs/conf.py
index feb823ca..383855af 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -22,7 +22,7 @@ copyright = "2020, UVA QData Lab"
author = "UVA QData Lab"
# The full version, including alpha/beta/rc tags
-release = "0.1.2"
+release = "0.1.5"
# Set master doc to `index.rst`.
master_doc = "index"
diff --git a/docs/datasets_models/datasets.rst b/docs/datasets_models/datasets.rst
index bcd5b407..158d87d7 100644
--- a/docs/datasets_models/datasets.rst
+++ b/docs/datasets_models/datasets.rst
@@ -6,19 +6,10 @@ Datasets
:members:
:private-members:
-Classification
-###############
-.. automodule:: textattack.datasets.classification.classification_dataset
+.. automodule:: textattack.datasets.huggingface_nlp_dataset
:members:
-Entailment
-############
-.. automodule:: textattack.datasets.entailment.entailment_dataset
+.. automodule:: textattack.datasets.translation.ted_multi
:members:
-Translation
-#############
-.. automodule:: textattack.datasets.translation.translation_datasets
- :members:
-
diff --git a/docs/datasets_models/models.rst b/docs/datasets_models/models.rst
index 15bbeb45..e3069415 100644
--- a/docs/datasets_models/models.rst
+++ b/docs/datasets_models/models.rst
@@ -11,7 +11,7 @@ We split models up into two broad categories:
**Classification models:**
- :ref:`BERT`: ``bert-base-uncased`` fine-tuned on various datasets using transformers_.
+ :ref:`BERT`: ``bert-base-uncased`` fine-tuned on various datasets using ``transformers``.
:ref:`LSTM`: a standard LSTM fine-tuned on various datasets.
@@ -20,30 +20,29 @@ We split models up into two broad categories:
**Text-to-text models:**
- :ref:`T5`: ``T5`` fine-tuned on various datasets using transformers_.
+ :ref:`T5`: ``T5`` fine-tuned on various datasets using ``transformers``.
+.. _BERT:
BERT
********
-.. _BERT:
-
.. automodule:: textattack.models.helpers.bert_for_classification
:members:
-LSTM
-*******
.. _LSTM:
+LSTM
+*******
.. automodule:: textattack.models.helpers.lstm_for_classification
:members:
-Word-CNN
-************
.. _CNN:
+Word-CNN
+************
.. automodule:: textattack.models.helpers.word_cnn_for_classification
:members:
diff --git a/docs/examples/1_Introduction_and_Transformations.ipynb b/docs/examples/1_Introduction_and_Transformations.ipynb
index f39fb9b4..fb37db23 100644
--- a/docs/examples/1_Introduction_and_Transformations.ipynb
+++ b/docs/examples/1_Introduction_and_Transformations.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "# The TextAttack🐙 ecosystem: search, transformations, and constraints\n",
+ "# The TextAttack ecosystem: search, transformations, and constraints\n",
"\n",
"An attack in TextAttack consists of four parts.\n",
"\n",
@@ -31,9 +31,9 @@
"This lesson explains how to create a custom transformation. In TextAttack, many transformations involve *word swaps*: they take a word and try and find suitable substitutes. Some attacks focus on replacing characters with neighboring characters to create \"typos\" (these don't intend to preserve the grammaticality of inputs). Other attacks rely on semantics: they take a word and try to replace it with semantic equivalents.\n",
"\n",
"\n",
- "### Banana word swap 🍌\n",
+ "### Banana word swap \n",
"\n",
- "As an introduction to writing transformations for TextAttack, we're going to try a very simple transformation: one that replaces any given word with the word 'banana'. In TextAttack, there's an abstract `WordSwap` class that handles the heavy lifting of breaking sentences into words and avoiding replacement of stopwords. We can extend `WordSwap` and implement a single method, `_get_replacement_words`, to indicate to replace each word with 'banana'."
+ "As an introduction to writing transformations for TextAttack, we're going to try a very simple transformation: one that replaces any given word with the word 'banana'. In TextAttack, there's an abstract `WordSwap` class that handles the heavy lifting of breaking sentences into words and avoiding replacement of stopwords. We can extend `WordSwap` and implement a single method, `_get_replacement_words`, to indicate to replace each word with 'banana'. 🍌"
]
},
{
@@ -308,9 +308,9 @@
"collapsed": true
},
"source": [
- "### Conclusion 🍌\n",
+ "### Conclusion n",
"\n",
- "We can examine these examples for a good idea of how many words had to be changed to \"banana\" to change the prediction score from the correct class to another class. The examples without perturbed words were originally misclassified, so they were skipped by the attack. Looks like some examples needed only a single \"banana\", while others needed up to 17 \"banana\" substitutions to change the class score. Wow!"
+ "We can examine these examples for a good idea of how many words had to be changed to \"banana\" to change the prediction score from the correct class to another class. The examples without perturbed words were originally misclassified, so they were skipped by the attack. Looks like some examples needed only a couple \"banana\"s, while others needed up to 17 \"banana\" substitutions to change the class score. Wow! 🍌"
]
}
],
diff --git a/docs/index.rst b/docs/index.rst
index 52f88a92..c2abc5f4 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -35,7 +35,6 @@ TextAttack has some other features that make it a pleasure to use:
Installation