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 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/baseline_eval_pre-trained.model"
param = pickle.load(open(DIS_MODEL_FILE, "rb")) #add
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)
'''
def main(param):
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:
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)
def __init__(self,
input_shape,
depth_layers_discriminator=[64, 128, 256, 512],
depth_layers_generator=[1024, 512, 256, 128],
dim_noise=100,
model="simple",
data="MNIST",
flip_discri_labels=False,
final_generator_activation="tanh",
test_name='_1'):
"""DCGAN model (for each parameter, the default value is the value used in the DCGAN paper)
:param input_shape: format [height, width, depth]
:param depth_layers_discriminator: the depth of the different layers used by the discriminator, only for the
dcgan models
:param depth_layers_generator: the depth of the different layers used by the generator, only for the
dcgan models
:param dim_noise: size of the input noise used by the generator
:param model: type of model to use (simple, intermediate, dcgan_custom, dcgan_vanilla)
:param data: dataset used
:param flip_discri_labels: flip labels in the computation of the discrimination loss (10% flip)
:param final_generator_activation: activation function for the output layer of the generator
:param test_name: to give a name to the current execution"""
#Saving param
self.test_name = test_name
# Global model
self.model = model
self.data = data
# Dimension of data
self.output_height = input_shape[0]
self.output_width = input_shape[1]
self.output_depth = input_shape[2]
self.dim_noise = dim_noise
# Useful variables
self.real_images_probabilities = 0
self.fake_images_probabilities = 0
# Build input variables
#self.X_batch = tf.placeholder(dtype=tf.float32, shape=[None, self.output_depth*self.output_height*self.output_width], name='X')
self.X_batch = tf.placeholder(dtype=tf.float32,
shape=[
None, self.output_height,
self.output_width, self.output_depth
],
name='real_images')
self.noise_batch = tf.placeholder(dtype=tf.float32,
shape=[None, self.dim_noise],
name='noise')
# Build both components
self.final_generator_activation = final_generator_activation
self.discriminator = Discriminator(input_shape,
depth_layers_discriminator,
model=model)
self.generator = Generator(input_shape,
depth_layers=depth_layers_generator,
model=model,
data=data,
final_activation=final_generator_activation)
# Construct the graph
self.build_graph(flip_discri_labels=flip_discri_labels)
def start():
global dataset
# THIS IS THE DATA THAT IS RETRIEVED IN DATASET
dataset = DataR.DatasetRetrieval()
dataset = dataset.retrieveImages() # first half is orig images, 2nd half is pixelated images
print('Loaded ', dataset[0].shape, dataset[0].shape[1:], " Image sizes")
# Image shape is 96 x 96 x 3 in this dataset
image_shape = dataset[0].shape[1:]
# define descriminator model
descrim_model = Discriminator.Discriminator(image_shape)
descrim_model= descrim_model.define_discriminator()
# Define generator model
gen_model = Generator.Generator((32,32,3))
gen_model= gen_model.define_gen()
# GAN MODEL IMPLEMENTS BOTH GENERATOR AND DESCRIMINATOR INSIDE
gan_model = define_GAN(gen_model, descrim_model,image_shape)
n_patch = descrim_model.get_output_shape_at(1)[1] # size 1
n_batches= dataset[0].shape[0]
# unpack dataset
train_hr, train_lr = dataset
# num of batches per epoch
####################################
#
# Train Discriminator...
#
#####################################
bat_per_epo = int(len(train_hr) / 1)
# Calculates total iterations needed based on epochs (100 epochs)
n_steps = bat_per_epo * 1000 #100,000 iterations...
# iterate through each epoch through steps
for i in range(n_steps):
# retrieve real samples
X_real_hr, X_real_lr,real_y1= generate_real_samples(n_batches, n_patch)
# generate fake images
X_fakeB,fake_y = Generator.generateFakeSamples(gen_model, X_real_lr, n_patch,)
#X_real_hr = (X_real_hr + 1) / 2.0
#X_real_lr = (X_real_lr + 1) / 2.0
#X_fakeB = (X_fakeB + 1) / 2.0
# Loss function of first set of real images
_,d_loss_real = descrim_model.train_on_batch(X_real_hr,real_y1)
# Loss function for fake images
_,d_loss_fake = descrim_model.train_on_batch(X_fakeB,fake_y)
d_loss= 0.5 * np.add(d_loss_real,d_loss_fake)# d_loss[0]--> shape(2,)
_,g_loss,_= gan_model.train_on_batch(X_real_lr, [X_real_hr,real_y1]) #in_src,[gen_out,dis_out] model
# Loss functions printed out
print('>%d, dreal[%.4f], dfake[%.4f], g[%.4f]' % (i + 1, d_loss_real, d_loss_fake,g_loss))
# save data after epoch
if (i + 1) % (200) == 0:
summarize_performance(i, gen_model)
def __init__(self,vocab_file,cost = 'gan'):
Encoder.__init__(self)
Decoder.__init__(self)
self.vocab = pickle.load(vocab_file)
self.cost = cost
self.evaluator = Discriminator()
self.params = self.eparams + self.dparams
self.gparams = []
self.train = []
self.test = []
def pre_train_discriminator(datafile):
Dis = Discriminator()
dataset = pickle.load(open(datafile,'r'))
prev_cost = 100.
while prev_cost>epsilon:
total_cost =0.
for c,r in dataset.iteritems():
total_cost + = Dis.run_discriminator([c,r])
print "Discriminator cost after Epoch:" + str(e) + "is "+str(total_cost/size)
prev_cost = total_cost
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/irgan_eval_pre-trained.model" # overfitted DNS
param = pickle.load(open(DIS_MODEL_FILE, "rb")) #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)
'''
def buildModel(model=None):
if model:
self.model = model
else:
phn_encoder = EncoderRNN(self.feat_dim, self.seq_len, self.p_hidden_dim,
input_dropout_p=self.dropout_rate, dropout_p=self.dropout_rate,
n_layers=self.phn_num_layers, bidirectional=True, rnn_cell='gru', variable_lengths=True)
spk_encoder = EncoderRNN(self.feat_dim, self.seq_len, self.s_hidden_dim,
input_dropout_p=self.dropout_rate, dropout_p=self.dropout_rate,
n_layers=self.spk_num_layers, bidirectional=True, rnn_cell='gru', variable_lengths=True)
decoder = DecoderRNN(self.feat_dim, self.seq_len, self.p_hidden_dim+self.s_hidden_dim, n_layers=self.dec_num_layers,
rnn_cell='gru', bidirectional=True, input_dropout_p=self.dropout_rate, dropout_p=self.dropout_rate)
# size of discriminator input = phn_num_layers * num_directions * p_hidden_dim * 2
discriminator = Discriminator(self.phn_num_layers*2*self.p_hidden_dim*2, self.p_hidden_dim*2, self.D_num_layers)
self.model = self.A2VwD(phn_encoder, spk_encoder, decoder, discriminator)
model.to(device)
def test():
print("Loading test data...")
# test dataset
fold = 0
dataset['test'] = {}
dataset['test']['caps'] = utils.load_txt_caption(datapath=caption_test_path)[fold*5000:(fold+1)*5000]
dataset['test']['img'] = np.load(image_feature_test_path)[fold*1000:(fold+1)*1000]
test_iterator = data_iterator.data_iterator(dataset['test'])
cap_test, image_feature_test = test_iterator.all()
cap_test = cap_test[range(0, len(cap_test), 5)]
print('image_feature_test tensor: ', image_feature_test.shape)
print('cap_test tensor: ', cap_test.shape)
sess= tf.Session()
sess.run(tf.global_variables_initializer())
#with tf.Graph().as_default():
saver = tf.train.Saver()#import_meta_graph(os.path.join(save_dir, 'best_validation-106200.meta'))
#ckpt = tf.train.latest_checkpoint(save_path)
#if ckpt:
# saver.restore(sess, ckpt)
# print('restore from ckpt{}'.format(ckpt))
saver.restore(sess=sess, save_path='checkpoints/discriminator/best_validation') # 读取保存的模型
#else:
# print('cannot restore')
param = None
discriminator = Discriminator.Discriminator(
sequence_length=FLAGS.max_sequence_length,
batch_size=FLAGS.batch_size,
vocab_size=len(word_to_id),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
# dropout_keep_prob=1.0,
learning_rate=FLAGS.learning_rate,
l2_reg_lambda=FLAGS.l2_reg_lambda,
embeddings=None,
paras=param,
loss="pair",
trainable=False)
print('Testing...')
rk_c_test, rmean_c_test, rk_i_test, rmean_i_test = dev_step(sess, discriminator, cap_test, image_feature_test, k=10)
print ("Image to text: %.4f %.4f" % (rk_i_test, rmean_i_test))
print ("Text to image: %.4f %.4f" % (rk_c_test, rmean_c_test))
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(precision, "w") as log:
discriminator = Discriminator.Discriminator(
sequence_length=x_train_1.shape[1],
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,
l2_reg_lambda=FLAGS.l2_reg_lambda)
sess.run(tf.global_variables_initializer())
# Generate batches
# Training loop. For each batch...
for i in range(FLAGS.num_epochs):
# try:
x_batch_1, x_batch_2, x_batch_3 = insurance_qa_data_helpers.load_data_6(
vocab, alist, raw, FLAGS.batch_size)
train_step(sess, discriminator, x_batch_1, x_batch_2,
x_batch_3)
current_step = tf.train.global_step(
sess, discriminator.global_step)
if current_step % FLAGS.evaluate_every == 0:
if current_step % (FLAGS.evaluate_every * 20) != 0:
precision_current = dev_step(
sess, discriminator, 100)
line = " %d epoch: precision %f" % (
current_step, precision_current)
else:
precision_current = dev_step(
sess, discriminator, 1800)
line = "__________________\n%d epoch: precision %f" % (
current_step, precision_current)
log.write(line + "\n")
print(line)
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(precision, "w") as log:
discriminator = Discriminator.Discriminator(
sequence_length=x_train_1.shape[1],
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,
l2_reg_lambda=FLAGS.l2_reg_lambda)
sess.run(tf.global_variables_initializer())
# Generate batches
# Training loop. For each batch...
# x1,x2,x3=generateNegSamples(sess,discriminator,300)
for i in range(FLAGS.num_epochs):
x1, x2, x3 = generateNegSamples(sess, discriminator, 100)
for x_batchs1, x_batchs2, x_batchs3 in zip(x1, x2,
x3): # try:
for j in range(500 / FLAGS.batch_size):
index_start = FLAGS.batch_size * j
index_end = FLAGS.batch_size * (j + 1)
x_batch_1, x_batch_2, x_batch_3 = x_batchs1[
index_start:index_end], x_batchs2[
index_start:index_end], x_batchs3[
index_start:index_end]
train_step(sess, discriminator, x_batch_1,
x_batch_2, x_batch_3)
evaluation(sess, discriminator, log)
if __name__ == "__main__":
with open('data/data.pkl', 'rb') as f:
data = pkl.load(f)
voc2int = data['vocab']
text = data['text']
int2voc = data['int2voc']
#Generator
G = Generator(embed_size,
hidden_size,
vocab_size,
num_layers,
use_cuda=cuda)
g_loader = G_loader(text, use_cuda=cuda)
g_op = optim.Adam(G.parameters(), lr=0.01)
restore(G, G_path)
#Discriminator
D = Discriminator(seq_len, vocab_size, embed_size, dis_filter_sizes,
dis_num_filters, num_class, dis_dropout_keep_prob,
dis_l2_reg_lambda)
d_loader = D_loader(pos_path, neg_path, use_cuda=cuda)
d_op = optim.Adam(D.parameters(), lr=1e-3)
restore(D, D_path)
#pretrain_generator(G,g_op,g_loader)
#pretrain_discriminator(D,d_loader,d_op,G)
#Adveraisl_training(G,g_op,D,d_op,d_loader)
#generate(G,D,100,seq_len,int2voc)
def train(learning_rate, batch_size, n_iter, image_width, image_height,
num_classes, z_size):
x_s = tf.placeholder(shape=[batch_size, image_width, image_height, 3],
name='x_s',
dtype=tf.float32)
x_t = tf.placeholder(name='x_t',
shape=[batch_size, image_width, image_height, 3],
dtype=tf.float32)
y_s = tf.placeholder(
name='y_s',
shape=[batch_size, image_width, image_height, num_classes],
dtype=tf.float32)
z = tf.placeholder(shape=[1, z_size], dtype=tf.float32, name='z')
dis_tar = Discriminator(x_t, name="dis_tar")
dis_gen = Discriminator(Generator(x_s, z, name="gen1"), name="dis_gen")
gen2 = Generator(x_s, z, name="gen2")
#print(gen2)
cla_gen = SegNet(gen2, batch_size, num_classes, name="cla_gen")
cla_source = SegNet(x_s, batch_size, num_classes, name="cla_source")
epsilon = np.finfo(np.float32).eps
#if(tf.assert_less_equal(dis_tar,epsilon)dis_tar<=epsilon):
# dis_tar = dis_tar + epsilon
#if(dis_gen-1<=epsilon):
# dis_gen= dis_gen - epsilon
loss_domain = tf.reduce_mean(tf.log_sigmoid(
(dis_tar))) + tf.reduce_mean(tf.log_sigmoid((1.0 - dis_gen)))
#print(cla_gen)
#print(cla_source)
loss_classifier = tf.reduce_mean(
tf.reduce_sum(-y_s * tf.log(cla_gen), axis=[1])) - tf.reduce_mean(
tf.reduce_sum(y_s * tf.log(cla_source), axis=[1]))
t_vars = tf.trainable_variables()
class_vars = [var for var in t_vars if 'SegNet' in var.name]
dis_vars = [var for var in t_vars if 'Discriminator' in var.name]
gen_vars = [var for var in t_vars if 'Generator' in var.name]
d_t = class_vars + dis_vars
domain_optimizer = tf.train.AdamOptimizer(learning_rate,
beta1=0.5).minimize(loss_domain,
var_list=d_t)
class_optimizer = tf.train.AdamOptimizer(
learning_rate, beta1=0.5).minimize(loss_classifier, var_list=gen_vars)
model_path = './model/'
saver = tf.train.Saver()
coord = tf.train.Coordinator()
interval = 20
writer = tf.summary.FileWriter(logdir='logdir',
graph=tf.get_default_graph())
writer.flush()
with tf.Session(config=config) as sess:
sess.run(tf.global_variables_initializer())
flag = True
for i in range(n_iter):
#gbl = GBL(batch_size)
if flag == True:
gbl = GBL(batch_size)
avg_l1 = 0
for iCombined in gbl.global_db_gen():
#iCombined = np.array(iCombined)
z_b = tf.random_uniform(minval=-1,
maxval=1,
shape=[1, z_size])
z_b = sess.run(z_b)
s_i = np.array([x for x, y, z in iCombined])
t_i = np.array([y for x, y, z in iCombined])
s_l = np.array([z for x, y, z in iCombined])
#s_i = cv2.resize(s_i,(image_width,image_height))
#s_l = cv2.resize(s_l, (image_width, image_height))
#t_i = cv2.resize(t_i, (image_width, image_height))
#break
#print(iCombined)
s_i = s_i / 255.0
s_i = s_i - np.mean(s_i)
s_i = s_i / (np.std(s_i, axis=0) +
np.finfo(np.float32).eps)
#s_i = s_i/255.0
t_i = t_i / 255.0
t_i = t_i - np.mean(t_i)
t_i = t_i / (np.std(t_i, axis=0) +
np.finfo(np.float32).eps)
#t_i = s_i/255.0
#print(s_i.shape)
#print(t_i.shape)
d_t, d_g, l1, _ = sess.run(
[dis_tar, dis_gen, loss_domain, domain_optimizer],
feed_dict={
x_s: s_i,
x_t: t_i,
y_s: s_l,
z: z_b
})
#if ( i % 5 == s0 ):
#print(l1)
avg_l1 = avg_l1 + l1
avg_l1 = avg_l1 / 60.0
#flag = 1
print("Epoch: " + str(i) + " Domain Loss: " + str(l1))
if flag == True:
gbl = GBL(batch_size)
avg_l2 = 0
for iCombined in gbl.global_db_gen():
# iCombined = np.array(iCombined)
z_b = tf.random_normal(shape=[1, z_size])
z_b = sess.run(z_b)
s_i = np.array([x for x, y, z in iCombined])
t_i = np.array([y for x, y, z in iCombined])
s_l = np.array([z for x, y, z in iCombined])
#if (np.random.random_sample() < 0.5):
# print("breaking")
# break
s_i = s_i / 255.0
s_i = s_i - np.mean(s_i)
s_i = s_i / (np.std(s_i, axis=0) +
np.finfo(np.float32).eps)
# s_i = s_i/255.0
t_i = t_i / 255.0
t_i = t_i - np.mean(t_i)
t_i = t_i / (np.std(t_i, axis=0) +
np.finfo(np.float32).eps)
# print(s_i.shape)
# print(t_i.shape)
l2, _ = sess.run([loss_classifier, class_optimizer],
feed_dict={
x_s: s_i,
x_t: t_i,
y_s: s_l,
z: z_b
})
avg_l2 = avg_l2 + l2
#flag = 0
avg_l2 = avg_l2 / 60.0
print("Epoch: " + str(i) + " Classifier Loss: " + str(l2))
if ((i + 1) % interval == 0):
saver.save(sess,
os.path.join(model_path, 'model'),
global_step=i + 1)
saver.save(sess, os.path.join(model_path, 'model'), global_step=i + 1)
def train(args):
data_loader = TextLoader(args.data_dir, args.batch_size, args.seq_length)
if args.init_from is not None:
ckpt = tf.train.get_checkpoint_state(args.init_from)
assert ckpt, "No checkpoint found"
assert ckpt.model_checkpoint_path, "No model path found in checkpoint"
Disc = Discriminator(args)
Gen = Generator(args)
# D_tvars = [Disc.W1,Disc.W2]
# G_tvars = [Gen.weight]
fp1 = open('G_loss_training', 'w')
fp2 = open('D_loss_training', 'w')
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
if args.init_from is not None:
saver.restore(sess, ckpt.model_checkpoint_path)
for e in range(args.num_epochs):
print str(e) + 'th epoch'
sess.run(tf.assign(Disc.lr, args.disc_learning_rate))
sess.run(tf.assign(Gen.lr, args.gen_learning_rate))
data_loader.reset_batch_pointer()
for b in range(data_loader.num_batches):
start = time.time()
con, res = data_loader.next_batch()
real_data = np.concatenate((con, res), axis=1)
fake_data = sess.run(Fake_data,
feed_dict={Gen.input_data: con})
D_real, D_logit_real = sess.run(
[prob, logit], feed_dict={Disc.input_data: real_data})
D_fake, D_logit_fake = sess.run(
[prob, logit], feed_dict={Disc.input_data: fake_data})
D_loss = -tf.reduce_mean(tf.log(D_real) + tf.log(1 - D_fake))
G_loss = -tf.reduce_mean(tf.log(D_fake))
D_tvars = [v for v in t_vars if v.name.startswith('disc')]
G_tvars = [v for v in t_vars if v.name.startswith('gen')]
D_solver = tf.train.AdamOptimizer(Disc.lr).minimize(
D_loss, var_list=D_tvars)
G_solver = tf.train.AdamOptimizer(Gen.lr).minimize(
G_loss, var_list=G_tvars)
_, d_loss = sess.run([D_solver, D_loss],
feed_dict={
Disc.input_data: real_data,
Gen.input_data: con
})
_, g_loss = sess.run([G_solver, G_loss],
feed_dict={
Disc.input_data: fake_data,
Gen.input_data: con
})
fp1.write(str(g_loss) + '\n')
fp2.write(str(d_loss) + '\n')
end = time.time()
print("{}/{} (epoch {}), Generator_loss = {:.3f}, Discriminator_loss = {:.3f}, time/batch = {:.3f}" \
.format(e * data_loader.num_batches + b,
args.num_epochs * data_loader.num_batches,
e, g_loss, d_loss, end - start))
if (e * data_loader.num_batches + b) % args.save_every == 0\
or (e==args.num_epochs-1 and b == data_loader.num_batches-1): # save for the last result
checkpoint_path = os.path.join(args.save_dir, 'model.ckpt')
saver.save(sess,
checkpoint_path,
global_step=e * data_loader.num_batches + b)
print("model saved to {}".format(checkpoint_path))
fp1.close()
fp2.close()
from Generator import *
from Discriminator import *
import support
import os
os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
attrNum = 18
attrDim = 5
hideDim = 100
userDim = 18
generator = Generator(attrNum, attrDim, hideDim, userDim)
discriminator = Discriminator(attrNum, attrDim, hideDim, userDim)
test_items, test_attrs = support.get_testdata()
test_attrs = torch.Tensor(test_attrs)
for i in range(30):
generator.load_state_dict(
torch.load('Generator/epoch' + str(i * 10) + '.ld'))
test_G_user = generator(test_attrs)
precision10, precision20, map10, map20, ndcg10, ndcndcg20 = support.test(
test_items, test_G_user.detach())
print(
"epoch{} precision_10:{:.4f},precision_20:{:.4f},map_10:{:.4f},map_20:{:.4f},ndcg_10:{:.4f},ndcg_20:{:.4f}"
.format(i * 10, precision10, precision20, map10, map20, ndcg10,
ndcndcg20))
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"):
# embeddings
param = None
if len(FLAGS.pretrained_embeddings_path) > 0:
print('loading pretrained embeddings...')
param = embd
else:
print('using randomized embeddings...')
param = np.random.uniform(-0.05, 0.05,
(len(vocab), FLAGS.embedding_dim))
# models
with tf.variable_scope('Dis'):
discriminator = Discriminator.Discriminator(
sequence_length_q=FLAGS.max_sequence_length_q,
sequence_length_a=FLAGS.max_sequence_length_a,
batch_size=FLAGS.batch_size,
vocab_size=len(vocab),
embedding_size=FLAGS.embedding_dim,
hidden_size=FLAGS.hidden_size,
l2_reg_lambda=FLAGS.l2_reg_lambda,
learning_rate=FLAGS.learning_rate,
dropout_keep_prob=FLAGS.dropout_keep_prob,
padding_id=vocab[FLAGS.padding])
with tf.variable_scope('Gen'):
generator = Generator.Generator(
sequence_length_q=FLAGS.max_sequence_length_q,
sequence_length_a=FLAGS.max_sequence_length_a,
batch_size=FLAGS.batch_size,
vocab_size=len(vocab),
embedding_size=FLAGS.embedding_dim,
hidden_size=FLAGS.hidden_size,
l2_reg_lambda=FLAGS.l2_reg_lambda,
sampled_temperature=FLAGS.sampled_temperature,
learning_rate=FLAGS.learning_rate,
dropout_keep_prob=FLAGS.dropout_keep_prob,
padding_id=vocab[FLAGS.padding])
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(log_loss,
"w") as loss_log:
# initialze or restore
if len(FLAGS.pretrained_model_path) == 0:
print('initializing model...')
sess.run(tf.global_variables_initializer())
# pretrained embeddings or randomized embeddings
sess.run(
discriminator.embedding_init,
feed_dict={discriminator.embedding_placeholder: param})
sess.run(
generator.embedding_init,
feed_dict={generator.embedding_placeholder: param})
else:
print('loading pretrained model...')
var_list = tf.global_variables()
var_list = [
x for x in var_list
if not x.name.startswith('Dis/output/Variable')
]
var_list = [
x for x in var_list
if not x.name.startswith('Gen/Variable')
]
restore_op, feed_dict = tf.contrib.framework.assign_from_checkpoint(
tf.train.latest_checkpoint(
FLAGS.pretrained_model_path), var_list, True)
sess.run(restore_op, feed_dict)
# initial evaluation
saver = tf.train.Saver(max_to_keep=None)
# evaluation(sess, discriminator, log, saver, 0, 'dev', False)
# evaluation(sess, generator, log, saver, 0, 'dev', False)
baseline = 0.05
for i in range(FLAGS.num_epochs):
# discriminator
if i > 0:
samples = generate_gan(sess, generator, FLAGS.gan_k)
for _index, batch in enumerate(
data_helpers.batch_iter(
samples,
num_epochs=FLAGS.d_epochs_num,
batch_size=FLAGS.batch_size,
shuffle=True)):
feed_dict = { # [q, a, distractor, negative sample]
discriminator.input_x_1:
np.array(batch[:, 0].tolist()),
discriminator.input_x_2:
np.array(batch[:, 1].tolist()),
discriminator.input_x_3:
np.array(batch[:, 2].tolist()),
discriminator.input_x_4:
np.array(batch[:, 3].tolist())
}
_, step, current_loss, accuracy, positive, negative = sess.run(
[
discriminator.train_op,
discriminator.global_step,
discriminator.loss, discriminator.accuracy,
discriminator.positive,
discriminator.negative
], feed_dict)
line = (
"%s: Dis step %d, loss %f with acc %f, positive %f negative %f"
% (datetime.datetime.now().isoformat(), step,
current_loss, accuracy, positive, negative))
if _index % 100 == 0:
print(line)
loss_log.write(line + "\n")
loss_log.flush()
evaluation(sess, discriminator, log, saver, i, 'dev',
True, False)
# generator
baseline_avg = []
for g_epoch in range(FLAGS.g_epochs_num):
for _index, pair in enumerate(raw):
q = pair[1]
a = pair[2]
distractor = pair[3]
# it's possible that true positive samples are selected
neg_alist_index = [j for j in range(len(alist))]
pos_num = min(4, len(raw_dict[q]))
sampled_index = np.random.choice(
neg_alist_index,
size=FLAGS.pools_size - pos_num,
replace=False)
sampled_index = list(sampled_index)
pools = np.array(alist)[sampled_index]
# add the positive index
positive_index = [
j for j in range(len(raw_dict[q]))
]
positive_index = np.random.choice(
positive_index, pos_num,
replace=False).tolist()
pools = np.concatenate(
(pools, np.array(raw_dict[q])[positive_index]))
samples = data_helpers.loadCandidateSamples(
q, a, distractor, pools, vocab,
FLAGS.max_sequence_length_q,
FLAGS.max_sequence_length_a)
predicteds = []
for batch in data_helpers.batch_iter(
samples, batch_size=FLAGS.batch_size):
feed_dict = {
generator.input_x_1:
np.array(batch[:, 0].tolist()),
generator.input_x_2:
np.array(batch[:, 1].tolist()),
generator.input_x_3:
np.array(batch[:, 2].tolist()),
generator.input_x_4:
np.array(batch[:, 3].tolist())
}
predicted = sess.run(generator.gan_score,
feed_dict)
predicteds.extend(predicted)
# generate FLAGS.gan_k negative samples
predicteds = np.array(
predicteds) * FLAGS.sampled_temperature
predicteds -= np.max(predicteds)
exp_rating = np.exp(predicteds)
prob = exp_rating / np.sum(exp_rating)
prob = np.nan_to_num(prob) + 1e-7
prob = prob / np.sum(prob)
neg_index = np.random.choice(np.arange(len(pools)),
size=FLAGS.gan_k,
p=prob,
replace=False)
subsamples = np.array(
data_helpers.loadCandidateSamples(
q, a, distractor, pools[neg_index], vocab,
FLAGS.max_sequence_length_q,
FLAGS.max_sequence_length_a))
feed_dict = {
discriminator.input_x_1:
np.array(subsamples[:, 0].tolist()),
discriminator.input_x_2:
np.array(subsamples[:, 1].tolist()),
discriminator.input_x_3:
np.array(subsamples[:, 2].tolist()),
discriminator.input_x_4:
np.array(subsamples[:, 3].tolist())
}
reward, l2_loss_d = sess.run(
[discriminator.reward, discriminator.l2_loss],
feed_dict)
baseline_avg.append(np.mean(reward))
reward = reward - baseline
samples = np.array(samples)
feed_dict = {
generator.input_x_1:
np.array(samples[:, 0].tolist()),
generator.input_x_2:
np.array(samples[:, 1].tolist()),
generator.input_x_3:
np.array(samples[:, 2].tolist()),
generator.input_x_4:
np.array(samples[:, 3].tolist()),
generator.neg_index:
neg_index,
generator.reward:
reward
}
# should be softmax over all, but too computationally expensive
_, step, current_loss, positive, negative, score12, score13, l2_loss_g = sess.run(
[
generator.gan_updates,
generator.global_step, generator.gan_loss,
generator.positive, generator.negative,
generator.score12, generator.score13,
generator.l2_loss
], feed_dict)
line = (
"%s: Gen step %d, loss %f l2 %f,%f positive %f negative %f, sample prob [%s, %f], reward [%f, %f]"
%
(datetime.datetime.now().isoformat(), step,
current_loss, l2_loss_g, l2_loss_d, positive,
negative, np.min(prob), np.max(prob),
np.min(reward), np.max(reward)))
if _index % 100 == 0:
print(line)
loss_log.write(line + "\n")
loss_log.flush()
evaluation(sess, generator, log, saver,
i * FLAGS.g_epochs_num + g_epoch, 'dev',
True, False)
log.flush()
baseline = np.mean(baseline_avg)
# final evaluation
evaluation(sess, discriminator, log, saver, -1, 'test', False,
False, True)
evaluation(sess, generator, log, saver, -1, 'test', False,
False, True)
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 train(attrNum, attrDim, hideDim, userDim, batch_size, epochs,
learning_rate, alpha):
generator = Generator(attrNum, attrDim, hideDim, userDim) # 生成器
discriminator = Discriminator(attrNum, attrDim, hideDim, userDim) # 判别器
generator = generator.to(device)
discriminator = discriminator.to(device)
# 定义优化器
optimizerG = optim.Adam(generator.parameters(),
lr=learning_rate,
weight_decay=alpha)
optimizerD = optim.Adam(discriminator.parameters(),
lr=learning_rate,
weight_decay=alpha)
BCELoss = nn.BCELoss()
support.shuffle()
support.shuffle2()
# 开始训练
for epoch in range(epochs + 1):
start = time.time()
# 训练生成器
index = 0
while index < 253236:
if index + batch_size <= 253236:
train_attr_batch, _, _, _ = support.get_data(
index, index + batch_size)
index += batch_size
train_attr_batch = train_attr_batch.to(device)
fake_user_emb = generator(train_attr_batch)
fake_user_emb = fake_user_emb.to(device)
D_fake, D_logit_fake = discriminator(train_attr_batch,
fake_user_emb)
G_loss = BCELoss(D_fake, torch.ones_like(D_fake)).mean()
optimizerG.zero_grad()
G_loss.backward()
optimizerG.step()
# 训练判别器
index = 0
while index < 253236:
# discriminator.zero_grad()
if index + batch_size <= 253236:
train_attr_batch, train_user_emb_batch, counter_attr_batch, counter_user_emb_batch = support.get_data(
index, index + batch_size)
index = index + batch_size
train_attr_batch = train_attr_batch.to(device)
train_user_emb_batch = train_user_emb_batch.to(device)
counter_attr_batch = counter_attr_batch.to(device)
counter_user_emb_batch = counter_user_emb_batch.to(device)
fake_user_emb = generator(train_attr_batch)
fake_user_emb.to(device)
D_real, D_logit_real = discriminator(train_attr_batch,
train_user_emb_batch)
D_fake, D_logit_fake = discriminator(train_attr_batch,
fake_user_emb)
D_counter, D_logit_counter = discriminator(counter_attr_batch,
counter_user_emb_batch)
D_loss_real = BCELoss(D_real, torch.ones_like(D_real)).mean()
D_loss_fake = BCELoss(D_fake, torch.zeros_like(D_fake)).mean()
D_loss_counter = BCELoss(D_counter,
torch.zeros_like(D_counter)).mean()
D_loss = D_loss_real + D_loss_fake + D_loss_counter
optimizerD.zero_grad()
D_loss.backward()
optimizerD.step()
end = time.time()
# 记录训练状态
if epoch % 10 == 0:
torch.save(generator.state_dict(),
"Generator/epoch" + str(epoch) + ".ld")
torch.save(discriminator.state_dict(),
"Discriminator/" + str(epoch) + ".ld")
print("epoch: {}/{}, G_loss:{:.4f}, D_loss:{:.4f}, time:{:.4f}".format(
epoch, epochs, G_loss, D_loss, end - start))
def main():
graph = tf.Graph()
with graph.as_default():
with tf.device("/gpu:1"):
#configure tensorboard
# tensorboard_dir = 'tensorboard/discriminator'
# if not os.path.exists(tensorboard_dir):
# os.makedirs(tensorboard_dir)
saver = tf.train.Saver()
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(graph=graph, 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(word_to_id),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
# dropout_keep_prob=FLAGS.dropout_keep_prob,
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)
best_average_recall = 0.0
total_batch = 0
last_improved = 0 # 记录上一次提升批次
require_improvement = 50 # 如果超过1000轮未提升，提前结束训练
flag = False
last_step = 0
for epoch in range(FLAGS.num_epochs):
print('Epoch:', epoch + 1)
# 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() #
# samples = generate_uniform_pair()
train_iterator = data_iterator.data_iterator(dataset['train'], batch_size=FLAGS.batch_size)
#print('==========================')
for batch in train_iterator:#utils.batch_iter(samples,batch_size=FLAGS.batch_size,num_epochs=1,shuffle=True):
cap_sample = batch[0]#np.array([item[0] for item in batch])
#print('cap_sample tensor: ', cap_sample.shape)
img_pos_sample = batch[1]#np.array([item[1] for item in batch])
#print(img_pos_sample.shape)
img_neg_sample = batch[1]#np.array([item[2] for item in batch])
feed_dict = {
discriminator.input_caption: cap_sample,
discriminator.input_image_pos: img_pos_sample,
discriminator.input_image_neg: img_neg_sample,
}
_, step, current_loss, accuracy, positive, negative = sess.run(
[discriminator.train_op, discriminator.global_step, discriminator.loss,discriminator.accuracy, discriminator.positive, discriminator.negative],
feed_dict)
time_str = datetime.datetime.now().isoformat()
if(step % 100 == 0):
print(("%s: DIS step %d, loss %f with acc %f, positive score %f and negative score %f "%(time_str, step, current_loss,accuracy, positive, negative)))
last_step = step
# evaluate the performance of the model on the val dataset
if((total_batch+1) % FLAGS.evaluate_every == 0):
rk_i_current, rk_c_current = evaluation(sess, discriminator, log, epoch)
# save the best performed model
if (rk_i_current + rk_c_current) * 0.5 > best_average_recall:
best_average_recall = (rk_i_current + rk_c_current) * 0.5
last_improved = total_batch
saver.save(sess=sess, save_path=save_path, global_step=last_step)
improved_str = '*'
break
else:
improved_str = ''
total_batch += 1
if total_batch - last_improved > require_improvement:
# early stop
print("No optimization for a long time, auto-stopping...")
flag = True
break
if flag:
break
def inference(word_list, user_dict, train, ckpt_path, k=30, model_type="Dis"):
k = int(k)
tokenizer = jieba.Tokenizer()
tokenizer.load_userdict(user_dict)
vocab, id2tok = build_vocab(
word_list) #vocab里token是unicode， id2tok里tok是str， 两个里面id都是int
print "read data"
alist = read_ans(train, FLAGS.max_sequence_length) #是个二维list
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():
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)
saver = tf.train.Saver(tf.global_variables())
sess.run(tf.global_variables_initializer())
saver.restore(sess=sess, save_path=ckpt_path)
if model_type == "Dis":
print "Test Dis Model!"
model = discriminator
else:
print "Test Gen Model!"
model = generator
while True:
print "Please input query:"
line = sys.stdin.readline().strip()
if not line:
line = "小米蓝牙手柄能连接手机玩吗"
ws = tokenizer.cut(line) #切出来每个tok是unicode。
ws = list(ws)
q = "_".join(ws)
ws_enc = [tok.encode("utf-8") for tok in ws]
q_enc = "_".join(ws_enc)
print "tokenized query is:", q_enc
q = tok2id(q, FLAGS.max_sequence_length, vocab) #是个list
print "id q is:", q
qs = []
for a in alist: #每个a是个list
qs.append(q)
feed_dict = {
model.input_x_1: qs,
model.input_x_2: alist,
model.input_x_3: alist
}
scorel2 = tf.reshape(model.score12, [-1])
topk = tf.nn.top_k(scorel2, k)
index = sess.run(topk, feed_dict)[1]
recalls = np.array(alist)[index]
print "Recall results are: \n"
for recall in recalls:
line = de_id(recall, id2tok)
print line, "\n"
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()
gen = Generator(train_data_loader=train_dl,
validation_data_loader=val_dl,
units=generator_hidden_units,
leaky_relu_alpha=generator_leaky_relu_alpha,
num_layers=generator_layers,
opt=generator_optimizer,
dropout_keep_prob=generator_dropout_keep_prob,
l2_reg_lambda=generator_l2_regularization_lambda,
sequence_length=sequence_length,
loss=generator_loss,
metrics=generator_metrics)
disc = Discriminator(table_len=len(train_dl.st.table),
filter_sizes=filter_sizes_by_layer,
num_filters=number_of_filters_by_layer,
sequence_len=sequence_length,
l2_reg_lambda=discriminator_l2_regularization_lambda,
dropout_keep_prob=discriminator_dropout_keep_prob,
learning_rate=discriminator_learning_rate,
leaky_relu_alpha=discriminator_leaky_relu_alpha,
carry_bias=carry_bias,
metrics=discriminator_metrics)
# Load Model Weights if you have them
if load_oracle_weights:
oracle.load_weights(oracle_checkpoint_dir)
if load_generator_weights:
gen.load_weights(generator_checkpoint_dir)
if load_discriminator_weights:
disc.load_weights(discriminator_checkpoint_dir)
# Train Oracle
if train_oracle:
def process(fold_index=0):
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(precision_log + str(fold_index),
'w') as log:
if len(sys.argv) > 1:
param = cPickle.load(open(pre_trained_path + sys.argv[1], 'r'))
print param[2][3], param[2][4], param[2][5]
else:
param = None
#samples = generate_uniform_pair('test_feature')
#eb_samples, pro_samples = generate_uniform_pair('train_feature')
eb_samples, pro_samples = cPickle.load(
open(path + 'train_samples' + str(fold_index), 'r'))
query_prof_dim = len(pro_samples[0][0])
response_prof_dim = len(pro_samples[0][-1])
batch_size = FLAGS.batch_size
num_batches = int(math.ceil(len(eb_samples) / batch_size))
print np.shape(eb_samples), np.shape(
pro_samples), query_prof_dim, response_prof_dim
dis = Discriminator.Discriminator(
FLAGS.max_sequence_len, FLAGS.batch_size, len(vocab),
FLAGS.embedding_dim,
list(map(int, FLAGS.filter_sizes.split(","))),
FLAGS.num_filters, query_prof_dim, response_prof_dim,
FLAGS.dropout, FLAGS.l2_reg, FLAGS.learning_rate, param, None,
'log', True, FLAGS.score_type)
sess.run(tf.global_variables_initializer())
for i in range(FLAGS.num_epochs):
step, current_loss, accuracy = 0, 0.0, 0.0
#eb_samples, pro_samples = generate_dns_pair(sess,dis,eb_samples,pro_samples)
for ib in range(num_batches):
end_index = min((ib + 1) * batch_size, len(eb_samples))
eb_batch = eb_samples[end_index - batch_size:end_index]
pro_batch = pro_samples[end_index - batch_size:end_index]
feed_dict = {
dis.input_x_1: eb_batch[:, 0],
dis.input_x_2: eb_batch[:, 1],
dis.input_x_3: eb_batch[:, 2],
dis.prof_1: list(pro_batch[:, 0]),
dis.prof_2: list(pro_batch[:, 1]),
dis.prof_3: list(pro_batch[:, 2])
}
_, step, current_loss, accuracy, pos_score, neg_score = sess.run(
[
dis.updates, dis.global_step, dis.loss,
dis.accuracy, dis.positive, dis.negative
], feed_dict)
line = (
"%s: basic Dis step %d, loss %f with acc %f,pos score %f, neg score %f, total step: %d "
% (timestamp(), step, current_loss, accuracy, pos_score,
neg_score, FLAGS.num_epochs * num_batches))
print line
log.write(line + "\n")
if i != FLAGS.num_epochs - 1:
evaluation(sess, dis, log, batch_size,
path + 'test_samples' + str(fold_index))
evaluation(sess, dis, log, batch_size,
path + 'test_samples' + str(fold_index), True)
# Create the generator
netG = Generator(ngpu).to(device)
# Handle multi-gpu if desired
if (device.type == 'cuda') and (ngpu > 1):
netG = nn.DataParallel(netG, list(range(ngpu)))
# Apply the weights_init function to randomly initialize all weights
# to mean=0, stdev=0.2.
netG.apply(weights_init)
# Print the model
#print(netG)
# Create the Discriminator
netD = Discriminator(ngpu).to(device)
# Handle multi-gpu if desired
if (device.type == 'cuda') and (ngpu > 1):
netD = nn.DataParallel(netD, list(range(ngpu)))
# Apply the weights_init function to randomly initialize all weights
# to mean=0, stdev=0.2.
netD.apply(weights_init)
# Print the model
print(netD)
# Initialize BCELoss function
criterion = nn.BCELoss()
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 :
discriminator = Discriminator.Discriminator(
sequence_length=x_train_1.shape[1],
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,
l2_reg_lambda=FLAGS.l2_reg_lambda)
generator = Generator.Generator(
sequence_length=x_train_1.shape[1],
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,
l2_reg_lambda=FLAGS.l2_reg_lambda)
sess.run(tf.global_variables_initializer())
for epoch in range(FLAGS.num_epochs):
if epoch > -1:
# G generate negative for D, then train D
# generate_for_d(sess, generator, DIS_TRAIN_FILE)
# train_size = ut.file_len(DIS_TRAIN_FILE)
for d_epoch in range(1):
print "start sample"
x1,x2,x3=generateNegSamples(sess,generator,100)
for x_batchs1, x_batchs2, x_batchs3 in zip(x1,x2,x3): # try:
for j in range(500/FLAGS.batch_size):
index_start=FLAGS.batch_size*j
index_end=FLAGS.batch_size*(j+1)
x_batch_1, x_batch_2, x_batch_3=x_batchs1[index_start:index_end], x_batchs2[index_start:index_end], x_batchs3[index_start:index_end]
train_step(sess,discriminator,x_batch_1, x_batch_2, x_batch_3)
evaluation(sess,discriminator,log)
# Train G
for g_epoch in range(1): # 50
print "g_epoach: %d" % g_epoch
x1,x2,x3=generateNegSamples(sess,generator,100)
for i in range(1):
for x_batchs1, x_batchs2, x_batchs3 in zip(x1,x2,x3): # try:
for j in range(500/FLAGS.batch_size):
index_start=FLAGS.batch_size*j
index_end=FLAGS.batch_size*(j+1)
x_batch_1, x_batch_2, x_batch_3=x_batchs1[index_start:index_end], x_batchs2[index_start:index_end], x_batchs3[index_start:index_end]
feed_dict = {
discriminator.input_x_1: x_batch_1,
discriminator.input_x_2: x_batch_2,
discriminator.input_x_3: x_batch_3,
discriminator.dropout_keep_prob: 1.0
}
neg_reward = sess.run(discriminator.neg_reward,feed_dict)
feed_dict = {
generator.input_x_1: x_batch_1,
generator.input_x_2: x_batch_2,
generator.input_x_3: x_batch_3,
generator.reward: neg_reward,
generator.dropout_keep_prob: 1.0
}
_ ,step= sess.run([generator.gan_updates, generator.global_step],feed_dict)
print "have trained %d g_epoch" % step
evaluation(sess,generator,log)
training_loader = DataLoader(
train_dataset,
batch_size=batch_size
#shuffle=True
#num_workers=multiprocessing.cpu_count(),
)
validation_loader = DataLoader(val_dataset,
batch_size=batch_size
#num_workers=multiprocessing.cpu_count(),
)
# load model / criterion / optimizer
netG = GeneratorUnet().to(device)
print(netG)
netD = Discriminator().to(device)
mseloss = nn.MSELoss()
bceloss = nn.BCELoss()
vggloss = VGGLoss()
optimizerG = optim.Adam(netG.parameters())
optimizerD = optim.Adam(netD.parameters())
# load weight if load_weight_dir is defined
if load_weight_dir is not None:
print(f'Loading checkpoint: {load_weight_dir}')
checkpoint = torch.load(load_weight_dir)
netG.load_state_dict(checkpoint['model_state_dict'])
optimizerG.load_state_dict(checkpoint['optimizer_state_dict'])
init_epoch = checkpoint['epoch']
def process(fold_index=0):
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_log + str(fold_index),
'w') as log:
if len(sys.argv) > 1:
paramG = cPickle.load(open(pre_trained_path + sys.argv[1],
'r'))
paramD = cPickle.load(open(pre_trained_path + sys.argv[2],
'r'))
else:
paramG = None
paramD = None
eb_samples, pro_samples = cPickle.load(
open(path + 'train_samples' + str(fold_index), 'r'))
query_prof_dim = len(pro_samples[0][0])
response_prof_dim = len(pro_samples[0][-1])
batch_size = FLAGS.batch_size
num_batches = int(math.ceil(len(eb_samples) / batch_size))
print np.shape(eb_samples), np.shape(
pro_samples), query_prof_dim, response_prof_dim
dis = Discriminator.Discriminator(
FLAGS.max_sequence_len, FLAGS.batch_size, len(vocab),
FLAGS.embedding_dim,
list(map(int, FLAGS.filter_sizes.split(","))),
FLAGS.num_filters, query_prof_dim, response_prof_dim,
FLAGS.dropout, FLAGS.l2_reg, FLAGS.learning_rate, paramD, None,
FLAGS.loss, True, FLAGS.score_type)
gen = Generator.Generator(
FLAGS.max_sequence_len, FLAGS.batch_size, len(vocab),
FLAGS.embedding_dim,
list(map(int, FLAGS.filter_sizes.split(","))),
FLAGS.num_filters, query_prof_dim, response_prof_dim,
FLAGS.dropout, FLAGS.l2_reg, FLAGS.learning_rate / 50, paramG,
None, FLAGS.loss, True, FLAGS.score_type)
sess.run(tf.global_variables_initializer())
for i in range(FLAGS.num_epochs):
#g_batch_size = len(eb_samples)
for g_epoch in range(FLAGS.g_epochs_num):
#if i == 0:
# break
step, current_loss, positive,negative, pos_score, neg_score = 0, 0.0, 0.0, 0.0, [],[]
for _index, row in enumerate(eb_samples):
#candidate_index = range(len(eb_samples))
#sampled_index = list(np.random.choice(candidate_index, size=[batch_size],replace=False))
#if _index not in sampled_index:
# sampled_index[-1] = _index
#sampled_index = list(candidate_index)
for ib in range(1):
ib = _index / batch_size
end_index = min((ib + 1) * batch_size,
len(eb_samples))
eb_sample_pools = eb_samples[end_index -
batch_size:end_index]
pro_sample_pools = pro_samples[
end_index - batch_size:end_index]
feed_dict = {
gen.input_x_1: [row[0]] * batch_size,
gen.input_x_2: [row[1]] * batch_size,
gen.input_x_3: eb_sample_pools[:, 2],
gen.prof_1:
[pro_samples[_index][0]] * batch_size,
gen.prof_2:
[pro_samples[_index][1]] * batch_size,
gen.prof_3: list(pro_sample_pools[:, 2])
}
predicted = sess.run(gen.gan_score, feed_dict)
exp_rating = np.exp(np.array(predicted) * 10)
prob = exp_rating / np.sum(exp_rating)
neg_index = np.random.choice(range(batch_size),
size=[FLAGS.gan_k],
p=prob,
replace=False)
feed_dict = {
dis.input_x_1: [row[0]] * FLAGS.gan_k,
dis.input_x_2: [row[1]] * FLAGS.gan_k,
dis.input_x_3: eb_sample_pools[neg_index][:,
2],
dis.prof_1:
[pro_samples[_index][0]] * FLAGS.gan_k,
dis.prof_2:
[pro_samples[_index][1]] * FLAGS.gan_k,
dis.prof_3:
list(pro_sample_pools[neg_index][:, 2])
}
reward = sess.run(dis.reward, feed_dict)
feed_dict = {
gen.input_x_1: eb_sample_pools[:, 0],
gen.input_x_2: eb_sample_pools[:, 1],
gen.input_x_3: eb_sample_pools[:, 2],
gen.prof_1: list(pro_sample_pools[:, 0]),
gen.prof_2: list(pro_sample_pools[:, 1]),
gen.prof_3: list(pro_sample_pools[:, 2]),
gen.neg_index: neg_index,
gen.reward: reward
}
_, step, current_loss, gan_score, pos, neg, pos_score, neg_score = sess.run(
[
gen.gan_updates, gen.global_step,
gen.gan_loss, gen.gans, gen.positive,
gen.negative, gen.pos_score, gen.neg_score
], feed_dict)
#print pos_score[:1], neg_score[:1],current_loss, step, _index, len(eb_samples)
line = (
"%s: GEN step %d %d, loss %f gan score %f ,pos score %f, neg score %f, total step: %d "
% (timestamp(), step, i, current_loss, gan_score, pos,
neg, FLAGS.num_epochs * FLAGS.g_epochs_num *
len(eb_samples)))
print line
log.write(line + "\n")
d_eb_samples, d_pro_samples = gan_samples(
eb_samples, pro_samples, sess, gen)
for d_epoch in range(FLAGS.d_epochs_num):
step, current_loss, accuracy = 0, 0.0, 0.0
for ib in range(num_batches):
end_index = min((ib + 1) * batch_size,
len(d_eb_samples))
eb_batch = d_eb_samples[end_index -
batch_size:end_index]
pro_batch = d_pro_samples[end_index -
batch_size:end_index]
feed_dict = {
dis.input_x_1: eb_batch[:, 0],
dis.input_x_2: eb_batch[:, 1],
dis.input_x_3: eb_batch[:, 2],
dis.prof_1: list(pro_batch[:, 0]),
dis.prof_2: list(pro_batch[:, 1]),
dis.prof_3: list(pro_batch[:, 2])
}
_, step, current_loss, accuracy, pos_score, neg_score = sess.run(
[
dis.updates, dis.global_step, dis.loss,
dis.accuracy, dis.positive, dis.negative
], feed_dict)
line = (
"%s: Dis step %d %d, loss %f with acc %f, pos score %f, neg score %f, total step: %d "
% (timestamp(), step, i, current_loss, accuracy,
pos_score, neg_score, FLAGS.num_epochs *
FLAGS.d_epochs_num * num_batches))
print line
log.write(line + '\n')
if i != FLAGS.num_epochs - 1:
evaluation(sess, gen, log, batch_size,
path + 'test_samples' + str(fold_index))
evaluation(sess, dis, log, batch_size,
path + 'test_samples' + str(fold_index))
evaluation(sess, gen, log, batch_size,
path + 'test_samples' + str(fold_index), True)
evaluation(sess, dis, log, batch_size,
path + 'test_samples' + str(fold_index), True)
def __init__(self, model_params):
self.word_indexer = model_params["word_indexer"]
self.word_embedder = model_params["word_embedder"]
self.embedding_size = model_params["embedding_size"]
self.state_size = model_params["state_size"]
self.mode_size = model_params["mode_size"]
self.position_size = model_params["position_size"]
self.ques_attention_size = model_params["ques_attention_size"]
self.kb_attention_size = model_params["kb_attention_size"]
self.dis_embedding_dim = model_params["dis_embedding_dim"]
self.dis_hidden_dim = model_params["dis_hidden_dim"]
self.max_fact_num = model_params["max_fact_num"]
self.max_ques_len = model_params["max_ques_len"]
self.learning_rate = model_params["learning_rate"]
self.mode_loss_rate = model_params["mode_loss_rate"]
self.position_loss_rate = model_params["position_loss_rate"]
self.L2_factor = model_params["L2_factor"]
self.batch_size = model_params["batch_size"]
self.adv_batch_size = model_params["adv_batch_size"]
self.epoch_size = model_params["epoch_size"]
self.adv_epoch_size = model_params["adv_epoch_size"]
self.instance_weight = 1.0 / self.batch_size
self.MAX_LENGTH = model_params["MAX_LENGTH"]
self.has_trained = False
self.oracle_samples = []
self.negative_samples = torch.zeros(1, self.MAX_LENGTH,
self.embedding_size)
################ Initialize graph components ########################
self.encoder = Encoder(self.word_indexer.wordCount, self.state_size,
self.embedding_size)
self.decoder = Decoder(output_size=self.word_indexer.wordCount,
state_size=self.state_size,
embedding_size=self.embedding_size,
mode_size=self.mode_size,
kb_attention_size=self.kb_attention_size,
max_fact_num=self.max_fact_num,
ques_attention_size=self.ques_attention_size,
max_ques_len=self.max_ques_len,
position_size=self.MAX_LENGTH)
self.positioner = Positioner(self.state_size, self.position_size,
self.MAX_LENGTH)
self.dis = Discriminator(self.embedding_size,
self.dis_hidden_dim,
self.word_indexer.wordCount,
self.MAX_LENGTH,
gpu=use_cuda)
if use_cuda:
self.encoder.cuda()
self.decoder.cuda()
self.positioner.cuda()
self.dis.cuda()
self.negative_samples = self.negative_samples.cuda()
self.optimizer = optim.Adam(list(self.encoder.parameters()) +
list(self.decoder.parameters()) +
list(self.positioner.parameters()),
lr=self.learning_rate,
weight_decay=self.L2_factor)
self.dis_optimizer = optim.Adagrad(self.dis.parameters())
