def Output_Result(doc4test):
mp, mr, mf = evaluation.evaluate_documents(doc4test, evaluation.muc)
#print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp, br, bf = evaluation.evaluate_documents(doc4test, evaluation.b_cubed)
#print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp, cr, cf = evaluation.evaluate_documents(doc4test, evaluation.ceafe)
#print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
metrics = {}
metrics["muc"] = (mr, mp, mf)
metrics["b3"] = (br, bp, bf)
metrics["ceaf"] = (cr, cp, cf)
return metrics
def get_reward(cluster_info, gold_info, max_cluster_num):
ev_document = get_evaluation_document(cluster_info, gold_info,
max_cluster_num)
p, r, f = evaluation.evaluate_documents([ev_document], evaluation.b_cubed)
#p,r,f = evaluation.evaluate_documents([ev_document],evaluation.muc)
#print >> sys.stderr, p,r,f
return f
def get_reward_average(cluster_info,gold_info,max_cluster_num,index,max_cluster_index):
# build new cluster
new_cluster_prefix = cluster_info[:index]
new_cluster_postfix = cluster_info[index+1:]
el = []
for cluster_num in range(max_cluster_index):
new_cluster_info = new_cluster_prefix + [cluster_num] + new_cluster_postfix
ev_document = get_evaluation_document(new_cluster_info,gold_info,max_cluster_num)
el.append(ev_document)
p,r,f = evaluation.evaluate_documents(el,evaluation.b_cubed)
#p,r,f = evaluation.evaluate_documents([ev_document],evaluation.muc)
#print >> sys.stderr, p,r,f
return f
def compute_metrics(docs, prefix):
results = {}
for name, metric in [(' muc', evaluation.muc), (' b3', evaluation.b_cubed),
(' ceafe', evaluation.ceafe), (' lea', evaluation.lea)]:
p, r, f1 = evaluation.evaluate_documents(docs, metric)
results[prefix + name] = f1
results[prefix + name + ' precision'] = p
results[prefix + name + ' recall'] = r
muc, b3, ceafe, lea = \
results[prefix + ' muc'], results[prefix + ' b3'], results[prefix + ' ceafe'], results[prefix + ' lea']
conll = (muc + b3 + ceafe) / 3
print "{:} - MUC: {:0.2f} - B3: {:0.2f} - CEAFE: {:0.2f} - LEA {:0.2f} - CoNLL {:0.2f}".format(
prefix, 100 * muc, 100 * b3, 100 * ceafe, 100 * lea, 100 * conll)
results[prefix + ' conll'] = conll
return results
def compute_metrics(docs, prefix):
results = {}
for name, metric in [(' muc', evaluation.muc), (' b3', evaluation.b_cubed),
(' ceafe', evaluation.ceafe),
(' lea', evaluation.lea)]:
p, r, f1 = evaluation.evaluate_documents(docs, metric)
results[prefix + name] = f1
results[prefix + name + ' precision'] = p
results[prefix + name + ' recall'] = r
muc, b3, ceafe, lea = \
results[prefix + ' muc'], results[prefix + ' b3'], results[prefix + ' ceafe'], results[prefix + ' lea']
conll = (muc + b3 + ceafe) / 3
print "{:} - MUC: {:0.2f} - B3: {:0.2f} - CEAFE: {:0.2f} - LEA {:0.2f} - CoNLL {:0.2f}".format(
prefix, 100 * muc, 100 * b3, 100 * ceafe, 100 * lea, 100 * conll)
results[prefix + ' conll'] = conll
return results
def main():
embedding_dir = args.embedding+args.language
print >> sys.stderr,"Read Embedding from %s ..."%embedding_dir
embedding_dimention = 50
if args.language == "cn":
embedding_dimention = 64
w2v = word2vec.Word2Vec(embedding_dir,embedding_dimention)
#network_model
net_dir = "./model/pretrain_ana/network_model_pretrain.cn.3"
#net_dir = "./model/pretrain/network_model_pretrain.cn.10"
#net_dir = "./model/nets/network_model.cn.1"
#net_dir = './model/network_model.cn'
#read_f = file('./model/network_model_pretrain.'+args.language, 'rb')
print >> sys.stderr,"Read model from ./model/network_model."+args.language
read_f = file(net_dir, 'rb')
network_model = cPickle.load(read_f)
#network_model = network.NetWork(1738,855,1000)
train_docs = DataGenerate.doc_data_generater("train")
dev_docs = DataGenerate.doc_data_generater("dev")
test_docs = DataGenerate.doc_data_generater("test")
MAX=5
train4test = [] # add 5 items for testing the training performance
## test performance after pretraining
dev_docs_for_test = []
num = 0
for cases,gold_chain in DataGenerate.case_generater(train_docs,"train",w2v):
#for cases,gold_chain in DataGenerate.case_generater(dev_docs,"dev",w2v):
ev_doc = policy_network.generate_policy_test(cases,gold_chain,network_model)
dev_docs_for_test.append(ev_doc)
train4test.append((cases,gold_chain))
num += 1
if num >= MAX:
break
print "Performance on DATA after PreTRAINING"
mp,mr,mf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print "#################################################"
sys.stdout.flush()
print >> sys.stderr,"Pre Train done"
##train
add2train = True
ran_p = 0.0
l2_lambda = 0.0000003
#l2_lambda = 0.0001
lr = 0.0002
#lr = 0.0
#lr = 0.0001
#ce_lmbda = 0.1
ce_lmbda = 0.0
for echo in range(50):
start_time = timeit.default_timer()
cost_this_turn = 0.0
average_reward = 0.0
done_case_num = 0
#for cases,gold_chain in DataGenerate.case_generater_trick(train_docs,"train",w2v):
for cases,gold_chain in DataGenerate.case_generater(train_docs,"train",w2v):
#for single_mention_array,train_list,lable_list in pretrain.generate_pretrain_case(cases,gold_chain,network_model):
# print lable_list
this_reward = 0.0
reward_baseline = []
zero_num = 0
for single, train, action, reward in policy_network.generate_policy_case(cases,gold_chain,network_model,ran_p):
#for single, train, action, reward , acp in policy_network.generate_policy_case_trick(cases,gold_chain,network_model,ran_p):
reward_b = 0 if len(reward_baseline) < 1 else float(sum(reward_baseline))/float(len(reward_baseline))
norm_reward = reward - reward_b if reward > reward_b else 0.00001
this_reward = reward
this_cost = network_model.train_step(single,train,action,reward,lr,l2_lambda,ce_lmbda,0.0)[0]
#this_cost = network_model.train_step(single,train,action,norm_reward,lr,l2_lambda,ce_lmbda)[0]
#print reward,this_cost
cost_this_turn += this_cost
#print this_cost,acp,reward
#print this_cost
reward_baseline.append(this_reward)
if len(reward_baseline) >= 32:
reward_baselin = reward_baseline[1:]
average_reward += this_reward
done_case_num += 1
if done_case_num >= MAX:
break
print network_model.get_weight_sum()
end_time = timeit.default_timer()
print >> sys.stderr, "Total cost:",cost_this_turn
print >> sys.stderr, "Average Reward:",average_reward/float(done_case_num)
print >> sys.stderr, "TRAINING Use %.3f seconds"%(end_time-start_time)
ran_p = ran_p*0.5
## test training performance
train_docs_for_test = []
start_time = timeit.default_timer()
for train_cases,train_doc_gold_chain in train4test:
ev_doc = policy_network.generate_policy_test(train_cases,train_doc_gold_chain,network_model)
train_docs_for_test.append(ev_doc)
print "** Echo: %d **"%echo
print "TRAIN"
mp,mr,mf = evaluation.evaluate_documents(train_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(train_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(train_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print
sys.stdout.flush()
'''
def get_reward(cluster_info, gold_info, max_cluster_num):
ev_document = get_evaluation_document(cluster_info, gold_info,
max_cluster_num)
p, r, f = evaluation.evaluate_documents([ev_document], evaluation.b_cubed)
return p, r, f
def main():
embedding_dir = args.embedding + args.language
print >> sys.stderr, "Read Embedding from %s ..." % embedding_dir
embedding_dimention = 50
if args.language == "cn":
embedding_dimention = 64
w2v = word2vec.Word2Vec(embedding_dir, embedding_dimention)
#network_model
#net_dir = "./model/pretrain/network_model_pretrain.cn.19"
#net_dir = "./model/pretrain_manu_dropout/network_model_pretrain.cn.10"
if os.path.isfile("./model/network_model." + args.language):
read_f = file('./model/network_model.' + args.language, 'rb')
#read_f = file('./model/network_model_pretrain.'+args.language, 'rb')
#read_f = file('./model/network_model_pretrain.cn.best', 'rb')
#read_f = file(net_dir, 'rb')
network_model = cPickle.load(read_f)
print >> sys.stderr, "Read model from ./model/network_model." + args.language
else:
inpt_dimention = 1738
single_dimention = 855
if args.language == "en":
inpt_dimention = 1374
single_dimention = 673
network_model = network.NetWork(inpt_dimention, single_dimention, 1000)
print >> sys.stderr, "save model ..."
save_f = file('./model/network_model.' + args.language, 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
train_docs = DataGenerate.doc_data_generater("train")
dev_docs = DataGenerate.doc_data_generater("dev")
test_docs = DataGenerate.doc_data_generater("test")
#pretrain
l2_lambda = 0.0000001
lr = 0.03
ce_lambda = 0.0001
dropout_rate = 0.2
print "Weight Sum", network_model.get_weight_sum()
times = 0
#for echo in range(11,40):
for echo in range(10):
start_time = timeit.default_timer()
print "Pretrain ECHO:", echo
cost_this_turn = 0.0
#print >> sys.stderr, network_model.get_weight_sum()
done_num = 0
pos_num = 0
neg_num = 0
for cases, gold_chain in DataGenerate.case_generater(
train_docs, "train", w2v):
if len(cases) >= 700:
continue
for single_mention_array, train_list, lable_list in pretrain.generate_pretrain_case(
cases, gold_chain, network_model):
#cost_this_turn += network_model.pre_train_step(single_mention_array,train_list,lable_list,lr,l2_lambda,dropout_rate)[0]
if lable_list[0] == 1:
neg_num += 1
ana_cost, ana_result = network_model.ana_train_step(
single_mention_array, 1, lr, l2_lambda, dropout_rate)
else:
pos_num += 1
ana_cost, ana_result = network_model.ana_train_step(
single_mention_array, 0, lr, l2_lambda, dropout_rate)
for intance, lable in zip(train_list, lable_list):
mention_cost, mention_result = network_model.mention_train_step(
intance, lable, lr, l2_lambda, dropout_rate)
done_num += 1
if done_num == 10:
break
lr = lr * 0.99
save_f = file(
'./model/pretrain_manu_new/network_model_pretrain_pair.%s.%d' %
(args.language, echo), 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
end_time = timeit.default_timer()
print >> sys.stderr, "PreTrain", echo, "Total cost:", cost_this_turn
print >> sys.stderr, "POS:NEG", pos_num, neg_num
print >> sys.stderr, "lr", lr
print >> sys.stderr, "PreTRAINING Use %.3f seconds" % (end_time -
start_time)
print "Weight Sum", network_model.get_weight_sum()
## test performance after pretraining
dev_docs_for_test = []
num = 0
for cases, gold_chain in DataGenerate.case_generater(
dev_docs, "dev", w2v):
ev_doc = policy_network.generate_policy_test(
cases, gold_chain, network_model)
dev_docs_for_test.append(ev_doc)
num += 1
if num == 10:
break
print "Performance on DEV after PreTRAINING"
mp, mr, mf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print "#################################################"
sys.stdout.flush()
print >> sys.stderr, "Begin Normal Training"
for echo in range(30):
start_time = timeit.default_timer()
print "Pretrain ECHO:", echo
cost_this_turn = 0.0
#print >> sys.stderr, network_model.get_weight_sum()
done_num = 0
pos_num = 0
neg_num = 0
for cases, gold_chain in DataGenerate.case_generater(
train_docs, "train", w2v):
if len(cases) >= 700:
continue
for single_mention_array, train_list, lable_list in pretrain.generate_pretrain_case(
cases, gold_chain, network_model):
cost_this_turn += network_model.pre_train_step(
single_mention_array, train_list, lable_list, lr,
l2_lambda, dropout_rate)[0]
#cost_this_turn += network_model.pre_top_train_step(single_mention_array,train_list,lable_list,lr,l2_lambda)[0]
if lable_list[0] == 1:
neg_num += 1
else:
pos_num += 1
done_num += 1
#if done_num == 10:
# break
lr = lr * 0.99
save_f = file(
'./model/pretrain_manu_new/network_model_pretrain.%s.%d' %
(args.language, echo), 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
end_time = timeit.default_timer()
print >> sys.stderr, "PreTrain", echo, "Total cost:", cost_this_turn
print >> sys.stderr, "POS:NEG", pos_num, neg_num
print >> sys.stderr, "lr", lr
print >> sys.stderr, "PreTRAINING Use %.3f seconds" % (end_time -
start_time)
print "Weight Sum", network_model.get_weight_sum()
## test performance after pretraining
dev_docs_for_test = []
num = 0
for cases, gold_chain in DataGenerate.case_generater(
dev_docs, "dev", w2v):
ev_doc = policy_network.generate_policy_test(
cases, gold_chain, network_model)
dev_docs_for_test.append(ev_doc)
num += 1
if num == 10:
break
print "Performance on DEV after PreTRAINING"
mp, mr, mf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print "#################################################"
sys.stdout.flush()
return
for echo in range(30, 50):
start_time = timeit.default_timer()
cost_this_turn = 0.0
for cases, gold_chain in DataGenerate.case_generater(
train_docs, "train", w2v):
if len(cases) >= 700:
continue
for single_mention_array, train_list, lable_list in pretrain.generate_pretrain_case(
cases, gold_chain, network_model):
cost_this_turn += network_model.pre_ce_train_step(
single_mention_array, train_list, lable_list, lr,
l2_lambda, ce_lambda)[0]
end_time = timeit.default_timer()
print >> sys.stderr, "PreTrain", echo, "Total cost:", cost_this_turn
print >> sys.stderr, "PreTRAINING Use %.3f seconds" % (end_time -
start_time)
print "Weight Sum", network_model.get_weight_sum()
## test performance after pretraining
dev_docs_for_test = []
num = 0
for cases, gold_chain in DataGenerate.case_generater(
dev_docs, "dev", w2v):
ev_doc = policy_network.generate_policy_test(
cases, gold_chain, network_model)
dev_docs_for_test.append(ev_doc)
print "Performance on DEV after PreTRAINING"
mp, mr, mf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print "#################################################"
sys.stdout.flush()
save_f = file(
'./model/pretrain_manu_new/network_model_pretrain.%s.%d' %
(args.language, echo), 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
## test performance after pretraining
print >> sys.stderr, "Begin test on DEV after pertraining"
dev_docs_for_test = []
num = 0
#for dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain in DataGenerate.array_generater(dev_docs,"dev",w2v):
#ev_doc = policy_network.generate_policy_test(dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain,network_model)
for cases, gold_chain in DataGenerate.case_generater(dev_docs, "dev", w2v):
ev_doc = policy_network.generate_policy_test(cases, gold_chain,
network_model)
dev_docs_for_test.append(ev_doc)
print "Performance on DEV after PreTRAINING"
mp, mr, mf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print "#################################################"
sys.stdout.flush()
print >> sys.stderr, "Pre Train done"
def main():
embedding_dir = args.embedding + args.language
print >> sys.stderr, "Read Embedding from %s ..." % embedding_dir
embedding_dimention = 50
if args.language == "cn":
embedding_dimention = 64
w2v = word2vec.Word2Vec(embedding_dir, embedding_dimention)
#network_model_manager
if os.path.isfile("./model/network_model_manager." + args.language):
#read_f = file('./model/network_model_manager.'+args.language, 'rb')
read_f = file(
'./model/network_model_pretrain_manager.' + args.language, 'rb')
network_manager = cPickle.load(read_f)
print >> sys.stderr, "Read model from ./model/network_model_manager." + args.language
else:
inpt_dimention = 1738
single_dimention = 855
cluster_dimention = 855
if args.language == "en":
inpt_dimention = 1374
single_dimention = 673
cluster_dimention = 855
network_manager = network.Manager(inpt_dimention, single_dimention,
1000)
print >> sys.stderr, "save model network_manager..."
save_f = file('./model/network_model_manager.' + args.language, 'wb')
cPickle.dump(network_manager,
save_f,
protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
#network_model_worker
if os.path.isfile("./model/network_model_worker." + args.language):
read_f = file('./model/network_model_worker.' + args.language, 'rb')
#read_f = file('./model/network_model_pretrain_worker.'+args.language, 'rb')
network_worker = cPickle.load(read_f)
print >> sys.stderr, "Read model from ./model/network_model_worker." + args.language
else:
inpt_dimention = 1738
single_dimention = 855
cluster_dimention = 855
if args.language == "en":
inpt_dimention = 1374
single_dimention = 673
cluster_dimention = 855
network_worker = network.Worker(inpt_dimention, single_dimention,
cluster_dimention, 1000)
print >> sys.stderr, "save model network_worker..."
save_f = file('./model/network_model_worker.' + args.language, 'wb')
cPickle.dump(network_worker, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
train_docs = DataGenerate.doc_data_generater("train")
dev_docs = DataGenerate.doc_data_generater("dev")
test_docs = DataGenerate.doc_data_generater("test")
#pretrain_manager
times = 0
best_cost = 99999999
step = 0
lr = 0.00009
for echo in range(10):
start_time = timeit.default_timer()
print "Pretrain ECHO:", echo
cost_this_turn = 0.0
#print >> sys.stderr, network_model.get_weight_sum()
for cases, gold_chain in DataGenerate.case_generater(
train_docs, "train", w2v):
if len(cases) >= 700:
continue
for single_mention_array, train_list, lable_list in pretrain.generate_pretrain_case(
cases, gold_chain):
#cost_this_turn += network_manager.pre_train_step(single_mention_array,train_list,lable_list,0.0001)[0]
cost_this_turn += network_manager.pre_train_step(
single_mention_array, train_list, lable_list, lr)[0]
step += 1
if step % 128 == 0:
lr = lr * 0.99
end_time = timeit.default_timer()
print >> sys.stderr, "PreTrain for Manager", echo, "Total cost:", cost_this_turn
print >> sys.stderr, "PreTraining for Manager Use %.3f seconds" % (
end_time - start_time)
if cost_this_turn <= best_cost:
save_f = file(
'./model/network_model_pretrain_manager_best.' + args.language,
'wb')
cPickle.dump(network_manager,
save_f,
protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
best_cost = cost_this_turn
save_f = file(
'./model/network_model_pretrain_manager.' + args.language, 'wb')
cPickle.dump(network_manager,
save_f,
protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
## test performance after pretraining
print >> sys.stderr, "Begin test on DEV after Manager pertraining"
dev_docs_for_test = []
num = 0
for cases, gold_chain in DataGenerate.case_generater(dev_docs, "dev", w2v):
ev_doc = pretrain.generate_pretrain_test(cases, gold_chain,
network_manager)
dev_docs_for_test.append(ev_doc)
print "Performance on DEV after Manager PreTRAINING"
mp, mr, mf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print "##################################################"
sys.stdout.flush()
print >> sys.stderr, "Manager Pre Train done"
return
#pretrain_worker
times = 0
best_cost = 99999999
for echo in range(20):
start_time = timeit.default_timer()
print "Pretrain ECHO:", echo
cost_this_turn = 0.0
#print >> sys.stderr, network_model.get_weight_sum()
for cases, gold_chain in DataGenerate.case_generater(
train_docs, "train", w2v):
if len(cases) >= 700:
continue
for single_mention_array, train_list, lable_list in pretrain.generate_pretrain_case(
cases, gold_chain, network_model):
cost_this_turn += network_manager.pre_train_step(
single_mention_array, train_list, lable_list, 0.0001)[0]
end_time = timeit.default_timer()
print >> sys.stderr, "PreTrain4Manager", echo, "Total cost:", cost_this_turn
print >> sys.stderr, "PreTraining4Manager Use %.3f seconds" % (
end_time - start_time)
if cost_this_turn <= best_cost:
save_f = file(
'./model/network_model_pretrain_manager_best.' + args.language,
'wb')
cPickle.dump(network_manager,
save_f,
protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
best_cost = cost_this_turn
save_f = file(
'./model/network_model_pretrain_manager.' + args.language, 'wb')
cPickle.dump(network_manager,
save_f,
protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
## test performance after pretraining
print >> sys.stderr, "Begin test on DEV after Manager pertraining"
dev_docs_for_test = []
num = 0
for cases, gold_chain in DataGenerate.case_generater(dev_docs, "dev", w2v):
ev_doc = policy_network.generate_policy_test(cases, gold_chain,
network_manager)
dev_docs_for_test.append(ev_doc)
print "Performance on DEV after Manager PreTRAINING"
mp, mr, mf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print "##################################################"
sys.stdout.flush()
print >> sys.stderr, "Manager Pre Train done"
##train
train4test = [] # add 5 items for testing the training performance
add2train = True
for echo in range(20):
start_time = timeit.default_timer()
reward_baseline = []
cost_this_turn = 0.0
#for train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain in DataGenerate.array_generater(train_docs,"train",w2v):
for cases, gold_chain in DataGenerate.case_generater(
train_docs, "train", w2v):
if add2train:
if random.randint(1, 200) == 10:
#train4test.append((train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain))
train4test.append((cases, gold_chain))
if len(train4test) == 5:
add2train = False
this_reward = 0.0
#for single, train, action, reward in policy_network.generate_policy_case(train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain,network_model):
for single, train, action, reward in policy_network.generate_policy_case(
cases, gold_chain, network_model):
#reward_b = 0 if len(reward_baseline) < 1 else float(sum(reward_baseline))/float(len(reward_baseline))
#norm_reward = numpy.array(reward_batch) - reward_b
cost_this_turn += network_model.train_step(
single, train, action, reward, 0.0001)[0]
end_time = timeit.default_timer()
print >> sys.stderr, "Total cost:", cost_this_turn
print >> sys.stderr, "TRAINING Use %.3f seconds" % (end_time -
start_time)
#reward_baseline.append(this_reward)
#if len(reward_baseline) >= 32:
# reward_baselin = reward_baseline[1:]
## test training performance
train_docs_for_test = []
start_time = timeit.default_timer()
for train_cases, train_doc_gold_chain in train4test:
ev_doc = policy_network.generate_policy_test(
train_cases, train_doc_gold_chain, network_model)
train_docs_for_test.append(ev_doc)
print "** Echo: %d **" % echo
print "TRAIN"
mp, mr, mf = evaluation.evaluate_documents(train_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(train_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(train_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print
## dev
dev_docs_for_test = []
start_time = timeit.default_timer()
#for dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain in DataGenerate.array_generater(dev_docs,"dev",w2v):
#ev_doc = policy_network.generate_policy_test(dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain,network_model)
for dev_cases, dev_doc_gold_chain in DataGenerate.case_generater(
dev_docs, "dev", w2v):
ev_doc = policy_network.generate_policy_test(
dev_cases, dev_doc_gold_chain, network_model)
dev_docs_for_test.append(ev_doc)
print "DEV"
mp, mr, mf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print
end_time = timeit.default_timer()
print >> sys.stderr, "DEV Use %.3f seconds" % (end_time - start_time)
sys.stdout.flush()
## test
test_docs_for_test = []
start_time = timeit.default_timer()
#for test_doc_mention_array,test_doc_pair_array,test_doc_gold_chain in DataGenerate.array_generater(test_docs,"test",w2v):
for test_cases, test_doc_gold_chain in DataGenerate.case_generater(
test_docs, "test", w2v):
ev_doc = policy_network.generate_policy_test(
test_cases, test_doc_gold_chain, network_model)
test_docs_for_test.append(ev_doc)
print "TEST"
mp, mr, mf = evaluation.evaluate_documents(test_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(test_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(test_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print
end_time = timeit.default_timer()
print >> sys.stderr, "TEST Use %.3f seconds" % (end_time - start_time)
sys.stdout.flush()
save_f = file(
'./model/nets/network_model.%s.%d' % (args.language, echo), 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
def main():
DIR = args.DIR
embedding_file = args.embedding_dir
#network_file = "./model/model.pkl"
#network_file = "./model/pretrain/network_model_pretrain.20"
network_file = "./model/pretrain/network_model_pretrain.top.best"
if os.path.isfile(network_file):
print >> sys.stderr, "Read model from ./model/model.pkl"
network_model = torch.load(network_file)
else:
embedding_matrix = numpy.load(embedding_file)
#print len(embedding_matrix)
"Building torch model"
network_model = network.Network(pair_feature_dimention,
mention_feature_dimention,
word_embedding_dimention,
span_dimention, 1000, embedding_size,
embedding_dimention,
embedding_matrix).cuda()
print >> sys.stderr, "save model ..."
torch.save(network_model, network_file)
reduced = ""
if args.reduced == 1:
reduced = "_reduced"
print >> sys.stderr, "prepare data for train ..."
train_docs = DataReader.DataGnerater("train" + reduced)
#train_docs = DataReader.DataGnerater("dev"+reduced)
print >> sys.stderr, "prepare data for dev and test ..."
dev_docs = DataReader.DataGnerater("dev" + reduced)
#test_docs = DataReader.DataGnerater("test"+reduced)
l2_lambda = 1e-6
lr = 0.00002
dropout_rate = 0.5
shuffle = True
times = 0
best_thres = 0.5
reinforce = True
model_save_dir = "./model/pretrain/"
metrics = performance.performance(dev_docs, network_model)
p, r, f = metrics["b3"]
f_b = [f]
#for echo in range(30,200):
for echo in range(20):
start_time = timeit.default_timer()
print "Pretrain Epoch:", echo
#if echo == 100:
# lr = lr/2.0
#if echo == 150:
# lr = lr/2.0
#optimizer = optim.RMSprop(filter(lambda p: p.requires_grad, network_model.parameters()), lr=lr, weight_decay=l2_lambda)
#optimizer = optim.RMSprop(network_model.parameters(), lr=lr, weight_decay=l2_lambda)
cost = 0.0
optimizer = optim.RMSprop(network_model.parameters(),
lr=lr,
eps=1e-5,
weight_decay=l2_lambda)
pair_cost_this_turn = 0.0
ana_cost_this_turn = 0.0
pair_nums = 0
ana_nums = 0
pos_num = 0
neg_num = 0
inside_time = 0.0
score_softmax = nn.Softmax()
cluster_info = []
new_cluster_num = 0
cluster_info.append(-1)
action_list = []
new_cluster_info = []
tmp_data = []
#for data in train_docs.rl_case_generater():
for data in train_docs.rl_case_generater(shuffle=True):
inside_time += 1
this_doc = train_docs
tmp_data.append(data)
mention_word_index, mention_span, candi_word_index,candi_span,feature_pair,pair_antecedents,pair_anaphors,\
target,positive,negative,anaphoricity_word_indexs, anaphoricity_spans, anaphoricity_features, anaphoricity_target,rl,candi_ids_return = data
gold_chain = this_doc.gold_chain[rl["did"]]
gold_dict = {}
for chain in gold_chain:
for item in chain:
gold_dict[item] = chain
mention_index = autograd.Variable(
torch.from_numpy(mention_word_index).type(
torch.cuda.LongTensor))
mention_span = autograd.Variable(
torch.from_numpy(mention_span).type(torch.cuda.FloatTensor))
candi_index = autograd.Variable(
torch.from_numpy(candi_word_index).type(torch.cuda.LongTensor))
candi_spans = autograd.Variable(
torch.from_numpy(candi_span).type(torch.cuda.FloatTensor))
pair_feature = autograd.Variable(
torch.from_numpy(feature_pair).type(torch.cuda.FloatTensor))
anaphors = autograd.Variable(
torch.from_numpy(pair_anaphors).type(torch.cuda.LongTensor))
antecedents = autograd.Variable(
torch.from_numpy(pair_antecedents).type(torch.cuda.LongTensor))
anaphoricity_index = autograd.Variable(
torch.from_numpy(anaphoricity_word_indexs).type(
torch.cuda.LongTensor))
anaphoricity_span = autograd.Variable(
torch.from_numpy(anaphoricity_spans).type(
torch.cuda.FloatTensor))
anaphoricity_feature = autograd.Variable(
torch.from_numpy(anaphoricity_features).type(
torch.cuda.FloatTensor))
output, pair_score = network_model.forward_all_pair(
word_embedding_dimention, mention_index, mention_span,
candi_index, candi_spans, pair_feature, anaphors, antecedents,
dropout_rate)
ana_output, ana_score = network_model.forward_anaphoricity(
word_embedding_dimention, anaphoricity_index,
anaphoricity_span, anaphoricity_feature, dropout_rate)
reindex = autograd.Variable(
torch.from_numpy(rl["reindex"]).type(torch.cuda.LongTensor))
scores_reindex = torch.transpose(
torch.cat((pair_score, ana_score), 1), 0, 1)[reindex]
#scores_reindex = torch.transpose(torch.cat((pair_score,-1-0.3*ana_score),1),0,1)[reindex]
for s, e in zip(rl["starts"], rl["ends"]):
#action_prob: scores_reindex[s:e][1]
score = score_softmax(
torch.transpose(scores_reindex[s:e], 0,
1)).data.cpu().numpy()[0]
this_action = utils.sample_action(score)
#this_action = ac_list.index(max(score.tolist()))
action_list.append(this_action)
if this_action == len(score) - 1:
should_cluster = new_cluster_num
new_cluster_num += 1
new_cluster_info.append(1)
else:
should_cluster = cluster_info[this_action]
new_cluster_info.append(0)
cluster_info.append(should_cluster)
if rl["end"] == True:
ev_document = utils.get_evaluation_document(
cluster_info, this_doc.gold_chain[rl["did"]],
candi_ids_return, new_cluster_num)
p, r, f = evaluation.evaluate_documents([ev_document],
evaluation.b_cubed)
trick_reward = utils.get_reward_trick(cluster_info, gold_dict,
new_cluster_info,
action_list,
candi_ids_return)
#reward = f + trick_reward
average_f = float(sum(f_b)) / len(f_b)
reward = (f - average_f) * 10
f_b.append(f)
if len(f_b) > 128:
f_b = f_b[1:]
index = 0
for data in tmp_data:
mention_word_index, mention_span, candi_word_index,candi_span,feature_pair,pair_antecedents,pair_anaphors,\
target,positive,negative,anaphoricity_word_indexs, anaphoricity_spans, anaphoricity_features, anaphoricity_target,rl,candi_ids_return = data
mention_index = autograd.Variable(
torch.from_numpy(mention_word_index).type(
torch.cuda.LongTensor))
mention_span = autograd.Variable(
torch.from_numpy(mention_span).type(
torch.cuda.FloatTensor))
candi_index = autograd.Variable(
torch.from_numpy(candi_word_index).type(
torch.cuda.LongTensor))
candi_spans = autograd.Variable(
torch.from_numpy(candi_span).type(
torch.cuda.FloatTensor))
pair_feature = autograd.Variable(
torch.from_numpy(feature_pair).type(
torch.cuda.FloatTensor))
anaphors = autograd.Variable(
torch.from_numpy(pair_anaphors).type(
torch.cuda.LongTensor))
antecedents = autograd.Variable(
torch.from_numpy(pair_antecedents).type(
torch.cuda.LongTensor))
anaphoricity_index = autograd.Variable(
torch.from_numpy(anaphoricity_word_indexs).type(
torch.cuda.LongTensor))
anaphoricity_span = autograd.Variable(
torch.from_numpy(anaphoricity_spans).type(
torch.cuda.FloatTensor))
anaphoricity_feature = autograd.Variable(
torch.from_numpy(anaphoricity_features).type(
torch.cuda.FloatTensor))
rl_costs = autograd.Variable(
torch.from_numpy(rl["costs"]).type(
torch.cuda.FloatTensor))
rl_costs = torch.transpose(rl_costs, 0, 1)
output, pair_score = network_model.forward_all_pair(
word_embedding_dimention, mention_index, mention_span,
candi_index, candi_spans, pair_feature, anaphors,
antecedents, dropout_rate)
ana_output, ana_score = network_model.forward_anaphoricity(
word_embedding_dimention, anaphoricity_index,
anaphoricity_span, anaphoricity_feature, dropout_rate)
reindex = autograd.Variable(
torch.from_numpy(rl["reindex"]).type(
torch.cuda.LongTensor))
optimizer.zero_grad()
loss = None
scores_reindex = torch.transpose(
torch.cat((pair_score, ana_score), 1), 0, 1)[reindex]
#scores_reindex = torch.transpose(torch.cat((pair_score,-1-0.3*ana_score),1),0,1)[reindex]
for s, e in zip(rl["starts"], rl["ends"]):
#action_prob: scores_reindex[s:e][1]
this_action = action_list[index]
#current_reward = reward + trick_reward[index]
current_reward = reward
#this_loss = -reward*(torch.transpose(F.log_softmax(torch.transpose(scores_reindex[s:e],0,1)),0,1)[this_action])
this_loss = -current_reward * (torch.transpose(
F.log_softmax(
torch.transpose(scores_reindex[s:e], 0, 1)), 0,
1)[this_action])
if loss is None:
loss = this_loss
else:
loss += this_loss
index += 1
#loss /= len(rl["starts"])
loss /= len(rl["starts"])
#loss = loss/train_docs.scale_factor
## policy graident
cost += loss.data[0]
loss.backward()
optimizer.step()
new_cluster_num = 0
cluster_info = []
cluster_info.append(-1)
tmp_data = []
action_list = []
new_cluster_info = []
#if inside_time%50 == 0:
# performance.performance(dev_docs,network_model)
# print
# sys.stdout.flush()
end_time = timeit.default_timer()
print >> sys.stderr, "PreTRAINING Use %.3f seconds" % (end_time -
start_time)
print >> sys.stderr, "cost:", cost
#print >> sys.stderr,"save model ..."
#torch.save(network_model, model_save_dir+"network_model_pretrain.%d"%echo)
performance.performance(dev_docs, network_model)
sys.stdout.flush()
def main():
embedding_dir = args.embedding+args.language
print >> sys.stderr,"Read Embedding from %s ..."%embedding_dir
embedding_dimention = 50
if args.language == "cn":
embedding_dimention = 64
w2v = word2vec.Word2Vec(embedding_dir,embedding_dimention)
#network_model
if os.path.isfile("./model/network_model."+args.language):
read_f = file('./model/network_model.'+args.language, 'rb')
#read_f = file('./model/network_model_pretrain.'+args.language, 'rb')
network_model = cPickle.load(read_f)
print >> sys.stderr,"Read model from ./model/network_model."+args.language
else:
inpt_dimention = 1738
single_dimention = 855
if args.language == "en":
inpt_dimention = 1374
single_dimention = 673
network_model = network.NetWork(inpt_dimention,single_dimention,1000)
print >> sys.stderr,"save model ..."
save_f = file('./model/network_model.'+args.language, 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
train_docs = DataGenerate.doc_data_generater("train")
dev_docs = DataGenerate.doc_data_generater("dev")
test_docs = DataGenerate.doc_data_generater("test")
most_time = 100
most_time_test = 50
#pretrain
for echo in range(10):
start_time = timeit.default_timer()
print "Pretrain ECHO:",echo
cost_this_turn = 0.0
num = most_time
#print >> sys.stderr, network_model.get_weight_sum()
for train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain in DataGenerate.array_generater(train_docs,"train",w2v):
num -= 1
if num <= 0:
break
for single_mention_array,train_list,lable_list in pretrain.generate_pretrain_case(train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain,network_model):
#print single_mention_array
cost_this_turn += network_model.pre_train_step(single_mention_array,train_list,lable_list,0.0003)[0]
for dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain in DataGenerate.array_generater(train_docs,"train",w2v):
ev_doc = policy_network.generate_policy_test(dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain,network_model)
break
print network_model.get_weight_sum()
end_time = timeit.default_timer()
print >> sys.stderr, "PreTrain",echo,"Total cost:",cost_this_turn
print >> sys.stderr, "PreTRAINING Use %.3f seconds"%(end_time-start_time)
save_f = file('./model/network_model_pretrain.'+args.language, 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
print >> sys.stderr,"Begin test on DEV after pertraining"
## test performance on dev after pretraining
dev_docs_for_test = []
num = most_time_test
#for dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain in DataGenerate.array_generater(dev_docs,"dev",w2v):
for dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain in DataGenerate.array_generater(train_docs,"train",w2v):
num -= 1
if num <= 0:
break
ev_doc = policy_network.generate_policy_test(dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain,network_model)
dev_docs_for_test.append(ev_doc)
print "Performance on TRAIN after PreTRAINING"
mp,mr,mf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print "##################################################"
sys.stdout.flush()
print >> sys.stderr,"Pre Train done"
## test performance on dev after pretraining
dev_docs_for_test = []
num = most_time_test
for dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain in DataGenerate.array_generater(dev_docs,"dev",w2v):
num -= 1
if num <= 0:
break
ev_doc = policy_network.generate_policy_test(dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain,network_model)
dev_docs_for_test.append(ev_doc)
print "Performance on DEV after PreTRAINING"
mp,mr,mf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print "##################################################"
sys.stdout.flush()
print >> sys.stderr,"Pre Train done"
return
##train
train4test = [] # add 5 items for testing the training performance
add2train = True
for echo in range(20):
start_time = timeit.default_timer()
reward_baseline = []
cost_this_turn = 0.0
trick_num = 0
for train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain in DataGenerate.array_generater(train_docs,"train",w2v):
#trick_num += 1
#if trick_num < 80:
# continue
if add2train:
if random.randint(1,200) == 100:
train4test.append((train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain))
if len(train4test) == 5:
add2train = False
this_reward = 0.0
#for train_batch, mask_batch, action_batch, reward_batch in policy_network.generate_policy_case(train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain,network_model):
for single, train, action, reward in policy_network.generate_policy_case(train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain,network_model):
#this_reward = reward_batch
#reward_b = 0 if len(reward_baseline) < 1 else float(sum(reward_baseline))/float(len(reward_baseline))
#norm_reward = numpy.array(reward_batch) - reward_b
#cost_this_turn += network_model.train_step(train_batch,mask_batch,action_batch,norm_reward,0.0001)[0]
cost_this_turn += network_model.train_step(single,train,action,reward,0.0001)[0]
end_time = timeit.default_timer()
print >> sys.stderr, "Total cost:",cost_this_turn
print >> sys.stderr, "TRAINING Use %.3f seconds"%(end_time-start_time)
#reward_baseline.append(this_reward)
#if len(reward_baseline) >= 32:
# reward_baselin = reward_baseline[1:]
## test training performance
train_docs_for_test = []
start_time = timeit.default_timer()
for train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain in train4test:
ev_doc = policy_network.generate_policy_test(train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain,network_model)
train_docs_for_test.append(ev_doc)
print "** Echo: %d **"%echo
print "TRAIN"
mp,mr,mf = evaluation.evaluate_documents(train_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(train_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(train_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print
## dev
dev_docs_for_test = []
start_time = timeit.default_timer()
for dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain in DataGenerate.array_generater(dev_docs,"dev",w2v):
ev_doc = policy_network.generate_policy_test(dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain,network_model)
dev_docs_for_test.append(ev_doc)
print "DEV"
mp,mr,mf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print
end_time = timeit.default_timer()
print >> sys.stderr, "DEV Use %.3f seconds"%(end_time-start_time)
sys.stdout.flush()
## test
test_docs_for_test = []
start_time = timeit.default_timer()
for test_doc_mention_array,test_doc_pair_array,test_doc_gold_chain in DataGenerate.array_generater(test_docs,"test",w2v):
ev_doc = policy_network.generate_policy_test(test_doc_mention_array,test_doc_pair_array,test_doc_gold_chain,network_model)
test_docs_for_test.append(ev_doc)
print "TEST"
mp,mr,mf = evaluation.evaluate_documents(test_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(test_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(test_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print
end_time = timeit.default_timer()
print >> sys.stderr, "TEST Use %.3f seconds"%(end_time-start_time)
sys.stdout.flush()
save_f = file('./model/nets/network_model.%s.%d'%(args.language,echo), 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
def main():
embedding_dir = args.embedding + args.language
print >> sys.stderr, "Read Embedding from %s ..." % embedding_dir
embedding_dimention = 50
if args.language == "cn":
embedding_dimention = 64
w2v = word2vec.Word2Vec(embedding_dir + ".filtered", embedding_dimention)
#network_model
if os.path.isfile("./model/network_model_index." + args.language):
read_f = file('./model/network_model_index.' + args.language, 'rb')
#read_f = file('./model/network_model_pretrain.'+args.language, 'rb')
network_model = cPickle.load(read_f)
print >> sys.stderr, "Read model from ./model/network_model_index." + args.language
else:
inpt_dimention = 1738
single_dimention = 855
if args.language == "en":
inpt_dimention = 1374
single_dimention = 673
network_model = network.NetWork(inpt_dimention, single_dimention, 1000,
embedding_dir + ".filtered",
embedding_dimention)
print >> sys.stderr, "save model ..."
save_f = file('./model/network_model_index.' + args.language, 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
train_docs = DataGenerate.doc_data_generater("train")
dev_docs = DataGenerate.doc_data_generater("dev")
test_docs = DataGenerate.doc_data_generater("test")
#pretrain
times = 0
for echo in range(20):
start_time = timeit.default_timer()
print "Pretrain ECHO:", echo
cost_this_turn = 0.0
for cases, gold_chain in DataGenerate.case_generater(
train_docs, "train", w2v):
if len(cases) >= 700:
continue
for single_mention_array, single_index, train_list, train_index, lable_list in pretrain.generate_pretrain_case(
cases, gold_chain, network_model):
print network_model.fff(train_list, train_index)
cost_this_turn += network_model.pre_train_step(
single_mention_array, single_index, train_list,
train_index, lable_list, 0.0001)[0]
end_time = timeit.default_timer()
print >> sys.stderr, "PreTrain", echo, "Total cost:", cost_this_turn
print >> sys.stderr, "PreTRAINING Use %.3f seconds" % (end_time -
start_time)
if echo % 4 == 0:
save_f = file(
'./model/network_model_pretrain_index.' + args.language, 'wb')
cPickle.dump(network_model,
save_f,
protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
save_f = file('./model/network_model_pretrain_index.' + args.language,
'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
print >> sys.stderr, "Begin test on DEV after pertraining"
## test performance after pretraining
dev_docs_for_test = []
num = 0
for cases, gold_chain in DataGenerate.case_generater(dev_docs, "dev", w2v):
ev_doc = policy_network.generate_policy_test(cases, gold_chain,
network_model)
dev_docs_for_test.append(ev_doc)
print "Performance on DEV after PreTRAINING"
mp, mr, mf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print "##################################################"
sys.stdout.flush()
print >> sys.stderr, "Pre Train done"
##train
train4test = [] # add 5 items for testing the training performance
add2train = True
for echo in range(20):
start_time = timeit.default_timer()
reward_baseline = []
cost_this_turn = 0.0
for cases, gold_chain in DataGenerate.case_generater(
train_docs, "train", w2v):
if add2train:
if random.randint(1, 200) == 10:
#train4test.append((train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain))
train4test.append((cases, gold_chain))
if len(train4test) == 5:
add2train = False
this_reward = 0.0
for single, sindex, train, tindex, action, reward in policy_network.generate_policy_case(
cases, gold_chain, network_model):
cost_this_turn += network_model.train_step(
single, sindex, train, tindex, action, reward, 0.0001)[0]
end_time = timeit.default_timer()
print >> sys.stderr, "Total cost:", cost_this_turn
print >> sys.stderr, "TRAINING Use %.3f seconds" % (end_time -
start_time)
## test training performance
train_docs_for_test = []
start_time = timeit.default_timer()
for train_cases, train_doc_gold_chain in train4test:
ev_doc = policy_network.generate_policy_test(
train_cases, train_doc_gold_chain, network_model)
train_docs_for_test.append(ev_doc)
print "** Echo: %d **" % echo
print "TRAIN"
mp, mr, mf = evaluation.evaluate_documents(train_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(train_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(train_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print
## dev
dev_docs_for_test = []
start_time = timeit.default_timer()
#for dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain in DataGenerate.array_generater(dev_docs,"dev",w2v):
#ev_doc = policy_network.generate_policy_test(dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain,network_model)
for dev_cases, dev_doc_gold_chain in DataGenerate.case_generater(
dev_docs, "dev", w2v):
ev_doc = policy_network.generate_policy_test(
dev_cases, dev_doc_gold_chain, network_model)
dev_docs_for_test.append(ev_doc)
print "DEV"
mp, mr, mf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(dev_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print
end_time = timeit.default_timer()
print >> sys.stderr, "DEV Use %.3f seconds" % (end_time - start_time)
sys.stdout.flush()
## test
test_docs_for_test = []
start_time = timeit.default_timer()
#for test_doc_mention_array,test_doc_pair_array,test_doc_gold_chain in DataGenerate.array_generater(test_docs,"test",w2v):
for test_cases, test_doc_gold_chain in DataGenerate.case_generater(
test_docs, "test", w2v):
ev_doc = policy_network.generate_policy_test(
test_cases, test_doc_gold_chain, network_model)
test_docs_for_test.append(ev_doc)
print "TEST"
mp, mr, mf = evaluation.evaluate_documents(test_docs_for_test,
evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f" % (mr, mp, mf)
bp, br, bf = evaluation.evaluate_documents(test_docs_for_test,
evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f" % (br, bp, bf)
cp, cr, cf = evaluation.evaluate_documents(test_docs_for_test,
evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f" % (cr, cp, cf)
print
end_time = timeit.default_timer()
print >> sys.stderr, "TEST Use %.3f seconds" % (end_time - start_time)
sys.stdout.flush()
'''
def main():
embedding_dir = args.embedding+args.language
print >> sys.stderr,"Read Embedding from %s ..."%embedding_dir
embedding_dimention = 50
if args.language == "cn":
embedding_dimention = 64
w2v = word2vec.Word2Vec(embedding_dir,embedding_dimention)
#network_model
net_dir = "./model/pretrain_batch/network_model_pretrain.cn.9"
if os.path.isfile("./model/network_model_batch."+args.language):
#read_f = file('./model/network_model_batch.'+args.language, 'rb')
#read_f = file('./model/network_model_pretrain.'+args.language, 'rb')
#read_f = file('./model/network_model_pretrain.cn.best', 'rb')
read_f = file(net_dir, 'rb')
network_model = cPickle.load(read_f)
print >> sys.stderr,"Read model from ./model/network_model_batch."+args.language
else:
inpt_dimention = 1738
single_dimention = 855
if args.language == "en":
inpt_dimention = 1374
single_dimention = 673
network_model = network.NetWork(inpt_dimention,single_dimention,1000)
print >> sys.stderr,"save model ..."
save_f = file('./model/network_model_batch.'+args.language, 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
train_docs = DataGenerate.doc_data_generater("train")
dev_docs = DataGenerate.doc_data_generater("dev")
test_docs = DataGenerate.doc_data_generater("test")
#pretrain
l2_lambda = 0.0000003
lr = 0.00002
ce_lambda = 0.005
times = 0
for echo in range(0):
start_time = timeit.default_timer()
print "Pretrain ECHO:",echo
cost_this_turn = 0.0
#print >> sys.stderr, network_model.get_weight_sum()
for cases,gold_chain in DataGenerate.case_generater(train_docs,"train",w2v):
if len(cases) >= 700:
continue
for train_list,single_mention_array,mask_list,lable_list in pretrain.generate_pretrain_case_batch(cases,gold_chain,network_model):
cost_this_turn += network_model.pre_train_step(single_mention_array,train_list,mask_list,lable_list,lr,l2_lambda)[0]
end_time = timeit.default_timer()
print >> sys.stderr, "PreTrain",echo,"Total cost:",cost_this_turn
print >> sys.stderr, "PreTRAINING Use %.3f seconds"%(end_time-start_time)
save_f = file('./model/pretrain_batch/network_model_pretrain_noNorm.%s.%d'%(args.language,echo), 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
for echo in range(0):
start_time = timeit.default_timer()
cost_this_turn = 0.0
for cases,gold_chain in DataGenerate.case_generater(train_docs,"train",w2v):
if len(cases) >= 700:
continue
for train_list,single_mention_array,mask_list,lable_list in pretrain.generate_pretrain_case_batch(cases,gold_chain,network_model):
cost_this_turn += network_model.pre_ce_train_step(single_mention_array,train_list,mask_list,lable_list,lr,l2_lambda,ce_lambda)[0]
save_f = file('./model/pretrain_batch/network_model_pretrain.%s.%d'%(args.language,echo), 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
end_time = timeit.default_timer()
print >> sys.stderr, "PreTrain",echo,"Total cost:",cost_this_turn
print >> sys.stderr, "PreTRAINING Use %.3f seconds"%(end_time-start_time)
print >> sys.stderr,"Begin test on DEV after pertraining"
## test performance after pretraining
dev_docs_for_test = []
num = 0
#for dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain in DataGenerate.array_generater(dev_docs,"dev",w2v):
#ev_doc = policy_network.generate_policy_test(dev_doc_mention_array,dev_doc_pair_array,dev_doc_gold_chain,network_model)
for cases,gold_chain in DataGenerate.case_generater(dev_docs,"dev",w2v):
ev_doc = policy_network.generate_policy_test(cases,gold_chain,network_model)
dev_docs_for_test.append(ev_doc)
print "Performance on DEV after PreTRAINING"
mp,mr,mf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print "#################################################"
sys.stdout.flush()
print >> sys.stderr,"Pre Train done"
##train
train4test = [] # add 5 items for testing the training performance
add2train = True
for echo in range(10):
start_time = timeit.default_timer()
reward_baseline = []
cost_this_turn = 0.0
average_reward = 0.0
done_case_num = 0
l2_lambda = 0.000003
lr = 0.000002
ce_lambda = 0.0
for cases,gold_chain in DataGenerate.case_generater(train_docs,"train",w2v):
if len(cases) >= 700:
continue
if add2train:
if random.randint(1,200) == 10:
#if not random.randint(1,200) == 10:
#train4test.append((train_doc_mention_array,train_doc_pair_array,train_doc_gold_chain))
train4test.append((cases,gold_chain))
if len(train4test) == 20:
add2train = False
this_reward = 0.0
reward_b = 0 if len(reward_baseline) < 1 else float(sum(reward_baseline))/float(len(reward_baseline))
for train, single, mask, action, reward in policy_network.generate_policy_case(cases,gold_chain,network_model):
if len(train) <= 1:
continue
#for single, train, action, reward , acp in policy_network.generate_policy_case_trick(cases,gold_chain,network_model):
norm_reward = reward - reward_b
this_reward = reward
this_cost = network_model.train_step(single,train,mask,action,reward*100,lr,l2_lambda,ce_lambda)[0]
#print this_cost,acp,reward
cost_this_turn += this_cost
average_reward += this_reward
done_case_num += 1
#if done_case_num >= 1:
# break
print network_model.get_weight_sum()
end_time = timeit.default_timer()
print >> sys.stderr, "Total cost:",cost_this_turn
print >> sys.stderr, "Average Reward:",average_reward/float(done_case_num)
print >> sys.stderr, "TRAINING Use %.3f seconds"%(end_time-start_time)
reward_baseline.append(this_reward)
if len(reward_baseline) >= 64:
reward_baselin = reward_baseline[1:]
## test training performance
train_docs_for_test = []
start_time = timeit.default_timer()
for train_cases,train_doc_gold_chain in train4test:
ev_doc = policy_network.generate_policy_test(train_cases,train_doc_gold_chain,network_model)
train_docs_for_test.append(ev_doc)
print "** Echo: %d **"%echo
print "TRAIN"
mp,mr,mf = evaluation.evaluate_documents(train_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(train_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(train_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print
## dev
dev_docs_for_test = []
start_time = timeit.default_timer()
for dev_cases,dev_doc_gold_chain in DataGenerate.case_generater(dev_docs,"dev",w2v):
ev_doc = policy_network.generate_policy_test(dev_cases,dev_doc_gold_chain,network_model)
dev_docs_for_test.append(ev_doc)
print "DEV"
mp,mr,mf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(dev_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print
end_time = timeit.default_timer()
print >> sys.stderr, "DEV Use %.3f seconds"%(end_time-start_time)
sys.stdout.flush()
## test
test_docs_for_test = []
start_time = timeit.default_timer()
#for test_doc_mention_array,test_doc_pair_array,test_doc_gold_chain in DataGenerate.array_generater(test_docs,"test",w2v):
for test_cases,test_doc_gold_chain in DataGenerate.case_generater(test_docs,"test",w2v):
ev_doc = policy_network.generate_policy_test(test_cases,test_doc_gold_chain,network_model)
test_docs_for_test.append(ev_doc)
print "TEST"
mp,mr,mf = evaluation.evaluate_documents(test_docs_for_test,evaluation.muc)
print "MUC: recall: %f precision: %f f1: %f"%(mr,mp,mf)
bp,br,bf = evaluation.evaluate_documents(test_docs_for_test,evaluation.b_cubed)
print "BCUBED: recall: %f precision: %f f1: %f"%(br,bp,bf)
cp,cr,cf = evaluation.evaluate_documents(test_docs_for_test,evaluation.ceafe)
print "CEAF: recall: %f precision: %f f1: %f"%(cr,cp,cf)
print
end_time = timeit.default_timer()
print >> sys.stderr, "TEST Use %.3f seconds"%(end_time-start_time)
sys.stdout.flush()
save_f = file('./model/nets/network_model_batch.%s.%d'%(args.language,echo), 'wb')
cPickle.dump(network_model, save_f, protocol=cPickle.HIGHEST_PROTOCOL)
save_f.close()
