Upload Clustering.py

Clustering.py

@@ -0,0 +1,255 @@
+import textattack
+from textattack.shared import AttackedText
+from sklearn.cluster import KMeans
+from sklearn.metrics import silhouette_score
+from math import floor, sqrt
+import csv 
+
+class Clustering:
+    def __init__(self, file_, victim_model_wrapper, victim_model, attack):
+        self.file = file_
+        self.victim_model_wrapper = victim_model_wrapper
+        self.victim_model = victim_model
+        self.attack = attack
+
+    def get_embedding_layer(self, model, text_input):
+        if isinstance(model, textattack.models.helpers.T5ForTextToText):
+            raise NotImplementedError(
+                "`get_grads` for T5FotTextToText has not been implemented yet."
+            )
+
+        model.train()
+        embedding_layer = model.get_input_embeddings()
+        embedding_layer.weight.requires_grad = True
+
+        model.zero_grad()
+        model_device = next(model.parameters()).device
+        input_dict = tokenizer(
+            [text_input],
+            add_special_tokens=True,
+            return_tensors="pt",
+            padding="max_length",
+            truncation=True,
+        )
+        input_dict = input_dict.to(model_device)
+        embedding = embedding_layer(input_dict["input_ids"])
+        # embedding = embedding_layer(torch.tensor(input_dict))
+        return embedding
+
+    def prepare_sentences(self):
+        file = self.file
+        victim_model = self.victim_model
+        victim_model_wrapper = self.victim_model_wrapper
+        attack = self.attack
+        with open(file, "r") as f:
+            data = json.load(f)
+        global_sentences = []
+        global_masks = []
+        global_scores = []
+        for item in data["data"]:
+            original_words = item["original"].split()
+
+            # Iterate over each sample
+            sentences = []
+            masks = []
+            scores = []
+            _, indices_to_order = attack.get_indices_to_order(
+                AttackedText(item["original"])
+            )
+            for sample in item["samples"]:
+                scores.append(sample["score"])
+                attacked_text = AttackedText(sample["attacked_text"])
+                word2token_mapping_0 = attacked_text.align_with_model_tokens(
+                    victim_model_wrapper
+                )
+                embedding_0 = self.get_embedding_layer(
+                    model=victim_model, text_input=sample["attacked_text"]
+                )
+                embedding_vectors_0 = embedding_0[0].detach().cpu().numpy()
+
+                sentence_embedding = []
+                mask = []
+                for _, idx in enumerate(indices_to_order):
+                    # index of tensor that corresponds to the index of the word
+                    matched_tokens_0 = word2token_mapping_0[idx]
+                    embedding_from_layer = np.mean(
+                        embedding_vectors_0[matched_tokens_0], axis=0
+                    )
+                    if original_words[idx] != attacked_text.words[idx]:
+                        mask.append(1)
+                        sentence_embedding.append(embedding_from_layer)
+                    else:
+                        sentence_embedding.append(embedding_from_layer)
+                        mask.append(0)
+                sentences.append(sentence_embedding)
+                masks.append(mask)
+            global_sentences.append(sentences)
+            global_masks.append(masks)
+            global_scores.append(scores)
+        return global_sentences, global_masks, global_scores
+
+    def get_unified_mask(self, masks):
+
+        unified_mask = np.zeros_like(masks[0])
+        for mask in masks:
+
+            unified_mask = np.logical_or(unified_mask, mask)
+
+        return unified_mask.astype(int)
+
+    def get_global_unified_masks(self, masks):
+        global_unified_masks = [self.get_unified_mask(masks=mask) for mask in masks]
+
+        return global_unified_masks
+
+    def apply_mask_on_vectors(self, sentences, mask):
+        for i in range(len(sentences)):
+            sentence = sentences[i]
+
+            sentences[i] = [
+                sentence[j] if mask[j] == 1 else np.zeros_like(sentence[j])
+                for j in range(len(sentence))
+            ]
+
+        return sentences
+
+    def apply_mask_on_global_vectors(self, global_sentences, unified_masks):
+
+        return [
+            self.apply_mask_on_vectors(sentences, mask)
+            for sentences, mask in zip(global_sentences, unified_masks)
+        ]
+
+    def matrix_to_sentences(self, matrix_sentences):
+
+        return np.vstack([np.concatenate(sentence) for sentence in matrix_sentences])
+
+    def global_matrix_to_global_sentences(self, global_matrix_sentences):
+        # TODO : check for the compatibility of the tex firs \u00e3
+        return [
+            self.matrix_to_sentences(sentences) for sentences in global_matrix_sentences
+        ]
+
+    def find_best_clustering(self, sentences, max_clusters, method="silhouette"):
+        if method == "silhouette":
+            max_silhouette_avg = -1
+            final_cluster_labels = None
+            best_k = 2
+            
+            for num_clusters in range(1, max_clusters + 1):
+
+                kmeans = KMeans(n_clusters=num_clusters).fit(sentences)
+
+                cluster_labels = kmeans.labels_
+                silhouette_avg = silhouette_score(sentences, cluster_labels)
+
+                if silhouette_avg > max_silhouette_avg:
+                    max_silhouette_avg = silhouette_avg
+                    final_cluster_labels = cluster_labels
+                    best_k = num_clusters
+
+            return kmeans.cluster_centers_, final_cluster_labels
+        elif method == "thumb-rule":
+
+            best_k = floor(sqrt(len(sentences)/2)) + 1
+            kmeans = KMeans(n_clusters=best_k).fit(sentences)
+
+            return kmeans.cluster_centers_, kmeans.labels_
+        elif "custom":
+            best_k = 5
+            kmeans = KMeans(n_clusters=best_k).fit(sentences)
+
+            return kmeans.cluster_centers_, kmeans.labels_
+
+    def find_global_best_clustering(
+        self, global_sentences, max_clusters_per_group, method
+    ):
+        return [
+            self.find_best_clustering(
+                sentences,
+                min(len(sentences) - 1, max_clusters_per_group),
+                method=method,
+            )
+            for sentences in global_sentences
+        ]
+
+    def get_global_distances(self, sentences, global_clustering):
+        global_distances = []
+        for X, clustering in zip(sentences, global_clustering):
+            centroids = clustering[0]
+            labels = clustering[1]
+            global_distances.append(
+                [
+                    np.sqrt(np.sum((X[i] - centroids[labels[i]]) ** 2))
+                    for i in range(len(X))
+                ]
+            )
+        return global_distances
+
+    def select_diverce_samples(self, scores, distances, clustering):
+
+        scores_ = np.array(scores)
+        distances_ = np.array(distances)
+        labels_ = np.array(clustering)
+        selected_samples = []
+
+        normalized_distances = (distances_) / sum(distances_)
+
+        finalscores = scores / normalized_distances
+
+        clusters = np.unique(labels_)
+
+        for cluster in clusters:
+
+            indices = np.where(labels_ == cluster)[0]
+
+            cluster_finalscores = finalscores[indices]
+
+            best_sample_index = indices[np.argmin(cluster_finalscores)]
+
+            selected_samples.append(best_sample_index)
+        return selected_samples
+
+    def global_select_diverce_sample(self, global_scores, sentences, global_clustering):
+        global_distances = self.get_global_distances(sentences, global_clustering)
+        labels_ = [X[1] for X in global_clustering]
+
+        return [
+            self.select_diverce_samples(scores, distances, clustering)
+            for scores, distances, clustering in zip(
+                global_scores, global_distances, labels_
+            )
+        ]
+
+    def save_json(self, selected_samples, output):
+
+        data = json.load(open(self.file))
+
+        selected_data = []
+
+        for item, indices in zip(data["data"], selected_samples):
+
+            new_item = item.copy()
+
+            new_item["samples"] = [item["samples"][i] for i in indices]
+
+            selected_data.append(new_item)
+
+        with open(output, "w") as f:
+            json.dump({"data": selected_data}, f)
+    
+    def save_csv(self, selected_samples, ground_truth_output, train_file):
+
+        with open(self.file) as f:
+            data = json.load(f)["data"]
+
+        with open(train_file, 'a', newline='') as f:
+            writer = csv.writer(f)
+
+            for item, indices in zip(data, selected_samples):
+
+                samples = [item["samples"][i] for i in indices]  
+
+                for sample in samples:
+                    row = [sample, ground_truth_output]
+                    writer.writerow(row)