f = open("cnn_result.txt","a")#以追加的方式写入，这样不会覆盖掉之前的内容

print(time.strftime(ISOTIMEFORMAT,time.localtime()) , file = f);#写入时间

print(strr,file = f);

r"WikiQASent-dev-filtered",

r"WikiQASent-test",

r"WikiQASent-test-filtered",

List = [];

with open(filename,"r") as f:

filelines = f.readlines();

for line in filelines:

temp = line.strip("\n").strip().split("\t",5);#que ,ans, label ,qid, wordco;

List.append([ temp[0],temp[1],int(temp[2]),int(temp[3]) ]);

#句子列表，元素时字符串，改成元素是id，句子的最长的长度是236，但是这个长度是包含了，。？；！等句子中的符号的，符号用<unk>代表

global word_id;

x = [];

for i in range(0,size):

x.append(word_id["<NULL>"])

words = string.strip().split();

for i in range(len(words)):

if words[i] in word_id:

x[i] = word_id[words[i]];

else:

x[i] = word_id["<UNK>"]

que ,ans ,label = [], [], [];

total_len = len(List);

Temp = [];

if start_pos + batch_size <= total_len :

Temp = List[start_pos:start_pos + batch_size];

else :

Temp = List[ -batch_size :];

for i in range(batch_size):

q = Temp[i][0];

a = Temp[i][1];

l = int(Temp[i][2]);

que.append(encode_sent(q,236));

ans.append(encode_sent(a,236));

label.append(l);

score_list , index = [] , int(0);

avg_COST ,tot_COST = float(0) , float(0);

while True:

que , ans , label = load_batch_data(test_List ,index , batch_size);

COST , batch_scores , _ , _ = validate_model(que,ans,label,1.0);#在验证的时候不dropout,所以最后一个是1

tot_COST += COST;

for score in batch_scores:#这里的score指的是cos_sim搬移，压缩到0~1之间之后的值

score_list.append(score);

index += batch_size;

if index >= len(test_List):

break;

print("validating...",index);

avg_COST = tot_COST / len(test_List);

#构造可以用于计算MAP，MRR，precision的sdict

sdict , index = {} , int(0);

for items in test_List:#item = [que , ans ,label , qid]

qid = items[3];

if not qid in sdict:

sdict[qid] = [];

sdict[qid].append((score_list[index] , items[2]))#将“余弦值”和label作为元组加入到sdict[qid],这个列表中

index += 1;

#计算precision

lev0 , lev1 = float(0) ,float(0)

for qid , cases in sdict.items():

cases.sort(key = operator.itemgetter(0) , reverse = True)#按照余弦值的大小降序排序

score , flag = cases[0] #取最高的得分,和对应的label

if flag == 1:

lev1 += 1;

if flag == 0:

lev0 += 1;

precision = lev1 /(lev0 + lev1)

#计算MRR

MRR , num_Q , reciptrocal_rank = float(0) , float(0) , float(0);

for qid ,cases in sdict.items():

#已经拍过序了

for j in range(len(cases)):

if cases[j][1] == 1:

reciptrocal_rank = 1.0 /(j + 1);

break;

if reciptrocal_rank != 0.0:

MRR += reciptrocal_rank ;

num_Q += 1;

if num_Q != 0.0:

MRR /= num_Q;

else :

MRR = 0.0;

#计算MAP

MAP , num_Q , single_avg , single_num = float(0) , float(0) , float(0) , float(0);

#single_avg ：单个主题的平均准确率的平均值

for qid ,cases in sdict.items():

#cases.sort(key = operator.itemgetter(0) , reverse = True)

single_avg = 0.0;

single_num = 0.0;

for j in range(len(cases)):

if cases[j][1] == 1:

single_num += 1;

single_avg += single_num/(j + 1);

if single_num != 0.0 and single_num != len(cases):

single_avg /= single_num;

else:

single_avg = 0.0;

if single_avg != 0.0:

MAP += single_avg ;

num_Q += 1;

if num_Q != 0.0:

MAP /= num_Q;

else :

MAP = 0.0;

def __init__(self,que, ans, label, word_embeddings , batch_size,max_sequence_len,embedding_size , filter_sizes , num_filters, keep_prob):

'''

input1,inpu2 每一行是一个id化的句子,batch_size行 max_sequence_len 列；

max_sequence_len:最长的句子的长度

'''

rng = np.random.RandomState(23455);

self.params = [];

id_vec = theano.shared(name = "id_vec" , value = word_embeddings);

que_matrix = id_vec[T.cast(que.flatten() , dtype = "int32")]#flatten()之后就是batch_size * max_sequence_len列，一行，但是再从id_vec矩阵中析取之后就是batch_size *max_sequence_len行，embedding_size列了

ans_matrix = id_vec[T.cast(ans.flatten() , dtype = "int32")]#每max_sequence_len行构成一个句子。

que_x = que_matrix.reshape((batch_size , 1 , max_sequence_len , embedding_size))

ans_x = ans_matrix.reshape((batch_size , 1 , max_sequence_len , embedding_size))#为了进行卷积，将原始数据构成这样的格式[batch_size, num_feature_maps,img_height,mig_width]

self.dbg_x1 = que_x;

que_vec , ans_vec = [] , [];

#filter_sizes是一个列表有多种大小的filter_height;

#对于每一种filter之间并不是级联的关系，而是并列关系，每个filter的width都==embedding_size，然后池化层又都是利用(max_sequence_len - filter_height + 1 , 1)大小的池化块来池化，所以最后每个filter的情况下得到的都是num_filters维的向量

for i,filter_size in enumerate(filter_sizes):

filter_shape = (num_filters , 1 , filter_size , embedding_size)#根据函数conv2d(A,W)的要求，W[目标特征数，源特征数，filter_height, filter_width]

img_shape =(batch_size , 1 , max_sequence_len , embedding_size)#A[batch_size , 图片特征数，img_height , img_width]

fan_in = np.prod(filter_shape[1:])#每一层的神经元接收的上一层的输入的数量是[上一层的feature_map数 * filter_height * filter_width]

fan_out = np.prod(filter_shape[2:]) * filter_shape[0] // (max_sequence_len - filter_size + 1)

W_bound = np.sqrt(6./(fan_in + fan_out))

W = theano.shared(

name = "W_%d"%i,

value =

np.array(

rng.uniform(low = - W_bound , high = W_bound , size = filter_shape),

dtype = theano.config.floatX

),

borrow = True)

b_values = np.zeros((filter_shape[0],),dtype = theano.config.floatX)

b = theano.shared(name = "b_%d"%i , value = b_values,borrow = True)

#卷积+max_pooling

conv_out = conv2d(input = que_x , filters = W , filter_shape = filter_shape , input_shape = img_shape)

#卷积后[batch_size , num_filters , max_sequence_len - filer_size + 1 , 1]

pooled_out = pool.pool_2d(input = conv_out , ds = (max_sequence_len - filter_size + 1 , 1) , ignore_border = True , mode = "max")

#池化后[batch_size , numfilter , 1 , 1]

pooled_active = T.tanh(pooled_out + b.dimshuffle('x' , 0 , 'x' , 'x'))

que_vec.append(pooled_active)

conv_out = conv2d(input = ans_x , filters = W , filter_shape = filter_shape , input_shape = img_shape)

pooled_out = pool.pool_2d(input = conv_out , ds = (max_sequence_len - filter_size + 1 , 1) , ignore_border = True , mode = "max")

pooled_active = T.tanh(pooled_out + b.dimshuffle('x' , 0 , 'x' , 'x'))

ans_vec.append(pooled_active)

self.params += [W,b]

self.dbg_conv_out = conv_out.shape

num_filters_total = num_filters * len(filter_sizes)

self.dbg_outputs_que = que_vec[0].shape

que_vec_flat = T.reshape(T.concatenate(que_vec , axis = 1) , [batch_size , num_filters_total])

ans_vec_flat = T.reshape(T.concatenate(ans_vec , axis = 1) , [batch_size , num_filters_total])

#问答句向量到此计算结束

drop_que = self._dropout(rng , que_vec_flat , keep_prob)

drop_ans = self._dropout(rng , ans_vec_flat , keep_prob)

#drop_out

#计算问题与答案之间的余弦相似度

len_que = T.sqrt(T.sum(drop_que * drop_que , axis = 1))

len_ans = T.sqrt(T.sum(drop_ans * drop_ans , axis = 1))

cos_sim = T.sum(drop_que * drop_ans , axis = 1) / (len_que * len_ans)

self.cos_sim = cos_sim;

#损失

def loss(label , cos_sim , batch_size):

cos_sim = (cos_sim + 1.0)/2.0 #搬移，压缩到（0~1）之间,

cos_sim = T.clip(cos_sim , 1e-10 , 1-1e-10)#对0有效，对1无效

cross_entropy_loss = T.nnet.binary_crossentropy(cos_sim, label)

ones = theano.shared(numpy.ones(batch_size , dtype = theano.config.floatX), borrow = True);

cross_entropy_loss = T.switch(T.eq(cos_sim, ones),- ( label * T.log(cos_sim) + (1 - label) * T.log(1e-10) ),cross_entropy_loss)

return cross_entropy_loss;

cross_entropy_loss = loss(label , cos_sim , batch_size);

self.cost = T.sum(cross_entropy_loss , acc_dtype = theano.config.floatX);

def _dropout(self , rng , layer , keep_prob):

srng = T.shared_randomstreams.RandomStreams(rng.randint(123456));

mask = srng.binomial(n = 1, p = keep_prob , size = layer.shape)#二项分布，成功地概率是p,实验次数n，返回成功地次数

output = layer * T.cast(mask,theano.config.floatX)

output = output / keep_prob;

return output;

def save(self,folder = "save_my_params_cnn"):

if not os.path.exists(folder):

os.mkdir(folder);

for param in self.params:

numpy.save(os.path.join(folder,param.name + ".npy"),param.get_value());

def load(self,folder = "save_my_params_cnn"):

for param in self.params:

param.set_value(numpy.load(open(os.path.join(folder , param.name + ".npy"))));

def Show(self):

for param in self.params: