def graph_loss(image_tower_output1, image_tower_output2,text_tower_output1, text_tower_output2,y1,y2, A, graph_threshold):
batch_loss = []
i = argmax(y1, axis=1)
j = argmax(y2, axis=1)
for k in range(len(i)):
if (A[i[k]][j[k]] < graph_threshold):
#Image_tower_embedding
I = utils.cos_dist(image_tower_output1[k], image_tower_output2[k]) - A[i[k]][j[k]]
#Text tower embedding
T = utils.cos_dist(text_tower_output1[k], text_tower_output2[k]) - A[i[k]][j[k]]
g_loss = I + T
batch_loss.append(g_loss)
else:
g_loss = 0
batch_loss.append(g_loss)
# print(tf.convert_to_tensor(batch_loss).astype('float32'))
return tf.convert_to_tensor(batch_loss,dtype='float32')
def adv_interp(inputs,
y,
base_net,
num_classes,
epsilon=8,
epsilon_y=0.5,
v_min=0,
v_max=255):
# x: image batch with shape [batch_size, c, h, w]
# y: one-hot label batch with shape [batch_size, num_classes]
net = copy.deepcopy(base_net)
x = inputs.clone()
inv_index = torch.arange(x.size(0) - 1, -1, -1).long()
x_prime = x[inv_index, :, :, :].detach()
y_prime = y[inv_index, :]
x_init = x.detach() + torch.zeros_like(x).uniform_(-epsilon, epsilon)
x_init.requires_grad_()
zero_gradients(x_init)
if x_init.grad is not None:
x_init.grad.data.fill_(0)
net.eval()
fea_b = net(x_init, mode='feature')
fea_t = net(x_prime, mode='feature')
loss_adv = cos_dist(fea_b, fea_t)
net.zero_grad()
loss_adv = loss_adv.mean()
loss_adv.backward(retain_graph=True)
x_tilde = x_init.data - epsilon * torch.sign(x_init.grad.data)
x_tilde = torch.min(torch.max(x_tilde, inputs - epsilon), inputs + epsilon)
x_tilde = torch.clamp(x_tilde, v_min, v_max)
y_bar_prime = (1 - y_prime) / (num_classes - 1.0)
y_tilde = (1 - epsilon_y) * y + epsilon_y * y_bar_prime
return x_tilde.detach(), y_tilde.detach()
def MMR(final_lis, stopwords, model):
"""
根据MMR算法 保证摘要句子多样性
:param final_lis: 初步摘要（句子，权重）列表
:param stopwords:停用词表
:param model:词向量模型
:return:最终摘要的句子列表
"""
#根据final_lis 获取句子列表
sen_lis = [x[0] for x in final_lis]
#权重列表
weight_lis = [x[1] for x in final_lis]
#定义摘要列表
summary_lis = []
#首先挑出来权重最大的一句话，它必然是摘要列表中的一句
summary_lis.append(sen_lis[0])
#为了方便处理 将作为最终摘要的句子 从预摘要列表里删除掉
del sen_lis[0]
del weight_lis[0]
#根据要求个数摘要句子
#如果只摘要一个句子 直接将结果返回就可以了
if GlobalParameters.last_num == 1:
return summary_lis
#摘要不止一个句子 需要进行计算求解
else:
for i in range(len(sen_lis)):
# 所有候选句子的向量列表
vec_lis = [
generate_vector.sentence_vector(x, stopwords, model)
for x in sen_lis
]
#已经作为摘要的句子向量列表
summary_vec = [
generate_vector.sentence_vector(x, stopwords, model)
for x in summary_lis
]
#定义各个句子的得分情况
scores = []
for vec1 in vec_lis:
#计数器
count = 0
#初始化句子分数
score = 0
for vec2 in summary_vec:
score += GlobalParameters.alpha * weight_lis[count] - (
1 - GlobalParameters.alpha) * utils.cos_dist(
vec1, vec2)
#求新句子与最终摘要句子的平均相似度
count += 1
scores.append(score / len(summary_vec))
#根据最大分数的下标 求解对应的句子加入到摘要里面 通过array求解
scores = np.array(scores)
index = np.argmax(scores)
#将对应句子加入到摘要列表
summary_lis.append(sen_lis[index])
#将对应句子 和 权重从预摘要列表里删除
del sen_lis[index]
del weight_lis[index]
#返回指定需要的句子个数
return summary_lis[:GlobalParameters.last_num]
def get_first_summaries(text, stopwords, model):
"""
:param text: 文档
:param stopwords: 停用词
:param model: 词向量模型
:return: 摘要列表 按照权重从大到小排列[(句子，权重),(句子，权重)]
"""
#获取（位置，句子）列表
sentences = utils.get_sentences(text)
#获取句子列表
sen_lis = [x[1] for x in sentences]
# print(sen_lis)
#获取文档向量
docvec = generate_vector.doc_vector(text, stopwords, model)
#获取句子向量列表
sen_vecs = []
for i in range(len(sen_lis)):
#假设是首句
if i == 0:
sen_vecs.append(
generate_vector.sentence_vector(sen_lis[i], stopwords, model) *
GlobalParameters.locFirst_weight)
#如果是最后一句
elif i == len(sen_lis) - 1:
sen_vecs.append(
generate_vector.sentence_vector(sen_lis[i], stopwords, model) *
GlobalParameters.locLast_weight)
#如果是中间的句子
else:
sen_vecs.append(
generate_vector.sentence_vector(sen_lis[i], stopwords, model))
#计算余弦值列表
cos_lis = [utils.cos_dist(docvec, x) for x in sen_vecs]
#计算关键词权重列表
#获取关键词
keywords = utils.get_keywords(text)
#计算权重
keyweights = [utils.keyword_weight(x, keywords) for x in sen_lis]
#计算长度权重
len_weigths = [utils.len_weight(x) for x in sen_lis]
#根据余弦相似度 关键词权重 长度权重 计算每个句子最终权重
final_weights = [
cos * keyword * length for cos in cos_lis for keyword in keyweights
for length in len_weigths
]
#形成最后的（句子，权重列表）
final_lis = []
for sen, weight in zip(sen_lis, final_weights):
final_lis.append((sen, weight))
#将句子按照权重大小 从高到低排序
final_lis = sorted(final_lis, key=lambda x: x[1], reverse=True)
#取出第一次摘要的橘子个数
final_lis = final_lis[:GlobalParameters.first_num]
return final_lis
def gap_loss(output_image_encoding, output_text_encoding):
gap_loss = utils.cos_dist(output_image_encoding, output_text_encoding)
return tf.convert_to_tensor(gap_loss)