def check_compatibility(self, transformation):
"""The stopword constraint only is concerned with word swaps since
paraphrasing phrases containing stopwords is OK.
Args:
transformation: The ``Transformation`` to check compatibility with.
"""
return transformation_consists_of_word_swaps(transformation)
def _perform_search(self, initial_result):
#print(initial_result.attacked_text)
modifiable_indices = get_modifiable_indices(
initial_result.attacked_text, self.pre_transformation_constraints)
#print(modifiable_indices)
cur_text = initial_result.attacked_text
cur_result = initial_result
for index in modifiable_indices:
if cur_text.words[index] in self.freq_dict:
continue
#print("WORD INDEX")
#print(index)
transformed_text_candidates = self.get_transformations(
cur_text,
original_text=initial_result.attacked_text,
indices_to_modify=[index])
#print("CANDIDATES")
#print(transformed_text_candidates)
transformed_text_candidates = Union(transformed_text_candidates[0],
transformed_text_candidates[1])
#print("Union CANDIDATES")
#print(transformed_text_candidates)
if len(transformed_text_candidates) is 0:
#print("NO TRANSFORMATION FOUND")
continue
random_choice = np.random.choice(transformed_text_candidates)
if random_choice.words[index] not in self.freq_dict:
continue
else:
cur_text = random_choice
results = self.get_goal_results([cur_text])
cur_result = results[0][0]
return cur_result
def check_transformation_compatibility(self, transformation):
"""The genetic algorithm is specifically designed for word
substitutions."""
return transformation_consists_of_word_swaps(transformation)
def _perform_search(self, initial_result):
modifiable_indices = get_modifiable_indices(initial_result.attacked_text,self.pre_transformation_constraints )
#not_tried_modifiable_indices = modifiable_indices
cur_result = initial_result
if len(modifiable_indices) is 0:
return cur_result
while not cur_result.goal_status == GoalFunctionResultStatus.SUCCEEDED:
random_choice = np.random.choice(list(modifiable_indices))
transformed_text_candidates = self.get_transformations(
cur_result.attacked_text,
original_text=initial_result.attacked_text,
indices_to_modify=[random_choice]
)
if len(transformed_text_candidates) is 0:
return cur_result
results, search_over = self.get_goal_results(transformed_text_candidates)
#print([r.attacked_text for r in results])
#print([r.score for r in results])
results = sorted(results, key=lambda x: -x.score)
#print([r.score for r in results])
# Skip swaps which don't improve the score
if results[0].score > cur_result.score:
cur_result = results[0]
else:
return cur_result
modifiable_indices = get_modifiable_indices(cur_result.attacked_text,self.pre_transformation_constraints)
if len(modifiable_indices) is 0:
return cur_result
return cur_result
def check_transformation_compatibility(self, transformation):
"""The genetic algorithm is specifically designed for word
substitutions."""
return transformation_consists_of_word_swaps(transformation)
def check_transformation_compatibility(self, transformation):
"""The genetic algorithm is specifically designed for word
substitutions."""
return transformation_consists_of_word_swaps(transformation)
def check_transformation_compatibility(self, transformation):
"""
Since it ranks words by their importance, GreedyWordSwapWIR is limited to word swaps transformations.
"""
return transformation_consists_of_word_swaps(transformation)
def check_compatibility(self, transformation):
return transformation_consists_of_word_swaps(transformation)
def check_compatibility(self, transformation):
"""
WordEmbeddingDistance requires a word being both deleted and inserted at the same index
in order to compare their embeddings, therefore it's restricted to word swaps.
"""
return transformation_consists_of_word_swaps(transformation)
def _perform_search(self, initial_result):
print('Try loading Multi nli training Corpus')
freq_dict = corpus.load_csv('../multi_nli_train_word_freq.csv')
modifiable_indices = get_modifiable_indices(
initial_result.attacked_text, self.pre_transformation_constraints)
try_indices = set()
cur_result = initial_result
if len(modifiable_indices) is 0:
return cur_result
while not cur_result.goal_status == GoalFunctionResultStatus.SUCCEEDED:
random_choice = np.random.choice(list(modifiable_indices))
transformed_text_candidates = self.get_transformations(
cur_result.attacked_text,
original_text=initial_result.attacked_text,
indices_to_modify=[random_choice])
transformed_text_candidates = Union(transformed_text_candidates[0],
transformed_text_candidates[1])
if len(transformed_text_candidates) is 0:
return cur_result
frequencies = get_word_frequencies(transformed_text_candidates,
freq_dict, random_choice)
lowest_freq = np.argmin(frequencies)
try_indices.add(random_choice)
results = self.get_goal_results(
[transformed_text_candidates[lowest_freq]])
if self.type == 'R':
cur_result = results[0][0]
elif self.type == 'P':
cur_score = results[0][0].score
if cur_score > initial_result.score:
cur_result = results[0][0]
'''
else:
frequencies.remove(lowest_freq)
transformed_text_candidates.remove(lowest_freq)
while len(frequencies) > 0:
lowest_freq = np.argmin(frequencies)
print("FREQUENCIES")
print(frequencies)
print("LOWEST")
print(lowest_freq)
results = self.get_goal_results([transformed_text_candidates[lowest_freq]])
cur_score = results[0][0].score
print("CUR SCORE")
print(cur_score)
if cur_score > initial_result.score:
cur_result = results[0][0]
print("SUCCESS")
break
'''
else:
raise ValueError(
'Type must be either P or R for frequency search')
modifiable_indices = get_modifiable_indices(
cur_result.attacked_text, self.pre_transformation_constraints)
modifiable_indices = modifiable_indices - try_indices
if len(modifiable_indices) is 0:
return cur_result
return cur_result
def check_transformation_compatibility(self, transformation):
"""The genetic algorithm is specifically designed for word
substitutions."""
return transformation_consists_of_word_swaps(transformation)
def _perform_search(self, initial_result):
#print(initial_result.attacked_text)
modifiable_indices = get_modifiable_indices(
initial_result.attacked_text, self.pre_transformation_constraints)
#print(modifiable_indices)
cur_text = initial_result.attacked_text
cur_result = initial_result
for index in modifiable_indices:
word_freq = get_word_phi(initial_result.attacked_text.words[index],
self.freq_dict)
#print("WORD INDEX")
#print(index)
transformed_text_candidates = self.get_transformations(
cur_text,
original_text=initial_result.attacked_text,
indices_to_modify=[index])
#print("CANDIDATES")
#print(transformed_text_candidates)
transformed_text_candidates = Union(transformed_text_candidates[0],
transformed_text_candidates[1])
#print("Union CANDIDATES")
#print(transformed_text_candidates)
if len(transformed_text_candidates) is 0:
#print("NO TRANSFORMATION FOUND")
continue
frequencies = [
get_word_phi(candidate.words[index], self.freq_dict)
for candidate in transformed_text_candidates
]
#print("Frequncies ")
#print(frequencies)
max_freq = np.argmax(frequencies)
#print("Max Frequency")
#print(max_freq)
if max_freq < word_freq:
#print("Frequency is not better")
continue
else:
cur_text = transformed_text_candidates[max_freq]
results = self.get_goal_results([cur_text])
cur_result = results[0][0]
if self.type == 'continuous':
cur_score = results[0][0].score
if cur_score - initial_result.score > self.gamma:
# Make sure that status is changed
cur_result.goal_status = GoalFunctionResultStatus.SUCCEEDED
else:
cur_result.goal_status = GoalFunctionResultStatus.SEARCHING
else:
if not self.type == 'discrete':
raise ValueError('Type must be either discrete or continuous')
return cur_result
def check_transformation_compatibility(self, transformation):
"""The genetic algorithm is specifically designed for word
substitutions."""
return transformation_consists_of_word_swaps(transformation)
