def attack_in_mask(model_list, img, label, mask, id_embeddings_list, eps,
attack_type, iters, device, target_or_not, target_index):
#model_list=model_list[1:]
adv = img.detach()
adv.requires_grad = True
if target_or_not:
flag = -1
else:
flag = 1
if attack_type == 'fgsm':
iterations = 1
else:
iterations = iters
if attack_type == 'pgd':
step = 2 / 255
else:
step = eps / iterations
noise = 0
for j in range(iterations):
loss = 0
for model, id_embeddings in zip(model_list, id_embeddings_list):
features = extract_features.l2_normlize(
model(utils.normalize(adv.clone())))
loss = loss + utils.distance_loss(id_embeddings, features,
target_index, device)
#losses.append(utils.distance_loss(id_embeddings,features,target_index,device))
#loss = torch.sum(torch.cat(losses))
loss.backward()
if attack_type == 'mim':
adv_mean = torch.mean(torch.abs(adv.grad), dim=1, keepdim=True)
adv_mean = torch.mean(torch.abs(adv_mean), dim=2, keepdim=True)
adv_mean = torch.mean(torch.abs(adv_mean), dim=3, keepdim=True)
adv.grad = adv.grad / adv_mean
noise = noise + adv.grad
else:
noise = adv.grad
# Optimization step
adv.data = adv.data + flag * step * noise.sign()
if attack_type == 'pgd':
adv.data = torch.where(adv.data > img.data + eps, img.data + eps,
adv.data)
adv.data = torch.where(adv.data < img.data - eps, img.data - eps,
adv.data)
adv.data = adv.data * mask + img.data * (1 - mask)
adv.data.clamp_(0.0, 1.0)
adv.grad.data.zero_()
return adv.detach()
def compute(score_lookup,
word2vec_model,
jate_terms_file,
stopwords,
jate_terms_folder,
out_folder,
append_label=None):
kcr_lookup = score_lookup
model = Word2Vec.load(word2vec_model)
jate_term_base_scores = {
c[0]: c[1]
for c in tr.jate_terms_iterator(jate_terms_file)
}
term_unigrams = set()
for term in jate_term_base_scores.keys():
norm_parts = utils.normalize_string(term)
for part in norm_parts:
part = re.sub(r'[^a-zA-Z0-9,/\-\+\s_]', ' ', part).strip()
if (part in stopwords or len(part) < 2):
continue
else:
term_unigrams.add(part)
sum_unigram_scores = {}
for tu in term_unigrams:
if tu in kcr_lookup.keys():
sum_unigram_scores[tu] = kcr_lookup[tu]
else:
sum_unigram_scores[tu] = 0.0
sum_unigram_scores = utils.normalize(sum_unigram_scores)
jate_terms_components = td.generate_term_component_map(
jate_term_base_scores, 5, model)
for file in os.listdir(jate_terms_folder):
print("\t{}".format(file))
jate_term_base_scores = {
c[0]: c[1]
for c in tr.jate_terms_iterator(jate_terms_folder + "/" + file)
}
term_rank_scores = ts.SemReRankScorer(sum_unigram_scores,
jate_terms_components,
jate_term_base_scores)
out_file = out_folder + "/" + file
if append_label is not None:
out_file = out_file + "_" + append_label
# sorted_term_rank_scores = sorted(list(term_rank_scores), key=lambda k: k['score'])
with open(out_file, 'w') as outfile:
json.dump(list(term_rank_scores), outfile)
def chroma_stft(y=None, sr=22050, S=None, norm=np.inf, n_fft=2048,
hop_length=512, tuning=None, **kwargs):
S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length,
power=2)
n_chroma = kwargs.get('n_chroma', 12)
if tuning is None:
tuning = estimate_tuning(S=S, sr=sr, bins_per_octave=n_chroma)
if 'A440' not in kwargs:
kwargs['A440'] = 440.0 * 2.0**(float(tuning) / n_chroma)
chromafb = filters.chroma(sr, n_fft, **kwargs)
raw_chroma = np.dot(chromafb, S)
return utils.normalize(raw_chroma, norm=norm, axis=0)
def chroma(sr,
n_fft,
n_chroma=12,
A440=440.0,
ctroct=5.0,
octwidth=2,
norm=2,
base_c=True):
wts = np.zeros((n_chroma, n_fft))
frequencies = np.linspace(0, sr, n_fft, endpoint=False)[1:]
frqbins = n_chroma * hz_to_octs(frequencies, A440)
frqbins = np.concatenate(([frqbins[0] - 1.5 * n_chroma], frqbins))
binwidthbins = np.concatenate((np.maximum(frqbins[1:] - frqbins[:-1],
1.0), [1]))
D = np.subtract.outer(frqbins, np.arange(0, n_chroma, dtype='d')).T
n_chroma2 = np.round(float(n_chroma) / 2)
D = np.remainder(D + n_chroma2 + 10 * n_chroma, n_chroma) - n_chroma2
wts = np.exp(-0.5 * (2 * D / np.tile(binwidthbins, (n_chroma, 1)))**2)
wts = utils.normalize(wts, norm=norm, axis=0)
if octwidth is not None:
wts *= np.tile(
np.exp(-0.5 * (((frqbins / n_chroma - ctroct) / octwidth)**2)),
(n_chroma, 1))
if base_c:
wts = np.roll(wts, -3, axis=0)
return np.ascontiguousarray(wts[:, :int(1 + n_fft / 2)])
def run(word2vec_model, jate_out_terms, topN_similar, similarity_threshold,
jate_term_max_n, pagerank_out_file, final_out_file, personalized,
exp_id):
model = Word2Vec.load(word2vec_model)
graph_data_file = pagerank_out_file + ".graph".format(
str(similarity_threshold))
setting_parts = graph_data_file.split("-")
graph_data_file = setting_parts[0] + "-" + setting_parts[1] + "-" + setting_parts[2] + "-" + setting_parts[4]+"-" \
+ setting_parts[5] + "-" + setting_parts[6] + "-" + setting_parts[7] + "-" + setting_parts[9]
graph_data = utils.load_saved_model(graph_data_file)
G = None
jate_terms_components = None
if (graph_data is not None):
G = graph_data[0]
jate_terms_components = graph_data[1]
else:
if not exp_loader.DIRECTED_GRAPH:
G = nx.Graph()
else:
G = nx.DiGraph()
jate_terms_components = \
tr.build_graph(jate_out_terms, model, topN_similar, similarity_threshold, jate_term_max_n, G,
exp_loader.GRAPH_PRUNING)
pk._dump((G, jate_terms_components), open(graph_data_file, 'wb'))
jate_term_base_scores = {
c[0]: c[1]
for c in tr.jate_terms_iterator(jate_out_terms)
}
personalized_init = None
if personalized is not None:
personalized_init = tr.init_personalized_vector(
G.nodes(), jate_term_base_scores, personalized)
semrerank = utils.load_saved_model(pagerank_out_file)
if semrerank is None:
print("Graph size exp={}: {} {}".format(exp_id, len(G.nodes()),
len(G.edges())))
print(time.strftime("%H:%M:%S"))
logger.info("Graph size exp={}: {} {}".format(exp_id, len(G.nodes()),
len(G.edges())))
logger.info(time.strftime("%H:%M:%S"))
semrerank = nx.pagerank(G,
alpha=0.85,
personalization=personalized_init,
max_iter=5000,
tol=1e-06)
print(time.strftime("%H:%M:%S"))
print("Pagerank completes")
logger.info(time.strftime("%H:%M:%S"))
logger.info("Pagerank completes")
semrerank = utils.normalize(semrerank)
pk._dump(semrerank, open(pagerank_out_file, 'wb'))
term_rank_scores = ts.SemReRankScorer(semrerank, jate_terms_components,
jate_term_base_scores)
# sorted_term_rank_scores = sorted(list(term_rank_scores), key=lambda k: k['score'])
with open(final_out_file, 'w') as outfile:
json.dump(list(term_rank_scores), outfile)
def __init__(self, pageranks, jate_term_map, base_scores):
self.pageranks = pageranks
self.base_scores = base_scores
if exp_loader_doc_graph.SCORING_NORMALIZE_JATE_SCORE:
self.base_scores = utils.normalize(base_scores)
self.jate_term_map = jate_term_map