Upload GreedyMultyGeneration.py

GreedyMultyGeneration.py

@@ -0,0 +1,721 @@
+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"]