Spaces:
Running
Running
File size: 5,252 Bytes
63775f2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
"""
TextAttack Constraint Class
=====================================
"""
from abc import ABC, abstractmethod
import textattack
from textattack.shared.utils import ReprMixin
class Constraint(ReprMixin, ABC):
"""An abstract class that represents constraints on adversial text
examples. Constraints evaluate whether transformations from a
``AttackedText`` to another ``AttackedText`` meet certain conditions.
Args:
compare_against_original (bool): If `True`, the reference text should be the original text under attack.
If `False`, the reference text is the most recent text from which the transformed text was generated.
All constraints must have this attribute.
"""
def __init__(self, compare_against_original):
self.compare_against_original = compare_against_original
def call_many(self, transformed_texts, reference_text):
"""Filters ``transformed_texts`` based on which transformations fulfill
the constraint. First checks compatibility with latest
``Transformation``, then calls ``_check_constraint_many``
Args:
transformed_texts (list[AttackedText]): The candidate transformed ``AttackedText``'s.
reference_text (AttackedText): The ``AttackedText`` to compare against.
"""
incompatible_transformed_texts = []
compatible_transformed_texts = []
for transformed_text in transformed_texts:
try:
if self.check_compatibility(
transformed_text.attack_attrs["last_transformation"]
):
compatible_transformed_texts.append(transformed_text)
else:
incompatible_transformed_texts.append(transformed_text)
except KeyError:
raise KeyError(
"transformed_text must have `last_transformation` attack_attr to apply constraint"
)
filtered_texts = self._check_constraint_many(
compatible_transformed_texts, reference_text
)
return list(filtered_texts) + incompatible_transformed_texts
def _check_constraint_many(self, transformed_texts, reference_text):
"""Filters ``transformed_texts`` based on which transformations fulfill
the constraint. Calls ``check_constraint``
Args:
transformed_texts (list[AttackedText]): The candidate transformed ``AttackedText``
reference_texts (AttackedText): The ``AttackedText`` to compare against.
"""
return [
transformed_text
for transformed_text in transformed_texts
if self._check_constraint(transformed_text, reference_text)
]
def __call__(self, transformed_text, reference_text):
"""Returns True if the constraint is fulfilled, False otherwise. First
checks compatibility with latest ``Transformation``, then calls
``_check_constraint``
Args:
transformed_text (AttackedText): The candidate transformed ``AttackedText``.
reference_text (AttackedText): The ``AttackedText`` to compare against.
"""
if not isinstance(transformed_text, textattack.shared.AttackedText):
raise TypeError("transformed_text must be of type AttackedText")
if not isinstance(reference_text, textattack.shared.AttackedText):
raise TypeError("reference_text must be of type AttackedText")
try:
if not self.check_compatibility(
transformed_text.attack_attrs["last_transformation"]
):
return True
except KeyError:
raise KeyError(
"`transformed_text` must have `last_transformation` attack_attr to apply constraint."
)
return self._check_constraint(transformed_text, reference_text)
@abstractmethod
def _check_constraint(self, transformed_text, reference_text):
"""Returns True if the constraint is fulfilled, False otherwise. Must
be overridden by the specific constraint.
Args:
transformed_text: The candidate transformed ``AttackedText``.
reference_text (AttackedText): The ``AttackedText`` to compare against.
"""
raise NotImplementedError()
def check_compatibility(self, transformation):
"""Checks if this constraint is compatible with the given
transformation. For example, the ``WordEmbeddingDistance`` constraint
compares the embedding of the word inserted with that of the word
deleted. Therefore it can only be applied in the case of word swaps,
and not for transformations which involve only one of insertion or
deletion.
Args:
transformation: The ``Transformation`` to check compatibility with.
"""
return True
def extra_repr_keys(self):
"""Set the extra representation of the constraint using these keys.
To print customized extra information, you should reimplement
this method in your own constraint. Both single-line and multi-
line strings are acceptable.
"""
return ["compare_against_original"]
|