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)