def generate_gan(sess, model, loss_type="pair", negative_size=3):
samples = []
for _index, pair in enumerate(raw):
if _index % 100 == 0:
print("have sampled %d pairs" % _index)
q = pair[2]
a = pair[3]
neg_alist_index = [i for i in range(len(alist))]
neg_alist_index.remove(_index) # remove the positive index
sampled_index = np.random.choice(neg_alist_index, size=[FLAGS.pools_size], replace=False)
pools = np.array(alist)[sampled_index]
canditates = insurance_qa_data_helpers.loadCandidateSamples(q, a, pools, vocab)
predicteds = []
for batch in insurance_qa_data_helpers.batch_iter(canditates, batch_size=FLAGS.batch_size):
feed_dict = {model.input_x_1: batch[:, 0], model.input_x_2: batch[:, 1], model.input_x_3: batch[:, 2]}
predicted = sess.run(model.gan_score, feed_dict)
predicteds.extend(predicted)
# index=np.argmax(predicteds)
# samples.append([encode_sent(vocab,item, FLAGS.max_sequence_length) for item in [q,a,pools[index]]])
exp_rating = np.exp(np.array(predicteds) * FLAGS.sampled_temperature * 1.5)
prob = exp_rating / np.sum(exp_rating)
neg_samples = np.random.choice(pools, size=negative_size, p=prob, replace=False)
for neg in neg_samples:
samples.append([encode_sent(vocab, item, FLAGS.max_sequence_length) for item in [q, a, neg]])
return samples
def main():
with tf.Graph().as_default():
with tf.device("/gpu:0"):
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default(), open(precision, "w") as log:
# DIS_MODEL_FILE="model/Discriminator20170107122042.model"
# param = pickle.load(open(DIS_MODEL_FILE))
# print( param)
param = None
DIS_MODEL_FILE = "model/pre-trained.model"
param = pickle.load(open(DIS_MODEL_FILE, "rb"))
discriminator = Discriminator.Discriminator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=len(vocab),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
learning_rate=FLAGS.learning_rate,
l2_reg_lambda=FLAGS.l2_reg_lambda,
embeddings=None,
paras=param,
loss="pair")
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
# evaluation(sess,discriminator,log,0)
for i in range(FLAGS.num_epochs):
# x1,x2,x3=generate_dns(sess,discriminator)
# samples=generate_dns(sess,discriminator)#generate_uniform_pair() #generate_dns(sess,discriminator) #generate_uniform() #
samples = generate_dns_pair(
sess, discriminator
) #generate_uniform() # generate_uniform_pair() #
for j in range(1):
for batch in insurance_qa_data_helpers.batch_iter(
samples,
batch_size=FLAGS.batch_size,
num_epochs=1,
shuffle=True): # try:
feed_dict = {
discriminator.input_x_1: batch[:, 0],
discriminator.input_x_2: batch[:, 1],
discriminator.input_x_3: batch[:, 2],
}
_, step, current_loss, accuracy = sess.run([
discriminator.train_op,
discriminator.global_step, discriminator.loss,
discriminator.accuracy
], feed_dict)
time_str = datetime.datetime.now().isoformat()
print(("%s: DIS step %d, loss %f with acc %f " %
(time_str, step, current_loss, accuracy)))
evaluation(sess, discriminator, log, i)
def generate_dns_pair(sess, model):
samples = []
for _index, pair in enumerate(raw):
if _index % 100 == 0:
print("have sampled %d pairs" % _index)
q = pair[2]
a = pair[3]
pools = np.random.choice(alist, size=[FLAGS.pools_size])
canditates = insurance_qa_data_helpers.loadCandidateSamples(
q, a, pools, vocab)
predicteds = []
for batch in insurance_qa_data_helpers.batch_iter(
canditates, batch_size=FLAGS.batch_size):
feed_dict = {
model.input_x_1: batch[:, 0],
model.input_x_2: batch[:, 1],
model.input_x_3: batch[:, 2]
}
predicted = sess.run(model.score13, feed_dict)
predicteds.extend(predicted)
index = np.argmax(predicteds)
samples.append([
encode_sent(vocab, item, FLAGS.max_sequence_length)
for item in [q, a, pools[index]]
])
return samples
def generate_dns_pair(sess, model):
samples = []
for _index, pair in enumerate(raw):
#ループ内は１組のqaについて扱う
if _index % 100 == 0:
print("have sampled %d pairs" % _index)
q = pair[2]
a = pair[3]
pools = np.random.choice(alist, size=[FLAGS.pools_size])
#1qaペアにつき、プールサイズ(100)分のneg
canditates = insurance_qa_data_helpers.loadCandidateSamples(
q, a, pools, vocab)
predicteds = []
for batch in insurance_qa_data_helpers.batch_iter(
canditates, batch_size=FLAGS.batch_size):
#batchサイズ(100)分: (q,a,neg1),...,(q,a,negバッチサイズ)
#batch[:,0]にはバッチサイズ分のq、batch[:,1]はa、batch[:.2]はneg。
feed_dict = {
model.input_x_1: batch[:, 0],
model.input_x_2: batch[:, 1],
model.input_x_3: batch[:, 2]
}
predicted = sess.run(model.score13, feed_dict) #score13はcos(q,neg)
predicteds.extend(predicted)
index = np.argmax(predicteds)
samples.append([
encode_sent(vocab, item, FLAGS.max_sequence_length)
for item in [q, a, pools[index]]
])
return samples
def generate_gan(sess, model, raw_loop, alist_loop, loss_type="pair",negative_size=3):
samples=[]
for _index ,pair in enumerate (raw_loop):
if _index %100==0:
print( "have sampled %d pairs" % _index)
q=pair[0]
a=pair[1]
neg_alist_index=[i for i in range(len(alist_loop))]
neg_alist_index.remove(_index) #remove the positive index
simq = []
head = _index - 1
while head >= 0 and raw_loop[head][0] == q:
simq.append(raw_loop[head][1])
neg_alist_index.remove(head)
head -= 1
tail = _index + 1
while tail < len(raw_loop) and raw_loop[tail][0] == q:
simq.append(raw_loop[tail][1])
neg_alist_index.remove(tail)
tail += 1
while head >= 0 and raw_loop[head][1] in simq:
neg_alist_index.remove(head)
head -= 1
while tail < len(raw_loop) and raw_loop[tail][1] in simq:
neg_alist_index.remove(tail)
tail += 1
sampled_index=np.random.choice(neg_alist_index,size=[FLAGS.pools_size],replace= False)
pools=np.array(alist_loop)[sampled_index]
canditates=insurance_qa_data_helpers.loadCandidateSamples(q,a,pools)
predicteds=[]
for batch in insurance_qa_data_helpers.batch_iter(canditates,batch_size=FLAGS.batch_size):
feed_dict = {model.input_x_1: batch[:,0],model.input_x_2: batch[:,1],model.input_x_3: batch[:,2]}
predicted=sess.run(model.gan_score,feed_dict)
predicteds.extend(predicted)
# index=np.argmax(predicteds)
# samples.append([encode_sent(vocab,item, FLAGS.max_sequence_length) for item in [q,a,pools[index]]])
exp_rating = np.exp(np.array(predicteds)*FLAGS.sampled_temperature*1.5)
prob = exp_rating / np.sum(exp_rating)
neg_samples_index = np.random.choice(np.arange(len(pools)), size= negative_size,p=prob,replace=False)
for neg in neg_samples_index:
samples.append([q, a, pools[neg]])
return samples
def main():
with tf.Graph().as_default():
with tf.device("/cpu:0"):
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default(), open(log_precision, "w") as log, open(
loss_precision, "w") as loss_log:
DIS_MODEL_FILE = "/home/haojianyong/file_1/irgan-master/Question-Answer/model/pre-trained.model" # overfitted DNS
param = pickle.load(open(DIS_MODEL_FILE, "rb"))
loss_type = "pair"
discriminator = Discriminator.Discriminator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=len(vocab),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
learning_rate=FLAGS.learning_rate,
l2_reg_lambda=FLAGS.l2_reg_lambda,
# embeddings=embeddings,
embeddings=None,
paras=param,
loss=loss_type)
generator = Generator.Generator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=len(vocab),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
learning_rate=FLAGS.learning_rate * 0.1,
l2_reg_lambda=FLAGS.l2_reg_lambda,
# embeddings=embeddings,
embeddings=None,
paras=param,
loss=loss_type)
sess.run(tf.global_variables_initializer())
# evaluation(sess,discriminator,log,0)
for i in range(FLAGS.num_epochs):
if i > 0:
samples = generate_gan(sess, generator)
# for j in range(FLAGS.d_epochs_num):
for _index, batch in enumerate(
insurance_qa_data_helpers.batch_iter(
samples,
num_epochs=FLAGS.d_epochs_num,
batch_size=FLAGS.batch_size,
shuffle=True)): # try:
feed_dict = {
discriminator.input_x_1: batch[:, 0],
discriminator.input_x_2: batch[:, 1],
discriminator.input_x_3: batch[:, 2]
}
_, step, current_loss, accuracy = sess.run([
discriminator.train_op,
discriminator.global_step, discriminator.loss,
discriminator.accuracy
], feed_dict)
line = ("%s: DIS step %d, loss %f with acc %f " %
(datetime.datetime.now().isoformat(), step,
current_loss, accuracy))
if _index % 10 == 0:
print(line)
loss_log.write(line + "\n")
loss_log.flush()
evaluation(sess, discriminator, log, i)
for g_epoch in range(FLAGS.g_epochs_num): ## 1
print("start generator...")
loss_log.write("QA pairs have " + str(len(raw)) + "\n")
for _index, pair in enumerate(raw):
q = pair[2]
a = pair[3]
neg_alist_index = [
item for item in range(len(alist))
] ## [0,1,2,3,...,18540-1]
sampled_index = np.random.choice(
neg_alist_index,
size=[FLAGS.pools_size - 1],
replace=False) ## choose negative examples: 99
sampled_index = list(sampled_index)
sampled_index.append(_index)
pools = np.array(
alist
)[sampled_index] # 随机选取alist中的99个语句,同时包含了自己的后一个match语句, 作为候选语句
samples = insurance_qa_data_helpers.loadCandidateSamples(
q, a, pools,
vocab) # 同上:1+99=100, [q,a,candidate], 编码转换为向量
## 1
predicteds = []
for batch in insurance_qa_data_helpers.batch_iter(
samples, batch_size=FLAGS.batch_size):
feed_dict = {
generator.input_x_1: batch[:, 0],
generator.input_x_2: batch[:, 1],
generator.input_x_3: batch[:, 2]
}
predicted = sess.run(generator.gan_score,
feed_dict)
predicteds.extend(predicted)
exp_rating = np.exp(
np.array(predicteds) *
FLAGS.sampled_temperature)
prob = exp_rating / np.sum(exp_rating)
## 2
neg_index = np.random.choice(
np.arange(len(pools)),
size=FLAGS.gan_k,
p=prob,
replace=False
) # 在100个例子中按照prob生成 FLAGS.gan_k个负例
subsamples = np.array(
insurance_qa_data_helpers.loadCandidateSamples(
q, a, pools[neg_index], vocab))
feed_dict = {
discriminator.input_x_1: subsamples[:, 0],
discriminator.input_x_2: subsamples[:, 1],
discriminator.input_x_3: subsamples[:, 2]
}
reward = sess.run(
discriminator.reward, feed_dict
) # reward= 2 * (tf.sigmoid( score_13 ) - 0.5)
## 3
samples = np.array(samples)
feed_dict = {
generator.input_x_1: samples[:, 0],
generator.input_x_2: samples[:, 1],
generator.neg_index: neg_index,
generator.input_x_3: samples[:, 2],
generator.reward: reward
}
_, step, current_loss, positive, negative = sess.run( # 应该是全集上的softmax 但是此处做全集的softmax开销太大了
[
generator.gan_updates,
generator.global_step, generator.gan_loss,
generator.positive, generator.negative
], # self.prob= tf.nn.softmax(self.cos_13)
feed_dict
) # self.gan_loss = -tf.reduce_mean(tf.log(self.prob) * self.reward)
line = (
"%s: GEN step %d, loss %f positive %f negative %f"
% (datetime.datetime.now().isoformat(), step,
current_loss, positive, negative))
if _index % 100 == 0:
print(line)
loss_log.write(line + "\n")
loss_log.flush()
evaluation(sess, generator, log,
i * FLAGS.g_epochs_num + g_epoch)
log.flush()
def main():
with tf.Graph().as_default():
with tf.device("/gpu"):
session_conf = tf.ConfigProto(allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default(), open(log_precision, "w") as log, open(loss_precision, "w") as loss_log:
DIS_MODEL_FILE = "model/pre-trained.model" # overfitted DNS
# param = pickle.load(open(DIS_MODEL_FILE,"rb"))
param = None # 不加载参数
loss_type = "pair"
discriminator = Discriminator.Discriminator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=len(vocab),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
learning_rate=FLAGS.learning_rate,
l2_reg_lambda=FLAGS.l2_reg_lambda,
# embeddings=embeddings,
embeddings=None,
paras=param,
loss=loss_type)
generator = Generator.Generator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=len(vocab),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
learning_rate=FLAGS.learning_rate * 0.1,
l2_reg_lambda=FLAGS.l2_reg_lambda,
# embeddings=embeddings,
embeddings=None,
paras=param,
loss=loss_type)
sess.run(tf.global_variables_initializer())
# evaluation(sess,discriminator,log,0)
for i in range(FLAGS.num_epochs):
if i > 0:
samples = generate_gan(sess, generator)
# for j in range(FLAGS.d_epochs_num):
for _index, batch in enumerate(
insurance_qa_data_helpers.batch_iter(samples, num_epochs=FLAGS.d_epochs_num,
batch_size=FLAGS.batch_size,
shuffle=True)): # try:
feed_dict = {discriminator.input_x_1: batch[:, 0], discriminator.input_x_2: batch[:, 1],
discriminator.input_x_3: batch[:, 2]}
_, step, current_loss, accuracy = sess.run(
[discriminator.train_op, discriminator.global_step, discriminator.loss,
discriminator.accuracy],
feed_dict)
line = ("%s: DIS step %d, loss %f with acc %f " % (
datetime.datetime.now().isoformat(), step, current_loss, accuracy))
if _index % 10 == 0:
print(line)
loss_log.write(line + "\n")
loss_log.flush()
evaluation(sess, discriminator, log, i)
for g_epoch in range(FLAGS.g_epochs_num):
for _index, pair in enumerate(raw):
q = pair[2]
a = pair[3]
neg_alist_index = [item for item in range(len(alist))] # 答案列表
# 随机选择 100-1=99个index
sampled_index = np.random.choice(neg_alist_index, size=[FLAGS.pools_size - 1],
replace=False)
sampled_index = list(sampled_index)
sampled_index.append(_index) # 添加凑齐100个
pools = np.array(alist)[sampled_index] # 按照sampled_index里面是索引从a_list里面选出answer
# 把文字形式转换成数字[[q,a,neg],[q,a,neg]......]
samples = insurance_qa_data_helpers.loadCandidateSamples(q, a, pools, vocab)
predicteds = []
for batch in insurance_qa_data_helpers.batch_iter(samples, batch_size=FLAGS.batch_size):
feed_dict = {generator.input_x_1: batch[:, 0], generator.input_x_2: batch[:, 1],
generator.input_x_3: batch[:, 2]}
# 生成预测 # cosine(q,neg) - cosine(q,pos) 正常应该是负数
# 在QA中是排名cosine取最高的作为正确的。这里通过QA_CNN计算出Q_NEG - Q_POS的得分差值
predicted = sess.run(generator.gan_score, feed_dict)
predicteds.extend(predicted)
exp_rating = np.exp(np.array(predicteds) * FLAGS.sampled_temperature)
prob = exp_rating / np.sum(exp_rating)
# 回归后根据对应位置的概率，随机选择出一定的neg。 https://www.zhihu.com/question/23765351
neg_index = np.random.choice(np.arange(len(pools)), size=FLAGS.gan_k, p=prob,
replace=False) # 生成 FLAGS.gan_k个负例
# 取出这些负样本就拿去给D判别 score12 = q_pos score13 = q_neg
subsamples = np.array(
insurance_qa_data_helpers.loadCandidateSamples(q, a, pools[neg_index], vocab))
feed_dict = {discriminator.input_x_1: subsamples[:, 0],
discriminator.input_x_2: subsamples[:, 1],
discriminator.input_x_3: subsamples[:, 2]}
reward = sess.run(discriminator.reward,
feed_dict) # reward= 2 * (tf.sigmoid( 0.05- (q_pos -q_neg) ) - 0.5)
samples = np.array(samples)
feed_dict = {
generator.input_x_1: samples[:, 0],
generator.input_x_2: samples[:, 1],
generator.neg_index: neg_index,
generator.input_x_3: samples[:, 2],
generator.reward: reward
}
_, step, current_loss, positive, negative = sess.run( # 应该是全集上的softmax 但是此处做全集的softmax开销太大了
[generator.gan_updates, generator.global_step, generator.gan_loss, generator.positive,
generator.negative], # self.prob= tf.nn.softmax( self.cos_13)
feed_dict) # self.gan_loss = -tf.reduce_mean(tf.log(self.prob) * self.reward)
line = ("%s: GEN step %d, loss %f positive %f negative %f" % (
datetime.datetime.now().isoformat(), step, current_loss, positive, negative))
if _index % 100 == 0:
print(line)
loss_log.write(line + "\n")
loss_log.flush()
evaluation(sess, generator, log, i * FLAGS.g_epochs_num + g_epoch)
log.flush()
def main():
with tf.Graph().as_default():
with tf.device("/gpu:1"):
session_conf = tf.ConfigProto(allow_soft_placement=FLAGS.allow_soft_placement,log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default() ,open(log_precision,"w") as log,open(loss_precision,"w") as loss_log :
param= None
loss_type="pair"
discriminator = Discriminator.Discriminator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=FLAGS.vocab_size,
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
learning_rate=FLAGS.learning_rate,
l2_reg_lambda=FLAGS.l2_reg_lambda,
# embeddings=embeddings,
embeddings=None,
paras=param,
loss=loss_type)
generator = Generator.Generator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=FLAGS.vocab_size,
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
learning_rate=FLAGS.learning_rate*0.1,
l2_reg_lambda=FLAGS.l2_reg_lambda,
# embeddings=embeddings,
embeddings=None,
paras=param,
loss=loss_type)
timestamp = str(int(time.time()))
out_dir = os.path.abspath(os.path.join(os.path.curdir, "runs", FLAGS.model_name, timestamp))
print("Writing to {}\n".format(out_dir))
checkpoint_dir = os.path.abspath(os.path.join(out_dir, "checkpoints"))
checkpoint_prefix = os.path.join(checkpoint_dir, "model")
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=FLAGS.num_checkpoints)
sess.run(tf.global_variables_initializer())
# evaluation(sess,discriminator,log,0)
num_round_per_epoch = int(math.ceil(len(raw)/FLAGS.data_every_round))
for i in range(FLAGS.num_epochs):
for loop in range(num_round_per_epoch):
end_index = min((loop + 1) * FLAGS.data_every_round, len(raw))
raw_loop = raw[end_index-FLAGS.data_every_round:end_index]
alist_loop = alist[end_index-FLAGS.data_every_round:end_index]
assert len(raw_loop) == len(alist_loop)
if loop>0 or i>0:
samples=generate_gan(sess,generator, raw_loop, alist_loop)
# for j in range(FLAGS.d_epochs_num):
for _index,batch in enumerate(insurance_qa_data_helpers.batch_iter(samples,num_epochs=FLAGS.d_epochs_num,batch_size=FLAGS.batch_size,shuffle=True)): # try:
feed_dict = {discriminator.input_x_1: batch[:,0],discriminator.input_x_2: batch[:,1],discriminator.input_x_3: batch[:,2]}
_, step, current_loss,accuracy = sess.run(
[discriminator.train_op, discriminator.global_step, discriminator.loss,discriminator.accuracy],
feed_dict)
line=("%s: DIS step %d, loss %f with acc %f "%(datetime.datetime.now().isoformat(), step, current_loss,accuracy))
if _index%10==0:
print(line)
loss_log.write(line+"\n")
loss_log.flush()
if loop != 0 and loop % 20 == 0:
evaluation(sess,discriminator,log, dev_data, i)
for g_epoch in range(FLAGS.g_epochs_num):
for _index,pair in enumerate(raw_loop):
q=pair[0]
a=pair[1]
neg_alist_index=[item for item in range(len(alist_loop))]
neg_alist_index.remove(_index) # remove the positive index
simq = []
head = _index - 1
while head >= 0 and raw_loop[head][0] == q:
simq.append(raw_loop[head][1])
neg_alist_index.remove(head)
head -= 1
tail = _index + 1
while tail < len(raw_loop) and raw_loop[tail][0] == q:
simq.append(raw_loop[tail][1])
neg_alist_index.remove(tail)
tail += 1
while head >= 0 and raw_loop[head][1] in simq:
neg_alist_index.remove(head)
head -= 1
while tail < len(raw_loop) and raw_loop[tail][1] in simq:
neg_alist_index.remove(tail)
tail += 1
sampled_index=np.random.choice(neg_alist_index,size=[FLAGS.pools_size-1],replace= False)
sampled_index=list(sampled_index)
sampled_index.append(_index)
pools=np.array(alist_loop)[sampled_index]
samples=insurance_qa_data_helpers.loadCandidateSamples(q,a,pools)
predicteds=[]
for batch in insurance_qa_data_helpers.batch_iter(samples,batch_size=FLAGS.batch_size):
feed_dict = {generator.input_x_1: batch[:,0],generator.input_x_2: batch[:,1],generator.input_x_3: batch[:,2]}
predicted=sess.run(generator.gan_score,feed_dict)
predicteds.extend(predicted)
exp_rating = np.exp(np.array(predicteds)*FLAGS.sampled_temperature)
prob = exp_rating / np.sum(exp_rating)
neg_index = np.random.choice(np.arange(len(pools)) , size=FLAGS.gan_k, p=prob ,replace=False) # 生成 FLAGS.gan_k个负例
subsamples=np.array(insurance_qa_data_helpers.loadCandidateSamples(q,a,pools[neg_index]))
feed_dict = {discriminator.input_x_1: subsamples[:,0],discriminator.input_x_2: subsamples[:,1],discriminator.input_x_3: subsamples[:,2]}
reward = sess.run(discriminator.reward,feed_dict) # reward= 2 * (tf.sigmoid( score_13 ) - 0.5)
samples=np.array(samples)
feed_dict = {
generator.input_x_1: samples[:,0],
generator.input_x_2: samples[:,1],
generator.neg_index: neg_index,
generator.input_x_3: samples[:,2],
generator.reward: reward
}
_, step, current_loss,positive,negative = sess.run( #应该是全集上的softmax 但是此处做全集的softmax开销太大了
[generator.gan_updates, generator.global_step, generator.gan_loss, generator.positive,generator.negative], # self.prob= tf.nn.softmax( self.cos_13)
feed_dict) #self.gan_loss = -tf.reduce_mean(tf.log(self.prob) * self.reward)
line=("%s: Epoch %d, Loop %d, GEN step %d, loss %f positive %f negative %f"%(datetime.datetime.now().isoformat(), i, loop, step, current_loss,positive,negative))
if _index %10==0:
print(line)
loss_log.write(line+"\n")
loss_log.flush()
if loop != 0 and loop % 20 == 0:
evaluation(sess,generator,log, dev_data, i*FLAGS.g_epochs_num + g_epoch)
log.flush()
path = saver.save(sess, checkpoint_prefix, global_step=generator.global_step)
print("Saved model checkpoint to {}\n".format(path))
def main():
with tf.Graph().as_default():
with tf.device("/gpu:1"):
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default(), open(log_precision, "w") as log, open(
loss_precision, "w") as loss_log:
DIS_MODEL_FILE = "model/pre-trained.model" # overfitted DNS
#param = pickle.load(open(DIS_MODEL_FILE,"rb")) #add
param = None #add
loss_type = "pair"
with tf.name_scope('discriminator_setting') as scope:
discriminator = Discriminator.Discriminator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=len(vocab),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(
map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
learning_rate=FLAGS.learning_rate,
l2_reg_lambda=FLAGS.l2_reg_lambda,
# embeddings=embeddings,
embeddings=None,
paras=param,
loss=loss_type)
with tf.name_scope('generator_setting') as scope:
generator = Generator.Generator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=len(vocab),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(
map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
learning_rate=FLAGS.learning_rate * 0.1,
l2_reg_lambda=FLAGS.l2_reg_lambda,
# embeddings=embeddings,
embeddings=None,
paras=param,
loss=loss_type)
sess.run(tf.global_variables_initializer())
tw = tf.summary.FileWriter("log_dir", graph=sess.graph) #add
# evaluation(sess,discriminator,log,0)
with tf.name_scope('gan_training') as scope:
for i in range(FLAGS.num_epochs):
with tf.name_scope(
'discriminator_gan_training') as scope:
if i > 0:
samples = generate_gan(sess, generator)
# for j in range(FLAGS.d_epochs_num):
for _index, batch in enumerate(
insurance_qa_data_helpers.batch_iter(
samples,
num_epochs=FLAGS.d_epochs_num,
batch_size=FLAGS.batch_size,
shuffle=True)): # try:
feed_dict = {
discriminator.input_x_1: batch[:, 0],
discriminator.input_x_2: batch[:, 1],
discriminator.input_x_3: batch[:, 2]
}
_, step, current_loss, accuracy = sess.run(
[
discriminator.train_op,
discriminator.global_step,
discriminator.loss,
discriminator.accuracy
], feed_dict)
line = (
"%s: DIS step %d, loss %f with acc %f "
% (datetime.datetime.now().isoformat(),
step, current_loss, accuracy))
if _index % 10 == 0:
print(line)
loss_log.write(line + "\n")
loss_log.flush()
evaluation(sess, discriminator, log, i) #add
with tf.name_scope('generator_gan_training') as scope:
for g_epoch in range(FLAGS.g_epochs_num):
for _index, pair in enumerate(raw):
q = pair[2]
a = pair[3]
neg_alist_index = [
item for item in range(len(alist))
]
sampled_index = np.random.choice(
neg_alist_index,
size=[FLAGS.pools_size - 1],
replace=False)
sampled_index = list(sampled_index)
sampled_index.append(_index)
pools = np.array(alist)[sampled_index]
samples = insurance_qa_data_helpers.loadCandidateSamples(
q, a, pools, vocab)
predicteds = []
for batch in insurance_qa_data_helpers.batch_iter(
samples,
batch_size=FLAGS.batch_size):
feed_dict = {
generator.input_x_1: batch[:, 0],
generator.input_x_2: batch[:, 1],
generator.input_x_3: batch[:, 2]
}
predicted = sess.run(
generator.gan_score, feed_dict)
predicteds.extend(predicted)
exp_rating = np.exp(
np.array(predicteds) *
FLAGS.sampled_temperature)
prob = exp_rating / np.sum(exp_rating)
neg_index = np.random.choice(
np.arange(len(pools)),
size=FLAGS.gan_k,
p=prob,
replace=False) # 生成 FLAGS.gan_k个负例
subsamples = np.array(
insurance_qa_data_helpers.
loadCandidateSamples(
q, a, pools[neg_index], vocab))
feed_dict = {
discriminator.input_x_1: subsamples[:,
0],
discriminator.input_x_2: subsamples[:,
1],
discriminator.input_x_3: subsamples[:,
2]
}
reward = sess.run(
discriminator.reward, feed_dict
) # reward= 2 * (tf.sigmoid( score_13 ) - 0.5)
samples = np.array(samples)
feed_dict = {
generator.input_x_1: samples[:, 0],
generator.input_x_2: samples[:, 1],
generator.neg_index: neg_index,
generator.input_x_3: samples[:, 2],
generator.reward: reward
}
_, step, current_loss, positive, negative = sess.run(
[
generator.gan_updates,
generator.global_step,
generator.gan_loss,
generator.positive,
generator.negative
], feed_dict)
#self.prob= tf.nn.softmax( self.cos_13)
#self.gan_loss = -tf.reduce_mean(tf.log(self.prob) * self.reward)
#tw = tf.summary.FileWriter("log_dir", graph=sess.graph) #add
line = (
"%s: GEN step %d, loss %f positive %f negative %f"
% (datetime.datetime.now().isoformat(),
step, current_loss, positive,
negative))
if _index % 100 == 0:
print(line)
loss_log.write(line + "\n")
loss_log.flush()
evaluation(sess, generator, log,
i * FLAGS.g_epochs_num + g_epoch)
#evaluation(sess, generator, log, 2) #toy
log.flush()
