|
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"])
|
|
|
|
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()
|
|
|
|
|
|
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):
|
|
|
|
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):
|
|
|
|
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) |
