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
