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 __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: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(): 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(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 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 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 D(width, height, channel, classes): # change different Discriminator here import Discriminator from keras.layers import Dense, Input from keras.models import Model width = 64 height = 64 channel = 1 classes = 41 Img = Input(shape=(width, height, channel)) x = Discriminator.paper_D(Img) x1 = Dense(classes, activation='softmax', name='label')(x) x2 = Dense(1, activation='sigmoid', name='auth')(x) D = Model(name='Discriminator', inputs=Img, outputs=[x1, x2])
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)
def init_model(config, mode): print('Initializing %s model...' % mode) if mode == 'disc': if config.model == 'transe': em = EmbeddingModel.TransE(config) elif config.model == 'transd': # config.embedding_size = config.embedding_size / 2 em = EmbeddingModel.TransD(config) # config.embedding_size = config.embedding_size * 2 else: raise ValueError('Unrecognized model type: %s' % config.model) model = Discriminator.BaseModel(config, em) elif mode == 'gen': em = EmbeddingModel.DistMult(config) model = GanGenerator(config, em) elif mode == 'sn_gen': em = EmbeddingModel.DistMult(config) model = GanGenerator(config, em) else: raise ValueError('Unrecognized mode: %s' % config.mode) model.build() return model
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)
def build_VGG(): input_layer = Input(shape=high_resolution_image_shape) vgg_model = tf.keras.applications.VGG19(weights='imagenet', include_top=False) vgg_model.outputs = [vgg_model.layers[vgg_out_layer].output] output_layer = vgg_model(input_layer) model = Model(input_layer, output_layer, name='VGG') model.trainable = False return model vgg = build_VGG() # build vgg model vgg.compile(loss=vgg_loss, optimizer=optimizer) # compile vgg generator = Generator.build_generator() discriminator = Discriminator.build_discriminator() discriminator.compile(loss=disc_loss, optimizer=optimizer) disc_output_shape = discriminator.output.shape n, h, w, c = disc_output_shape disc_output_shape = (h, w, c) lr_input = Input(low_resolution_image_shape, name='lr_input') hr_input = Input(high_resolution_image_shape, name='hr_input') fake_hr_images = generator(lr_input) vgg_features = vgg(fake_hr_images) discriminator.trainable = False validity = discriminator(fake_hr_images) total_model = Model([lr_input, hr_input], [validity, vgg_features],
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(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()
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)
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))
class Generator(Encoder,Decoder): 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 load_data(self, filename ): [self.train, self.test] = pickle.load() def init_params(self,filename): self.params = pickle.load(filename) def sample(self,y_t, type = 'max'): if type == 'max': return y_t.index(max(y_t)) elif type == 'sample': return np.random.multinomial(1,y_t,size=1).argmax() def MC(self,context, word_embed, response): #MC Rollout using Sampling -not Beam search- context_mc = context word_embed_mc = word_embed response_encoding = response while token!='<eor>': #save context embedding and use the same to be passed to discriminator [word_embed_mc,context_mc,y_t] = self.Decoder.sentence_decoder(word_embed_mc, context_mc, _) word_token = self.sample(y_t,type='max') response_encoding += [word_token] return response_encoding def save_params(self,text): pickle.dump(self.params,open("Generator_params_"+text)) def run_generator(self,): # initialize weights # i_t and o_t should be "open" or "closed" # f_t should be "open" (don't forget at the beginning of training) # we try to archive this by appropriate initialization of the corresponding biases [h_vals, _], _ = theano.scan(fn=self.Encoder.sentence_encoder, sequences = self.x_t, outputs_info = [self.h0, self.c0 ], # corresponds to return type of fn non_sequences = [None] ) [h1_vals,_], _ = theano.scan(fn=self.Encoder.utterance_Encoder, sequences =h_vals, outputs_info = [self.h0, self.c0 ], # corresponds to return type of fn non_sequences = [None] ) #p = sigma(theano.dot(h1_vals,self.V_d) + self.b_V_d) # cost = -T.mean(target * T.log(p[0])+ (1.- target) * T.log(1. - p[1])) self.response = [] token = '' b=0. count =0 self.cost=0. self.disc_loss = 0. while token!='<eor>': #save context embedding and use the same to be passed to discriminator [self.x_t,self.h0,y_t] = self.Decoder.sentence_decoder(stack(self.x_t,h1_vals), self.h0, _) word_token = self.sample(y_t,type='max') self.response+=[word_token] # if self.cost = 'tf': #Log-Likelihood self.cost + = - (count*cost + T.mean(self.target[count]*T.log(y_t) + (1.-self.target[count])*T.log(1.-y_t)))/(count+1.) #elif self.cost = 'gan': #GAN-training -REinforce RO_response = self.MC_rollout(context = self.h0,word_embed = self.x_t,self.response) [response_embed,_] = theano.scan(fn=self.Encoder.sentence_encoder, sequences = RO_response, outputs_info = [self.h0,self.c0] non_sequences = None) utterance_embed = theano.tensor.stack(response_embed,self.context) cost_d = self.evaluator.run_discriminator(utterances) self.disc_loss += -(count*disc_loss + T.mean(T.log(y_t)*(cost_d - b)))/(count + 1.) b = (count*b + cost_d)/(count + 1.) count += 1 self.lr = np.cast[dtype](self.lr) learning_rate = theano.shared(self.lr) self.res_gen = theano.function([self.x_t],self.response,updates = None) def get_updates(self,flag='gan'): if flag == "gan": for param in self.params: gparam = T.grad(self.disc_loss, param) self.gparams.append(gparam) self.updates=[] for param, gparam in zip(self.params, self.gparams): self.updates.append((param, param - gparam * learning_rate)) elif flag == "tf": for param in self.params: gparam = T.grad(cost, param) self.gparams.append(gparam) self.updates=[] for param, gparam in zip(self.params, self.gparams): self.updates.append((param, param - gparam * learning_rate)) self.gan_train_cost = theano.function([self.x_t,self.h0],self.disc_loss,updates = self.get_updates(self.cost)) self.tf_train_cost = theano.function([self.x_t,self.h0],self.cost,updates = self.get_updates(self.cost))
# 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()
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 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()
lightSpecs = [DataFile.getMassIntPairs(scanFDict[int(lightScanF)]['dta']) for lightScanF in lightScans] heavySpecs = [DataFile.getMassIntPairs(scanFDict[int(heavyScanF)]['dta']) for heavyScanF in heavyScans] avgLightPrecMass = np.average(np.array([scanFDict[lightScanF]['precMass'] for lightScanF in lightScans])) epSTD = options.ppmstd * 10**-6 * avgLightPrecMass specs = [] for i, massIntPairs in enumerate(lightSpecs): specs += [PN.Spectrum(PNet, scanFDict[lightScans[i]]['precMass'], Nmod=0.0, Cmod=0.0, epsilon=2*epSTD, spectrum=massIntPairs)] for i, massIntPairs in enumerate(heavySpecs): specs += [PN.Spectrum(PNet, scanFDict[heavyScans[i]]['precMass'], Nmod=pairConfig['NMod'], Cmod=pairConfig['CMod'], epsilon=2*epSTD, spectrum=massIntPairs)] for spec in specs: spec.initializeNoiseModel() clusterPairingStats = Discriminator.getClusterPairingStats(lightSpecs, heavySpecs, avgLightPrecMass, pairConfig, epSTD=epSTD) addClusterPairingStatsToFeatureList(clusterPairingStats, featureList) scoreStats = {} truePMs = {} prmLadders = {} for PSM in LADSSeqInfo[seqEntry]: lightSeq = An.preprocessSequence(PSM[1], seqMap, ambigEdges=PSM[2]) scoreStats[PSM[:2]] = Discriminator.getScoreStats(specs, lightSeq, ambigEdges=PSM[2]) prmLadderWithEnds = An.getPRMLadder(lightSeq, ambigEdges=PSM[2], addEnds=True) truePMs[PSM[:2]] = prmLadderWithEnds[-1] prmLadders[PSM[:2]] = prmLadderWithEnds[1:-1] PSMList = scoreStats.keys() spectrumOrderedScoreStats, clusterScoreStats = compileScoreStats(scoreStats, specs, PSMList)
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("/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)
def __init__(self): self.G_is_train = tf.placeholder(tf.bool) self.D_is_train = tf.placeholder(tf.bool) self.input_X = tf.placeholder(tf.float32, shape=(None, 28 * 28)) # t0は0のラベルを格納し、t1は1のラベルを格納する self.label_t0 = tf.placeholder(tf.float32, shape=(None, 1)) self.label_t1 = tf.placeholder(tf.float32, shape=(None, 1)) # Generator self.generator = gen.Generator(device_name=self.device_name) # 生成モデルに必要なノイズの入れ物 self.gen_z = tf.placeholder(tf.float32, shape=(None, 100)) # Discrimitor self.discrimitor = dis.Discrimitor(device_name=self.device_name) # weight decay gen_norm_term = tf.nn.l2_loss(self.generator.gen_w2) + tf.nn.l2_loss( self.generator.gen_w3) gen_lambda_ = 0.001 dis_norm_term = tf.nn.l2_loss(self.discrimitor.dis_w2) + tf.nn.l2_loss( self.discrimitor.dis_w3) dis_lambda_ = 0.001 # 訓練データの識別予測 input_X = self.discrimitor.run(self.input_X, is_train=self.D_is_train, device_name=self.device_name) # 生成されたデータの識別予測 generated_X = self.discrimitor.run(self.generator.run( z=self.gen_z, is_train=self.G_is_train, device_name=self.device_name), is_train=self.D_is_train, device_name=self.device_name) self.dis_entropy_X = tf.nn.sigmoid_cross_entropy_with_logits( labels=self.label_t1, logits=input_X) self.dis_entropy_G = tf.nn.sigmoid_cross_entropy_with_logits( labels=self.label_t0, logits=generated_X) self.dis_loss = tf.reduce_mean(self.dis_entropy_X + self.dis_entropy_G ) + dis_norm_term * dis_lambda_ self.gen_entropy = tf.nn.sigmoid_cross_entropy_with_logits( labels=self.label_t1, logits=generated_X) self.gen_loss = tf.reduce_mean( self.gen_entropy) #+ gen_norm_term * gen_lambda_ # 最適化する際にDならDのみのパラメータを、GならGのみのパラメータを更新するようにしたいのでモデル別の変数を取得する dis_vars = [x for x in tf.trainable_variables() if "dis_" in x.name] gen_vars = [x for x in tf.trainable_variables() if "gen_" in x.name] # 識別モデルDの最適化 self.opt_d = tf.train.AdamOptimizer(0.0002, beta1=0.1).minimize( self.dis_loss, var_list=[dis_vars]) # 生成モデルGの最適化 self.opt_g = tf.train.AdamOptimizer(0.0002, beta1=0.5).minimize( self.gen_loss, var_list=[gen_vars])
class GAN: from matplotlib import pyplot as plt # draw picture os.environ['TF_XLA_FLAGS'] = '--tf_xla_enable_xla_devices' # enable XLA Devices # define the constants BUFFER_SIZE = 300 ## change the order of image BATCH_SIZE = 1 # batch_size=1 means the trainig is very fast and one picture only trained for 1 time IMG_WIDTH = 256 # define the image size and it must be 256*256*3 because of Unet IMG_HEIGHT = 256 # define the image size LAMBDA = 98 # define the constant number of Lambada OUTPUT_CHANNELS = 3 # channel=1 is enough but 3 can use for color images and it depends on the datasets EPOCHS = 200 # set traning epochs and it is limited by the training sets and Max is 213 because of the size in train folder gan_count=0 "Build the Optimizers of generator and discriminator with Adam method and set the teta_1 as 0.5" optimizer_of_generator_with_Adam_algorithm = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) # optimizer the generator optimizer_of_discriminator_with_Adam_algorithm = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) # optimizer the generator "Build an instance of class Load_Function_Set()" load_function_set = load_function.Load_Function_Set() " load data from train folder and test folder" image_data_in_train_folder = load_function_set.load_and_prepare_data_from_training_folder() # load all images and convert them into suitable data for training in training folder image_data_in_test_folder = load_function_set.load_and_prepare_data_from_test_folder() # load all images and convert them into suitable data for training in test folder "Build Generator with Unet architecture" generator_set = Generator_with_Unet.Generator_Set() generator_with_unet = generator_set.Generator_based_on_paper() # create a generator with U-net "Set the type of calculating loss value as Binary" value_after_Cross_Entropy_calculation = tf.keras.losses.BinaryCrossentropy( from_logits=True) # use binary method to calculate the cross entropy "Build discriminator with VGG architecture" discriminator_set = Discriminator.Discriminator_Set() discriminator = discriminator_set.Discriminator_based_on_VGG() # create discriminator by using downsample "Set the type of calculating loss value as Categorical" value_after_Categorical_Cross_Entropy_calculation = tf.keras.losses.CategoricalCrossentropy # get the loss value by caterorical cross entropy image_processing_set = image_processing.Image_Processing_Set() def __init__(self,name,epoch): self.name=name self.EPOCHS=epoch print("Build "+name+" Successfully") GAN.gan_count+=1 def print_summary_of_G_and_D(self): self.generator_with_unet.summary() # print the summary of generator. Total params: 16,667,907,Trainable params: 16,661,635, Non-trainable params: 6,272 self.discriminator.summary() # output the information of discriminator def plot_model_structure(self): tf.keras.utils.plot_model(self.generator_with_unet, show_shapes=True, dpi=64, to_file='Generator Structure.png') # plot the model of generator tf.keras.utils.plot_model(self.discriminator, show_shapes=True, dpi=64, to_file='Discriminator Structure.png', ) # plot thte discriminator details @tf.function def step_of_training_GAN_with_Gradient(self,corresponding_picture, images_of_real_building, epoch): # define every step trainning with tf.GradientTape() as tape_of_generator, tf.GradientTape() as tape_of_discriminater: # divided the gradient tap into two parts and this is very important output_value_of_generator = self.generator_with_unet(corresponding_picture, training=True) # get the output of generator value_of_disc_for_real_image = self.discriminator([corresponding_picture, images_of_real_building], training=True) # get the disc value of real image value_of_disc_from_generated_image = self.discriminator([corresponding_picture, output_value_of_generator], training=True) # get the disc value of generated image gen_total_loss, gen_gan_loss, gen_l1_loss = calculation_of_loss_value.loss_value_of_generator( value_of_disc_from_generated_image, output_value_of_generator, images_of_real_building) # get the loss value loss_value_of_disc = calculation_of_loss_value.get_the_loss_value_of_discriminator( value_of_disc_for_real_image, value_of_disc_from_generated_image) # get the disc loss value gradients_value_from_discriminator = tape_of_discriminater.gradient(loss_value_of_disc, self. discriminator.trainable_variables) # get the gradients value of discriminator gradients_value_from_generator = tape_of_generator.gradient(gen_total_loss, self. generator_with_unet.trainable_variables) # get the gradients value of generator self.optimizer_of_generator_with_Adam_algorithm.apply_gradients(zip(gradients_value_from_generator, self. generator_with_unet.trainable_variables)) # optimizer generator by using Adam method self.optimizer_of_discriminator_with_Adam_algorithm.apply_gradients( zip(gradients_value_from_discriminator, self. discriminator.trainable_variables)) ##optimizer discriminator Adam method def trainning_GAN(self,dataset_of_trainning, dataset_of_test, epochs): for epoch in range(epochs): # define details in every epoch for an_corresponding_picture, an_target_image in dataset_of_test.take( 1): # for every image in dataset, there will be a predicted image self.image_processing_set.predict_images_from_generator(an_corresponding_picture, an_target_image, self.generator_with_unet) # excuted predict function to generate images print("The image of result is saved in current folder after every 2 epochs") print("Current epoch number: ", epoch," of ", self.name, " is trainning...........") # Train for j, (corresponding_picture, images_of_real_building) in dataset_of_trainning.enumerate(): # apply gradient for iteration and change the generator and discriminator self.step_of_training_GAN_with_Gradient(corresponding_picture, images_of_real_building, epoch) # excute the details of training in every step if epoch % 2 == 0 and epoch > 0: # save the image every 2 epoches self.plt.savefig(str(epoch)+"Epoch" +self.name+ 'result.jpg') # first character is the epoch numbers and if epoch % 200 == 0 and epoch > 0: # show image when the program is finished # plt.show()# show image print("Training is finished") # hint for training finished "Train GAN with the given number of epochs and the data from train folder, test folder " def start_train(self): self.trainning_GAN( self.image_data_in_train_folder, self.image_data_in_test_folder, self.EPOCHS) # Maximize the number of training, but it only has 213 pictures in train sets
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 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 getSpectrumAndPSMFeatureDict(LADSSeqInfo, seqEntry, scanFDict, pairConfig, PNet): featureList = [] lightScans = seqEntry[0] heavyScans = seqEntry[1] lightSpecs = [DataFile.getMassIntPairs(scanFDict[int(lightScanF)]['dta']) for lightScanF in lightScans] heavySpecs = [DataFile.getMassIntPairs(scanFDict[int(heavyScanF)]['dta']) for heavyScanF in heavyScans] avgLightPrecMass = np.average(np.array([scanFDict[lightScanF]['precMass'] for lightScanF in lightScans])) epSTD = options.ppmstd * 10**-6 * avgLightPrecMass specs = [] for i, massIntPairs in enumerate(lightSpecs): specs += [PN.Spectrum(PNet, scanFDict[lightScans[i]]['precMass'], Nmod=0.0, Cmod=0.0, epsilon=2*epSTD, spectrum=massIntPairs)] for i, massIntPairs in enumerate(heavySpecs): specs += [PN.Spectrum(PNet, scanFDict[heavyScans[i]]['precMass'], Nmod=pairConfig['NMod'], Cmod=pairConfig['CMod'], epsilon=2*epSTD, spectrum=massIntPairs)] for spec in specs: spec.initializeNoiseModel() clusterPairingStats = Discriminator.getClusterPairingStats(lightSpecs, heavySpecs, avgLightPrecMass, pairConfig, epSTD=epSTD) GLFD.addClusterPairingStatsToFeatureList(clusterPairingStats, featureList) scoreStats = {} truePMs = {} prmLadders = {} for PSM in LADSSeqInfo[seqEntry]: lightSeq = An.preprocessSequence(PSM[1], seqMap, ambigEdges=PSM[2]) scoreStats[PSM[:2]] = Discriminator.getScoreStats(specs, lightSeq, ambigEdges=PSM[2]) prmLadderWithEnds = An.getPRMLadder(lightSeq, ambigEdges=PSM[2], addEnds=True) truePMs[PSM[:2]] = prmLadderWithEnds[-1] prmLadders[PSM[:2]] = prmLadderWithEnds[1:-1] PSMList = scoreStats.keys() spectrumOrderedScoreStats, clusterScoreStats = GLFD.compileScoreStats(scoreStats, specs, PSMList) spectrumAndPSMSpecificFeatureDict = {} PSMIndexDict = dict([(PSM, i) for i, PSM in enumerate(PSMList)]) for i, PSM in enumerate(LADSSeqInfo[seqEntry]): PSMSpecificFeatureList = copy.copy(featureList) peptLength = len(prmLadders[PSM[:2]]) + 1 # Add LADS PScore (and normalized variants) and delta rank, delta score (LADS PScore) to feature list PSMSpecificFeatureList += [PSM[0], PSM[0]/peptLength, PSM[0]/len(specs), -i, PSM[0]-LADSSeqInfo[seqEntry][0][0]] # Add Total Path Score (and normalized variants) and delta rank, delta score (total path score) and total minimum node score to feature list totalPathScore = scoreStats[PSM[:2]]['Total Path Score'] PSMSpecificFeatureList += [totalPathScore, totalPathScore/peptLength, totalPathScore/len(specs), -clusterScoreStats['PSM Rankings'][PSMIndexDict[PSM[:2]]], totalPathScore-clusterScoreStats['Max Cluster Path Score'], scoreStats[PSM[:2]]['Total Minimum Node Score']] # Add minimum path score, maximum path score, (and normalized variants) and minimum score/maximum score for cluster to feature list PSMSpecificFeatureList += [scoreStats[PSM[:2]]['Minimum Path Score'], scoreStats[PSM[:2]]['Minimum Path Score']/peptLength, scoreStats[PSM[:2]]['Maximum Path Score'], scoreStats[PSM[:2]]['Maximum Path Score']/peptLength, scoreStats[PSM[:2]]['Minimum Path Score']/scoreStats[PSM[:2]]['Maximum Path Score']] # Add difference between minimum and maximum ranking for PSM across cluster to feature list rankingsForPSM = [spectrumOrderedScoreStats[i]['PSM Rankings'][PSMIndexDict[PSM[:2]]] for i in spectrumOrderedScoreStats] PSMSpecificFeatureList += [min(rankingsForPSM) - max(rankingsForPSM)] #Add Number forbidden node pairs (and normalized variants) to feature list numForbiddenPairs = Discriminator.getNumForbiddenPairs(prmLadders[PSM[:2]], avgLightPrecMass) PSMSpecificFeatureList += [numForbiddenPairs, 2.0*numForbiddenPairs/(peptLength-1)] # Add number of ambiguous edges to feature list PSMSpecificFeatureList += [len(PSM[2])] # Add stats for PRM Evidence over cluster (and normalized variants) to feature list PSMSpecificFeatureList += [scoreStats[PSM[:2]]['Aggregate PRM Score Statistics']['All Evidence'], scoreStats[PSM[:2]]['Aggregate PRM Score Statistics']['All Evidence']/float(peptLength-1), scoreStats[PSM[:2]]['Aggregate PRM Score Statistics']['Majority Evidence'], scoreStats[PSM[:2]]['Aggregate PRM Score Statistics']['Majority Evidence']/float(peptLength-1), scoreStats[PSM[:2]]['Aggregate PRM Score Statistics']['None Evidence'], scoreStats[PSM[:2]]['Aggregate PRM Score Statistics']['None Evidence']/float(peptLength-1)] # Add stats for paired PRMs and their corresponding ion types to feature list pairedPRMStats = Discriminator.getPairedPRMStats(prmLadders[PSM[:2]], clusterPairingStats['Light Merged Spec'], clusterPairingStats['Heavy Merged Spec'], lightSpecs, heavySpecs, clusterPairingStats['Cluster Paired PRM Information'], epSTD=epSTD) GLFD.addPairedPRMStatsToFeatureList(pairedPRMStats, PSMSpecificFeatureList, len(prmLadders[PSM[:2]])) pairedPRMLadder = pairedPRMStats['Paired PRM Ladder'] for i, scan in enumerate(lightScans): spectrumSpecificFeatureList = copy.copy(PSMSpecificFeatureList) # Add path score (and normalized variants), delta rank, delta score, number of negative PRMs, and minimum node score for spectrum to feature list pathScore = spectrumOrderedScoreStats[i]['Path Scores'][PSMIndexDict[PSM[:2]]] numNegativePRMs = spectrumOrderedScoreStats[i]['Num Negative PRMs'][PSMIndexDict[PSM[:2]]] spectrumSpecificFeatureList += [pathScore, pathScore/peptLength, pathScore/scoreStats[PSM[:2]]['Maximum Path Score'], -spectrumOrderedScoreStats[i]['PSM Rankings'][PSMIndexDict[PSM[:2]]], spectrumOrderedScoreStats[i]['Delta Scores'][PSMIndexDict[PSM[:2]]], numNegativePRMs, numNegativePRMs/float(peptLength-1), spectrumOrderedScoreStats[i]['Min Node Scores'][PSMIndexDict[PSM[:2]]]] # Add mass deviation from true peptide mass to feature list precMass = scanFDict[scan]['precMass'] spectrumSpecificFeatureList += [abs(truePMs[PSM[:2]] + Constants.mods['H2O'] + Constants.mods['H+'] - precMass)] peakAnnotationMassOffsetStats = Discriminator.getPeakAnnotationAndMassOffsetStats(DataFile.getMassIntPairs(scanFDict[scan]['dta']), specs[i], prmLadders[PSM[:2]], pairedPRMLadder, PNet) GLFD.addPeakAnnotationStatsToFeatureList(PNet, peakAnnotationMassOffsetStats, spectrumSpecificFeatureList, peptLength) GLFD.addMassOffsetStatsToFeatureList(peakAnnotationMassOffsetStats, spectrumSpecificFeatureList) spectrumSpecificFeatureList += [precMass, GLFD.getChargeStateFromDTAFName(scanFDict[scan]['dta']), peptLength] spectrumAndPSMSpecificFeatureDict[(scan, PSM[:2])] = spectrumSpecificFeatureList for j, scan in enumerate(heavyScans): i = j + len(lightScans) spectrumSpecificFeatureList = copy.copy(PSMSpecificFeatureList) # Add path score (and normalized variants), delta rank, delta score, number of negative PRMs, and minimum node score for spectrum to feature list pathScore = spectrumOrderedScoreStats[i]['Path Scores'][PSMIndexDict[PSM[:2]]] numNegativePRMs = spectrumOrderedScoreStats[i]['Num Negative PRMs'][PSMIndexDict[PSM[:2]]] spectrumSpecificFeatureList += [pathScore, pathScore/peptLength, pathScore/scoreStats[PSM[:2]]['Maximum Path Score'], -spectrumOrderedScoreStats[i]['PSM Rankings'][PSMIndexDict[PSM[:2]]], spectrumOrderedScoreStats[i]['Delta Scores'][PSMIndexDict[PSM[:2]]], numNegativePRMs, numNegativePRMs/float(peptLength-1), spectrumOrderedScoreStats[i]['Min Node Scores'][PSMIndexDict[PSM[:2]]]] # Add mass deviation from true peptide mass to feature list precMass = scanFDict[scan]['precMass'] spectrumSpecificFeatureList += [abs(truePMs[PSM[:2]] + pairConfig['NMod'] + pairConfig['CMod'] + Constants.mods['H2O'] + Constants.mods['H+'] - precMass)] peakAnnotationMassOffsetStats = Discriminator.getPeakAnnotationAndMassOffsetStats(DataFile.getMassIntPairs(scanFDict[scan]['dta']), specs[i], prmLadders[PSM[:2]], pairedPRMLadder, PNet) GLFD.addPeakAnnotationStatsToFeatureList(PNet, peakAnnotationMassOffsetStats, spectrumSpecificFeatureList, peptLength) GLFD.addMassOffsetStatsToFeatureList(peakAnnotationMassOffsetStats, spectrumSpecificFeatureList) spectrumSpecificFeatureList += [precMass, GLFD.getChargeStateFromDTAFName(scanFDict[scan]['dta']), peptLength] spectrumAndPSMSpecificFeatureDict[(scan, PSM[:2])] = spectrumSpecificFeatureList return spectrumAndPSMSpecificFeatureDict