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())