import random from textattack.search_methods import SearchMethod from textattack.goal_function_results import GoalFunctionResultStatus class GreedyMultipleGeneration(SearchMethod): def __init__( self, wir_method="delete", k=30, embed=None, file=None, rollback_level=3, naive=False, clust=None, train_file="train_file.csv", ): self.wir_method = wir_method self.k = k # maximum iterations self.embed = embed # universal sentence encoder self.file = file # similarity file to store the textual similarity self.naive = naive self.rollback_level = rollback_level self.successful_attacks = {} self.clust = clust def _get_index_order(self, initial_text, indices_to_order): """Returns word indices of ``initial_text`` in descending order of importance.""" if "unk" in self.wir_method: leave_one_texts = [ initial_text.replace_word_at_index(i, "[UNK]") for i in indices_to_order ] leave_one_results, search_over = self.get_goal_results(leave_one_texts) index_scores = np.array([result.score for result in leave_one_results]) elif "delete" in self.wir_method: leave_one_texts = [ initial_text.delete_word_at_index(i) for i in indices_to_order ] leave_one_results, search_over = self.get_goal_results(leave_one_texts) # print(f"leave_one_results : {leave_one_results}") # print(f"search_over : {search_over}") index_scores = np.array([result.score for result in leave_one_results]) elif "weighted-saliency" in self.wir_method: # first, compute word saliency leave_one_texts = [ initial_text.replace_word_at_index(i, "unk") for i in indices_to_order ] leave_one_results, search_over = self.get_goal_results(leave_one_texts) saliency_scores = np.array([result.score for result in leave_one_results]) softmax_saliency_scores = softmax( torch.Tensor(saliency_scores), dim=0 ).numpy() # compute the largest change in score we can find by swapping each word delta_ps = [] for idx in indices_to_order: # Exit Loop when search_over is True - but we need to make sure delta_ps # is the same size as softmax_saliency_scores if search_over: delta_ps = delta_ps + [0.0] * ( len(softmax_saliency_scores) - len(delta_ps) ) break transformed_text_candidates = self.get_transformations( initial_text, original_text=initial_text, indices_to_modify=[idx], ) if not transformed_text_candidates: # no valid synonym substitutions for this word delta_ps.append(0.0) continue swap_results, search_over = self.get_goal_results( transformed_text_candidates ) score_change = [result.score for result in swap_results] if not score_change: delta_ps.append(0.0) continue max_score_change = np.max(score_change) delta_ps.append(max_score_change) index_scores = softmax_saliency_scores * np.array(delta_ps) elif "gradient" in self.wir_method: victim_model = self.get_victim_model() index_scores = np.zeros(len(indices_to_order)) grad_output = victim_model.get_grad(initial_text.tokenizer_input) gradient = grad_output["gradient"] word2token_mapping = initial_text.align_with_model_tokens(victim_model) for i, index in enumerate(indices_to_order): matched_tokens = word2token_mapping[index] if not matched_tokens: index_scores[i] = 0.0 else: agg_grad = np.mean(gradient[matched_tokens], axis=0) index_scores[i] = np.linalg.norm(agg_grad, ord=1) search_over = False index_order = np.array(indices_to_order)[(-index_scores).argsort()] index_scores = sorted(index_scores, reverse=True) return index_order, search_over, index_scores # This present a rollback for reducing perturbation only def swap_to_origin(self, cur_result, initial_result, index): """Replace the chosen word with it origin a return a result instance""" new_attacked_text = cur_result.attacked_text.replace_word_at_index( index, initial_result.attacked_text.words[index] ) result, _ = self.get_goal_results([new_attacked_text]) return result[0] def check_synonym_validity( ind, ind_synonym, Synonym_indices, Current_attacked_Results, j, synonym ): """Checks if a synonym is valid for a given index in the attacked text. Args: ind: The index of the word in the attacked text. ind_synonym: The index of the synonym in the list of synonyms. Synonym_indices: A dictionary of synonym indices. Current_attacked_Results: A list of AttackedResult objects. j: The index of the current AttackedResult object in the list. synonym: The synonym to check. Returns: True if the synonym is valid, False otherwise.""" # Check if the synonym has already been chosen. if (ind, ind_synonym) in Synonym_indices: return False # Get the current attacked text and its words. current_attacked_text = Current_attacked_Results[j].attacked_text current_attacked_words = current_attacked_text.words # Check if the synonym is already present in the attacked text. if synonym in current_attacked_words[ind]: return False return True def generate_naive_attack(self, initial_result): curent_result = initial_result # dict of preturbed indexes with theire scores on on the original text perturbed_indexes = {} # possible synonyms of each index with theire scores on the original text to reduce avg num queries synonyms = {} # to track indexes with no transformation so we avoid recalculate them to reduce avg num queries non_usefull_indexes = [] attacked_text = initial_result.attacked_text _, indices_to_order = self.get_indices_to_order(attacked_text) # Sort words by order of importance index_order, search_over, _ = self._get_index_order( attacked_text, indices_to_order ) # iterate through words by theire importance for index in index_order: if search_over: break transformed_text_candidates = self.get_transformations( curent_result.attacked_text, original_text=initial_result.attacked_text, indices_to_modify=[index], ) if len(transformed_text_candidates) == 0: # track unusefull words to optimize the code . non_usefull_indexes.append(index) continue else: results, search_over = self.get_goal_results( transformed_text_candidates ) max_result = max(results, key=lambda x: x.score) if max_result.score > curent_result.score: if self.naive == False: # store perturbed indexes with theire score perturbed_indexes[index] = max_result.score - curent_result.score # add all synonyms except the one we ve been using synonyms[index] = [ (results[i].score, trans.words[index]) for i, trans in enumerate(transformed_text_candidates) if trans.words[index] != max_result.attacked_text.words[index] ] curent_result = max_result if curent_result.goal_status == GoalFunctionResultStatus.SUCCEEDED: return ( curent_result, perturbed_indexes, non_usefull_indexes, synonyms, curent_result.goal_status, ) return ( curent_result, perturbed_indexes, non_usefull_indexes, synonyms, curent_result.goal_status, ) # TODO we can add depth to track how many words rolled back for more statistics def perturbed_index_swap( self, initial_result, curent_result, non_perturbed_indexes, perturbed_indexes, synonyms, steps, ): past_curent_result = curent_result # the index with minimum perturbation rollback_found = False steps = min(steps, len(perturbed_indexes) - 1) sucsefull_attacks = [] for _ in range(steps): # TODO getting the least important perturbated word in the new attacked sample costs a lot rollback_index = min(perturbed_indexes, key=perturbed_indexes.get) # TODO remove from perturbed_indexes list and add it to non_perturbed_indexes but with punalitié # how punalité should look like ? it could be at the end of the quee with visited flag # or we can just eliminate it . perturbed_indexes.pop(rollback_index, None) for index in non_perturbed_indexes: # early returning if len(perturbed_indexes) == 1: return ( curent_result, non_perturbed_indexes, perturbed_indexes, synonyms, sucsefull_attacks, rollback_found, ) # get candidates for non perturbed word transformed_text_candidates = self.get_transformations( curent_result.attacked_text, original_text=initial_result.attacked_text, indices_to_modify=[index], ) if len(transformed_text_candidates) == 0: non_perturbed_indexes.remove(index) continue # wa7ed ma chaf wa7ed results, _ = self.get_goal_results(transformed_text_candidates) # we add one perturbed word max_result = max(results, key=lambda x: x.score) for res in results: if res.score > curent_result.score: if res.goal_status == GoalFunctionResultStatus.SUCCEEDED: synonyms = self.update_synonyms( synonyms=synonyms, index_to_add=index, index_to_remove=None, curent_result=res, results=results, transformed_text_candidates=transformed_text_candidates, ) # stock this sucssefull attack sucsefull_attacks.append(res) # we get better score if max_result.score > curent_result.score: # eplore minimum perturbation on the original text inferior = min(perturbed_indexes, key=perturbed_indexes.get) non_perturbed_indexes.remove(index) # remove perturbed index perturbed_indexes[index] = max_result.score - curent_result.score # restore one perturbed result_rollback = self.swap_to_origin( max_result, initial_result, rollback_index ) perturbed_indexes.pop(inferior, None) new_attacked_text = ( result_rollback.attacked_text.replace_word_at_index( inferior, initial_result.attacked_text.words[inferior], ) ) result, _ = self.get_goal_results([new_attacked_text]) result_rollback = max(result, key=lambda x: x.score) for res in result: if res.goal_status == GoalFunctionResultStatus.SUCCEEDED: synonyms = self.update_synonyms( synonyms, index, inferior, res, results, transformed_text_candidates, ) # stock this sucssefull attack sucsefull_attacks.append(res) if ( result_rollback.goal_status == GoalFunctionResultStatus.SUCCEEDED ): rollback_found = True synonyms = self.update_synonyms( synonyms, index, inferior, result_rollback, results, transformed_text_candidates, ) curent_result = result_rollback if rollback_found: return ( curent_result, non_perturbed_indexes, perturbed_indexes, synonyms, sucsefull_attacks, rollback_found, ) return ( past_curent_result, non_perturbed_indexes, perturbed_indexes, synonyms, sucsefull_attacks, rollback_found, ) def update_synonyms( self, synonyms, index_to_add=None, index_to_remove=None, curent_result=None, results=None, transformed_text_candidates=None, ): """Return an updated list of synonyms""" if index_to_remove in synonyms and len(synonyms[index_to_remove]) != 0: # remove the used synonym of certain index synonyms[index_to_remove] = [ syn for syn in synonyms[index_to_remove] if syn[1] != curent_result.attacked_text.words[index_to_remove] ] # add synonyms of new perturbated word with their score if index_to_add is not None and transformed_text_candidates is not None: synonyms[index_to_add] = [ (results[i].score, trans.words[index_to_add]) for i, trans in enumerate(transformed_text_candidates) if trans.words[index_to_add] != curent_result.attacked_text.words[index_to_add] ] return synonyms def get_non_perturbed_indexes( self, initial_result, perturbed_indexes, non_usefull_indexes ): """Return a list of non perturbed indexes""" all_indexes = set(range(len(initial_result.attacked_text.words))) perturbed_indexes_set = set(perturbed_indexes.keys()) non_usefull_indexes_set = set(non_usefull_indexes) non_perturbed_indexes = list( all_indexes - perturbed_indexes_set - non_usefull_indexes_set ) return non_perturbed_indexes def perform_search(self, initial_result): ( curent_result, perturbed_indexes, non_usefull_indexes, synonyms, goal_statut, ) = self.generate_naive_attack(initial_result) sucsefull_attacks = [curent_result] new_curent_sucsefull_attacks = [curent_result] if not self.naive: # perturbed_index_swap is our 1s priority (in case of attack succeed goal_statut = 0 ) for i in range(self.k): non_perturbed_indexes = self.get_non_perturbed_indexes( initial_result, perturbed_indexes, non_usefull_indexes ) if len(new_curent_sucsefull_attacks) != 0: # how to decide on the next text to be treated here we work on the the one with max score curent_result = max( new_curent_sucsefull_attacks, key=lambda x: x.score ) new_curent_sucsefull_attacks.remove(curent_result) else: curent_result, synonyms, synonym_found = self.swap_to_synonym( curent_result, synonyms, perturbed_indexes ) if synonym_found == True: sucsefull_attacks.append(curent_result) new_curent_sucsefull_attacks.append(curent_result) continue else: non_perturbed_indexes = self.get_non_perturbed_indexes( initial_result, perturbed_indexes, non_usefull_indexes ) ( non_perturbed_indexes, perturbed_indexes, synonyms, max_result, sample_found, ) = self.random_selection( non_perturbed_indexes, perturbed_indexes, synonyms, curent_result, initial_result, ) if sample_found == True: new_curent_sucsefull_attacks.append(max_result) sucsefull_attacks.append(curent_result) else: break if i % 3 == 0: non_perturbed_indexes = self.get_non_perturbed_indexes( initial_result, perturbed_indexes, non_usefull_indexes ) ( non_perturbed_indexes, perturbed_indexes, synonyms, max_result, sample_found, ) = self.random_selection( non_perturbed_indexes, perturbed_indexes, synonyms, curent_result, initial_result, ) if sample_found == True: new_curent_sucsefull_attacks.append(max_result) sucsefull_attacks.append(curent_result) if len(perturbed_indexes) > 1 and not goal_statut: non_perturbed_indexes = self.get_non_perturbed_indexes( initial_result, perturbed_indexes, non_usefull_indexes ) ( curent_result, non_perturbed_indexes, perturbed_indexes, synonyms, sucsefull_attacks_partial, rollback_found, ) = self.perturbed_index_swap( initial_result, curent_result, non_perturbed_indexes, perturbed_indexes, synonyms, steps=self.rollback_level, ) if len(sucsefull_attacks_partial) != 0: sucsefull_attacks.extend(sucsefull_attacks_partial) new_curent_sucsefull_attacks.extend(sucsefull_attacks_partial) # Action 2: the case where no rollback found we try to swap synonym and we aim to get better result if rollback_found == False: curent_result, synonyms, synonym_found = self.swap_to_synonym( curent_result, synonyms, perturbed_indexes ) if synonym_found == True: sucsefull_attacks.append(curent_result) new_curent_sucsefull_attacks.append(curent_result) # if it's a failed attack we give chance for an other synonym # we will pass it for now because no improvment were found """elif goal_statut == 1: curent_result, synonyms, goal_statut = self.swap_to_synonym( curent_result, synonyms, perturbed_indexes )""" if goal_statut == 0: sucsefull_attacks_text_scores = [] sucsefull_attacks_text_scores = [ (atk.attacked_text, atk.score) for atk in sucsefull_attacks if atk.score > 0.5 ] sucsefull_attacks_text_scores = list(set(sucsefull_attacks_text_scores)) self.successful_attacks[initial_result.attacked_text] = ( sucsefull_attacks_text_scores ) ground_truth_output = sucsefull_attacks[0].ground_truth_output self.save_to_train( self, initial_result.attacked_text, sucsefull_attacks_text_scores, ground_truth_output, ) try: best_result = self.min_perturbation( sucsefull_attacks, initial_result.attacked_text ) return best_result except: return curent_result def save_to_train( self, original_text, sucsefull_attacks_text_scores, ground_truth_output, train_file, ): successful_attacks = { original_text.attacked_text: sucsefull_attacks_text_scores } self.save_to_JSON(filename="temp.json", successful_attacks=successful_attacks) self.pipeline(ground_truth_output, train_file) def pipeline(self, ground_truth_output, train_file): clust = self.clust clust.file_ = "temp.json" sentence_embedding_vectors, masks, scores = clust.prepare_sentences() unified_mask = clust.get_global_unified_masks(masks=masks) sentences = clust.apply_mask_on_global_vectors( global_sentences=sentence_embedding_vectors, unified_masks=unified_mask ) sentences = clust.global_matrix_to_global_sentences( global_matrix_sentences=sentences ) global_clustering = clust.find_global_best_clustering( sentences, 10, "thumb-rule" ) selected_samples = clust.global_select_diverce_sample( scores, sentences, global_clustering ) clust.save_csv(selected_samples, ground_truth_output, train_file) def save_to_JSON(self, filename, successful_attacks): data_list = [] input_dict = {} for atk in successful_attacks: successful_attacks_with_scores = [ (atk, score) for atk, score in successful_attacks[atk] ] input_dict[" ".join(atk.words)] = successful_attacks_with_scores for original, samples in input_dict.items(): samples_list = [ {"attacked_text": " ".join(text.words), "score": score} for text, score in samples ] data_list.append({"original": original, "samples": samples_list}) # Save the formatted data to a JSON file with open(filename, "w") as json_file: json.dump({"data": data_list}, json_file, indent=4) def swap_to_synonym(self, curent_result, synonyms, perturbed_indexes): # giving chance to the second synonym of the most perturbated word if exists ! found = False for index in perturbed_indexes: if index in synonyms and len(synonyms[index]) != 0: # what about other indexes we may give them chance too ! # response : experiments shows that there is no much improvment taking in consideration the high increase of avg Q-num synonym = max(synonyms[index], key=lambda x: x[0]) if synonym[0] > 0.8: new_attacked_text = ( curent_result.attacked_text.replace_word_at_index( index, synonym[1], ) ) curent_result.attacked_text = ( curent_result.attacked_text.replace_word_at_index( index, synonym[1], ) ) synonyms = self.update_synonyms( synonyms=synonyms, index_to_remove=index, curent_result=curent_result, ) found = True return curent_result, synonyms, found # remove index with 0 synonymswithin the list synonyms.pop(index, None) return curent_result, synonyms, found def min_perturbation(self, results, original_text): # Initialize minimum score and result min_score = float("inf") min_result = None original_text_splited = original_text.words for result in results: # Calculate perturbation as the number of words changed attacked_text = result.attacked_text perturbation = sum( i != j for i, j in zip(original_text_splited, attacked_text.words) ) # Update minimum score and result if necessary if perturbation < min_score: min_score = perturbation min_result = result return min_result def check_transformation_compatibility(self, transformation): """Since it ranks words by their importance, the algorithm is limited to word swap and deletion transformations.""" return transformation_consists_of_word_swaps_and_deletions(transformation) def random_selection( self, non_perturbed_indexes, perturbed_indexes, synonyms, curent_result, initial_result, ): max_iterations = len(non_perturbed_indexes) sample_found = False for _ in range(max_iterations): random_index = random.choice(non_perturbed_indexes) transformed_text_candidates = self.get_transformations( curent_result.attacked_text, original_text=initial_result.attacked_text, indices_to_modify=[random_index], ) if len(transformed_text_candidates) == 0: non_perturbed_indexes.remove(random_index) continue results, _ = self.get_goal_results([transformed_text_candidates[0]]) # we add one perturbed word max_result = max(results, key=lambda x: x.score) sample_found = True # update synonym synonyms = self.update_synonyms( synonyms=synonyms, index_to_add=random_index, curent_result=curent_result, results=results, transformed_text_candidates=[transformed_text_candidates[0]], ) # penalty on existing indexes for index in perturbed_indexes: perturbed_indexes[index] = perturbed_indexes[index] * 0.9 perturbed_indexes[random_index] = max_result.score - curent_result.score non_perturbed_indexes.remove(random_index) return ( non_perturbed_indexes, perturbed_indexes, synonyms, max_result, sample_found, ) return ( non_perturbed_indexes, perturbed_indexes, synonyms, curent_result, sample_found, ) @property def is_black_box(self): if "gradient" in self.wir_method: return False else: return True def extra_repr_keys(self): return ["wir_method"]