random_one for imperceptible word swaps

Author: vlwk

textattack/transformations/word_swaps/word_swap_deletions.py

@@ -6,6 +6,7 @@
 from .word_swap_differential_evolution import WordSwapDifferentialEvolution
 from typing import List, Tuple
 from textattack.shared import AttackedText
+import numpy as np
 
 class WordSwapDeletions(WordSwapDifferentialEvolution):
     """
@@ -16,11 +17,12 @@ class WordSwapDeletions(WordSwapDifferentialEvolution):
     https://arxiv.org/abs/2106.09898 
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, random_one=False, **kwargs):
         super().__init__(**kwargs)
         self.del_chr = chr(0x8)
         self.ins_chr_min = '!'
         self.ins_chr_max = '~'
+        self.random_one = random_one
 
     def _get_bounds(self, current_text: AttackedText, max_perturbs: int, _) -> List[Tuple[int, int]]:
         return [(-1, len(current_text.text) - 1), (ord(self.ins_chr_min), ord(self.ins_chr_max))] * max_perturbs
@@ -41,13 +43,26 @@ def apply_perturbation(self, current_text: AttackedText, perturbation_vector: Li
 
     def _get_replacement_words(self, word: str) -> List[str]:
         candidate_words = []
-        for i in range(len(word) + 1):  # +1 to allow insertions at the end too
-            for code_point in range(ord(self.ins_chr_min), ord(self.ins_chr_max) + 1):
-                insert_char = chr(code_point)
-                perturbed = (
-                    word[:i] + insert_char + self.del_chr + word[i:]
-                )
-                candidate_words.append(perturbed)
+        if self.random_one:
+            if len(word) == 0:
+                return []
+            i = np.random.randint(0, len(word) + 1)
+            rand_char = chr(np.random.randint(ord(self.ins_chr_min), ord(self.ins_chr_max) + 1))
+            perturbed = word[:i] + rand_char + self.del_chr + word[i:]
+            candidate_words.append(perturbed)
+        else:
+            for i in range(len(word) + 1):  # +1 to allow insertions at the end
+                for code_point in range(ord(self.ins_chr_min), ord(self.ins_chr_max) + 1):
+                    insert_char = chr(code_point)
+                    perturbed = word[:i] + insert_char + self.del_chr + word[i:]
+                    candidate_words.append(perturbed)
         return candidate_words
 
+    @property
+    def deterministic(self):
+        return not self.random_one
+    
+    def extra_repr_keys(self):
+        return super().extra_repr_keys()
+
 

textattack/transformations/word_swaps/word_swap_invisible_characters.py

@@ -7,6 +7,7 @@
 from typing import List, Tuple
 from textattack.shared import AttackedText
 import random
+import numpy as np
 
 class WordSwapInvisibleCharacters(WordSwapDifferentialEvolution):
     """
@@ -17,9 +18,10 @@ class WordSwapInvisibleCharacters(WordSwapDifferentialEvolution):
     https://arxiv.org/abs/2106.09898 
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, random_one=False, **kwargs):
         super().__init__(**kwargs)
         self.invisible_chars = ["\u200B", "\u200C", "\u200D"]
+        self.random_one = random_one
 
     def _get_bounds(self, current_text: AttackedText, max_perturbs: int, _) -> List[Tuple[int, int]]:
         return [(0, len(self.invisible_chars) - 1), (-1, len(current_text.text) - 1)] * max_perturbs
@@ -39,8 +41,23 @@ def apply_perturbation(self, current_text: AttackedText, perturbation_vector: Li
 
     def _get_replacement_words(self, word: str) -> List[str]:
         candidate_words = []
-        for i in range(1, len(word)):  
-            for inv_char in self.invisible_chars:
-                new_word = word[:i] + inv_char + word[i:]
-                candidate_words.append(new_word)
+        if self.random_one:
+            if len(word) <= 1:
+                return []
+            i = np.random.randint(1, len(word))  # insert between characters
+            inv_char = np.random.choice(self.invisible_chars)
+            new_word = word[:i] + inv_char + word[i:]
+            candidate_words.append(new_word)
+        else:
+            for i in range(1, len(word)):  # start at 1 to avoid invisible prefix
+                for inv_char in self.invisible_chars:
+                    new_word = word[:i] + inv_char + word[i:]
+                    candidate_words.append(new_word)
         return candidate_words
+
+    @property
+    def deterministic(self):
+        return not self.random_one
+    
+    def extra_repr_keys(self):
+        return super().extra_repr_keys()

textattack/transformations/word_swaps/word_swap_reorderings.py

@@ -8,6 +8,7 @@
 from typing import List, Tuple, Union
 from textattack.shared import AttackedText
 from dataclasses import dataclass
+import numpy as np
 
 class WordSwapReorderings(WordSwapDifferentialEvolution):
     """
@@ -17,7 +18,7 @@ class WordSwapReorderings(WordSwapDifferentialEvolution):
     https://arxiv.org/abs/2106.09898 
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, random_one=False, **kwargs):
         super().__init__(**kwargs)
         self.PDF = chr(0x202C)
         self.LRE = chr(0x202A)
@@ -27,6 +28,7 @@ def __init__(self, **kwargs):
         self.PDI = chr(0x2069)
         self.LRI = chr(0x2066)
         self.RLI = chr(0x2067)
+        self.random_one = random_one
 
     @dataclass(eq=True, repr=True)
     class _Swap:
@@ -68,9 +70,27 @@ def apply_perturbation(self, current_text: AttackedText, perturbation_vector: Li
     def _get_replacement_words(self, word: str) -> List[str]:
         candidate_words = []
         chars = list(word)
-        for i in range(len(chars) - 1):
+
+        if self.random_one:
+            if len(chars) < 2:
+                return []
+            i = np.random.randint(0, len(chars) - 1)
             perturbed = chars[:]
             perturbed[i:i+2] = [self._Swap(chars[i+1], chars[i])]
             transformed = self._apply_swaps(perturbed)
             candidate_words.append(transformed)
-        return candidate_words
+        else:
+            for i in range(len(chars) - 1):
+                perturbed = chars[:]
+                perturbed[i:i+2] = [self._Swap(chars[i+1], chars[i])]
+                transformed = self._apply_swaps(perturbed)
+                candidate_words.append(transformed)
+
+        return candidate_words
+    
+    @property
+    def deterministic(self):
+        return not self.random_one
+    
+    def extra_repr_keys(self):
+        return super().extra_repr_keys()