def train(self, config):
seed = 0
np.random.seed(seed)
tf.set_random_seed(seed)
"""Train DCGAN"""
if config.dataset == "mnist":
data_X, val_data, test_data, train_dist = mnist_data.load_mnist()
elif config.dataset == "cifar":
data_X, val_data, test_data = cifar_data.load_cifar()
if self.model_type == "nice":
val_data = np.reshape(val_data, (-1, self.image_size))
test_data = np.reshape(test_data, (-1, self.image_size))
lr = config.learning_rate
self.learning_rate = tf.placeholder(tf.float32, [], name='lr')
d_optim_ = tf.train.AdamOptimizer(self.learning_rate,
beta1=config.beta1,
beta2=0.9)
d_grad = d_optim_.compute_gradients(self.d_loss, var_list=self.d_vars)
d_grad_mag = tf.global_norm(d_grad)
d_optim = d_optim_.apply_gradients(d_grad)
g_optim_ = tf.train.AdamOptimizer(self.learning_rate,
beta1=config.beta1,
beta2=0.9)
if self.n_critic <= 0:
g_grad = g_optim_.compute_gradients(self.train_log_likelihood \
, var_list=self.g_vars)
else:
if self.like_reg > 0:
if self.model_type == "real_nvp":
g_grad_1 = g_optim_.compute_gradients(self.g_loss /
self.like_reg,
var_list=self.g_vars)
g_grad_2 = g_optim_.compute_gradients(
self.train_log_likelihood, var_list=self.g_vars)
grads_1, _ = zip(*g_grad_1)
grads_2, _ = zip(*g_grad_2)
sum_grad = [g1 + g2 for g1, g2 in zip(grads_1, grads_2)]
g_grad = [
pair for pair in zip(sum_grad,
[var for grad, var in g_grad_1])
]
else:
g_grad = g_optim_.compute_gradients(
self.g_loss / self.like_reg +
self.train_log_likelihood,
var_list=self.g_vars)
else:
g_grad = g_optim_.compute_gradients(self.g_loss,
var_list=self.g_vars)
g_grad_mag = tf.global_norm(g_grad)
g_optim = g_optim_.apply_gradients(g_grad)
try: ##for data-dependent init (not implemented)
if self.model_type == "real_nvp":
self.sess.run(tf.global_variables_initializer(),
{self.x_init: data_X[0:config.batch_size]})
else:
self.sess.run(tf.global_variables_initializer())
except:
if self.model_type == "real_nvp":
self.sess.run(tf.global_variables_initializer(),
{self.x_init: data_X[0:config.batch_size]})
else:
self.sess.run(tf.global_variables_initializer())
self.g_sum = merge_summary([
self.z_sum, self.d__sum, self.G_sum, self.d_loss_fake_sum,
self.g_loss_sum
])
self.d_sum = merge_summary(
[self.z_sum, self.d_sum, self.d_loss_real_sum, self.d_loss_sum])
self.writer = SummaryWriter("./" + self.log_dir, self.sess.graph)
counter = 1
start_time = time.time()
could_load, checkpoint_counter = self.load(self.checkpoint_dir)
if could_load:
counter = checkpoint_counter
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
############## A FIXED BATCH OF Zs FOR GENERATING SAMPLES ######################
if self.prior == "uniform":
sample_z = np.random.uniform(-1,
1,
size=(self.sample_num, self.z_dim))
elif self.prior == "logistic":
sample_z = np.random.logistic(loc=0.,
scale=1.,
size=(self.sample_num, self.z_dim))
elif self.prior == "gaussian":
sample_z = np.random.normal(0.0,
1.0,
size=(self.sample_num, self.z_dim))
else:
print("ERROR: Unrecognized prior...exiting")
exit(-1)
################################ Evaluate initial model lli ########################
val_nlli = self.evaluate_neg_loglikelihood(val_data, config)
# train_nlli = self.evaluate_neg_loglikelihood(train_data, config)
curr_inception_score = self.calculate_inception_and_mode_score()
print("INITIAL TEST: val neg logli: %.8f,incep score: %.8f" % (val_nlli, \
curr_inception_score[0]))
if counter > 1:
old_data = np.load("./" + config.sample_dir + '/graph_data.npy')
self.best_val_nlli = old_data[2]
self.best_model_counter = old_data[3]
self.best_model_path = old_data[4]
self.val_nlli_list = old_data[1]
self.counter_list = old_data[5]
self.batch_train_nlli_list = old_data[-4]
self.inception_list = old_data[-2]
self.samples_list = old_data[0]
self.loss_list = old_data[-1]
manifold_h, manifold_w = old_data[6]
else:
self.writer.add_summary(tf.Summary( \
value=[tf.Summary.Value(tag="Val Neg Log-likelihood", simple_value=val_nlli)]), counter)
# self.writer.add_summary(tf.Summary(\
# value=[tf.Summary.Value(tag="Train Neg Log-likelihood", simple_value=train_nlli)]), counter)
self.best_val_nlli = val_nlli
# self.best_model_train_nlli = train_nlli
self.best_model_counter = counter
self.best_model_path = self.save(config.checkpoint_dir, counter)
# self.train_nlli_list = [train_nlli]
self.val_nlli_list = [val_nlli]
self.counter_list = [1]
self.batch_train_nlli_list = []
self.inception_list = [curr_inception_score]
self.samples_list = self.sess.run([self.sampler],
feed_dict={
self.z: sample_z,
})
sample_inputs = data_X[0:config.batch_size]
samples = self.samples_list[0]
manifold_h = int(np.ceil(np.sqrt(samples.shape[0])))
manifold_w = int(np.floor(np.sqrt(samples.shape[0])))
self.loss_list = self.sess.run(
[self.d_loss_real, self.d_loss_fake],
feed_dict={
self.z: sample_z,
self.inputs: sample_inputs,
})
##################################################################################
for epoch in xrange(config.epoch):
np.random.shuffle(data_X)
batch_idxs = len(data_X) // config.batch_size
for idx in xrange(0, batch_idxs):
sys.stdout.flush()
batch_images = data_X[idx * config.batch_size:(idx + 1) *
config.batch_size]
if self.prior == "uniform":
batch_z = np.random.uniform(-1, 1, [config.batch_size, self.z_dim]) \
.astype(np.float32)
elif self.prior == "logistic":
batch_z = np.random.logistic(loc=0., scale=1.0, size=[config.batch_size, self.z_dim]) \
.astype(np.float32)
elif self.prior == "gaussian":
batch_z = np.random.normal(0.0,
1.0,
size=(config.batch_size,
self.z_dim))
else:
print("ERROR: Unrecognized prior...exiting")
exit(-1)
for r in range(self.n_critic):
_, d_g_mag, errD_fake, errD_real, summary_str = self.sess.run(
[
d_optim, d_grad_mag, self.d_loss_fake,
self.d_loss_real, self.d_sum
],
feed_dict={
self.inputs: batch_images,
self.z: batch_z,
self.learning_rate: lr,
})
if self.n_critic > 0:
self.writer.add_summary(summary_str, counter)
# Update G network
if self.like_reg > 0 or self.n_critic <= 0:
_, g_g_mag, errG, summary_str = self.sess.run(
[g_optim, g_grad_mag, self.g_loss, self.g_sum],
feed_dict={
self.z: batch_z,
self.learning_rate: lr,
self.inputs: batch_images,
})
else:
_, g_g_mag, errG, summary_str = self.sess.run(
[g_optim, g_grad_mag, self.g_loss, self.g_sum],
feed_dict={
self.z: batch_z,
self.learning_rate: lr,
})
self.writer.add_summary(summary_str, counter)
batch_images_nl = batch_images
if self.model_type == "nice":
batch_images_nl = np.reshape(
batch_images_nl,
(self.batch_size, -1))[:, self.permutation]
b_train_nlli = self.sess.run([self.log_likelihood],
feed_dict={
self.log_like_batch:
batch_images_nl,
})
b_train_nlli = b_train_nlli[0]
self.batch_train_nlli_list.append(b_train_nlli)
if self.n_critic > 0:
self.loss_list.append([errD_real, errD_fake])
self.writer.add_summary(tf.Summary( \
value=[tf.Summary.Value(tag="training loss", simple_value=-(errD_fake + errD_real))]), counter)
self.writer.add_summary(tf.Summary( \
value=[tf.Summary.Value(tag="Batch train Neg Log-likelihood", simple_value=b_train_nlli)]), counter)
counter += 1
lr = max(lr * self.lr_decay, self.min_lr)
if np.mod(counter, 703) == 1: # 340
if self.n_critic > 0:
print(
"Epoch: [%2d] [%4d/%4d] time: %4.4f, d_loss: %.8f, g_loss: %.8f, d_grad_mag: %.8f, g_grad_mag: %.8f, lr: %.8f" \
% (epoch, idx, batch_idxs,
time.time() - start_time, errD_fake + errD_real, errG, d_g_mag, g_g_mag, lr))
else:
print("Epoch: [%2d] [%4d/%4d] time: %4.4f, g_loss: %.8f, g_grad_mag: %.8f, lr: %.8f" \
% (epoch, idx, batch_idxs,
time.time() - start_time, errG, g_g_mag, lr))
curr_model_path = self.save(config.checkpoint_dir, counter)
val_nlli = self.evaluate_neg_loglikelihood(
val_data, config)
# train_nlli = self.evaluate_neg_loglikelihood(train_data, config)
curr_inception_score = self.calculate_inception_and_mode_score(
)
print("[LogLi (%d,%d)]: val neg logli: %.8f, ince: %.8f, train lli: %.8f" % (epoch, idx, val_nlli, \
curr_inception_score[
0], np.mean(
self.batch_train_nlli_list[-700:])))
self.writer.add_summary(tf.Summary( \
value=[tf.Summary.Value(tag="Val Neg Log-likelihood", simple_value=val_nlli)]), counter)
# self.writer.add_summary(tf.Summary(\
# value=[tf.Summary.Value(tag="Train Neg Log-likelihood", simple_value=train_nlli)]), counter)
if val_nlli < self.best_val_nlli:
self.best_val_nlli = val_nlli
self.best_model_counter = counter
self.best_model_path = curr_model_path
# self.best_model_train_nlli = train_nlli
# self.train_nlli_list.append(train_nlli)
self.val_nlli_list.append(val_nlli)
self.counter_list.append(counter)
samples, d_loss, g_loss = self.sess.run(
[self.sampler, self.d_loss, self.g_loss],
feed_dict={
self.z: sample_z,
self.inputs: sample_inputs,
})
self.samples_list.append(samples)
self.samples_list[-1].shape[1]
manifold_h = int(np.ceil(np.sqrt(samples.shape[0])))
manifold_w = int(np.floor(np.sqrt(samples.shape[0])))
self.inception_list.append(curr_inception_score)
save_images(
samples, [manifold_h, manifold_w],
'./{}/train_{:02d}_{:04d}.png'.format(
config.sample_dir, epoch, idx))
print("[Sample] d_loss: %.8f, g_loss: %.8f" %
(d_loss, g_loss))
np.save("./" + config.sample_dir + '/graph_data',
[self.samples_list, self.val_nlli_list, self.best_val_nlli, self.best_model_counter, \
self.best_model_path, self.counter_list, [manifold_h, manifold_w], \
self.batch_train_nlli_list, self.inception_list, self.loss_list])
np.save("./" + config.sample_dir + '/graph_data',
[self.samples_list, self.val_nlli_list, self.best_val_nlli, self.best_model_counter, \
self.best_model_path, self.counter_list, [manifold_h, manifold_w], \
self.batch_train_nlli_list, self.inception_list, self.loss_list])
self.test_model(test_data, config)
def main(_):
np.random.seed(0)
tf.set_random_seed(0)
pp.pprint(flags.FLAGS.__flags)
if FLAGS.input_width is None:
FLAGS.input_width = FLAGS.input_height
if not os.path.exists(FLAGS.checkpoint_dir):
os.makedirs(FLAGS.checkpoint_dir)
if not os.path.exists(FLAGS.sample_dir):
os.makedirs(FLAGS.sample_dir)
run_config = tf.ConfigProto()
run_config.gpu_options.allow_growth = True
run_config.allow_soft_placement = True
sess = None
# main.py - -dataset
# mnist - -input_height = 28 - -output_height = 28 - -train
# - -dataset
# mnist - -input_height = 28 - -output_height = 28 - -train
flags2 = tf.app.flags
#flags2.DEFINE_integer("epoch2", 25, "Epoch to train [25]")
flags2.DEFINE_integer("epoch2", 251, "Epoch to train [25]")
flags2.DEFINE_float("learning_rate2", 0.0002,
"Learning rate of for adam [0.0002]")
flags2.DEFINE_float("beta12", 0.5, "Momentum term of adam [0.5]")
flags2.DEFINE_float("train_size2", np.inf,
"The size of train images [np.inf]")
#flags2.DEFINE_integer("batch_size2", 1024, "The size of batch images [64]")
flags2.DEFINE_integer("batch_size2", 512, "The size of batch images [64]")
#flags2.DEFINE_integer("batch_size2", 256, "The size of batch images [64]")
flags2.DEFINE_integer(
"input_height2", 28,
"The size of image to use (will be center cropped). [108]")
flags2.DEFINE_integer(
"input_width2", None,
"The size of image to use (will be center cropped). If None, same value as input_height [None]"
)
flags2.DEFINE_integer("output_height2", 28,
"The size of the output images to produce [64]")
flags2.DEFINE_integer(
"output_width2", None,
"The size of the output images to produce. If None, same value as output_height [None]"
)
flags2.DEFINE_string("dataset2", "mnist",
"The name of dataset [celebA, mnist, lsun]")
flags2.DEFINE_string("input_fname_pattern2", "*.jpg",
"Glob pattern of filename of input images [*]")
flags2.DEFINE_string("data_dir2", "./data",
"path to datasets [e.g. $HOME/data]")
flags2.DEFINE_string("out_dir2", "./out",
"Root directory for outputs [e.g. $HOME/out]")
flags2.DEFINE_string(
"out_name2", "",
"Folder (under out_root_dir) for all outputs. Generated automatically if left blank []"
)
flags2.DEFINE_string(
"checkpoint_dir2", "checkpoint",
"Folder (under out_root_dir/out_name) to save checkpoints [checkpoint]"
)
flags2.DEFINE_string(
"sample_dir2", "samples",
"Folder (under out_root_dir/out_name) to save samples [samples]")
flags2.DEFINE_boolean("train2", True,
"True for training, False for testing [False]")
flags2.DEFINE_boolean("crop2", False,
"True for training, False for testing [False]")
flags2.DEFINE_boolean("visualize2", False,
"True for visualizing, False for nothing [False]")
flags2.DEFINE_boolean("export2", False,
"True for exporting with new batch size")
flags2.DEFINE_boolean("freeze2", False,
"True for exporting with new batch size")
flags2.DEFINE_integer("max_to_keep2", 1,
"maximum number of checkpoints to keep")
flags2.DEFINE_integer("sample_freq2", 200,
"sample every this many iterations")
flags2.DEFINE_integer("ckpt_freq2", 200,
"save checkpoint every this many iterations")
flags2.DEFINE_integer("z_dim2", 100, "dimensions of z")
flags2.DEFINE_string("z_dist2", "uniform_signed",
"'normal01' or 'uniform_unsigned' or uniform_signed")
flags2.DEFINE_boolean("G_img_sum2", False,
"Save generator image summaries in log")
# flags.DEFINE_integer("generate_test_images", 100, "Number of images to generate during test. [100]")
FLAGS2 = flags2.FLAGS
pp.pprint(flags2.FLAGS.__flags)
# expand user name and environment variables
FLAGS2.data_dir2 = expand_path(FLAGS2.data_dir2)
FLAGS2.out_dir2 = expand_path(FLAGS2.out_dir2)
FLAGS2.out_name2 = expand_path(FLAGS2.out_name2)
FLAGS2.checkpoint_dir2 = expand_path(FLAGS2.checkpoint_dir2)
FLAGS2.sample_dir2 = expand_path(FLAGS2.sample_dir2)
if FLAGS2.output_height2 is None:
FLAGS2.output_height2 = FLAGS2.input_height2
if FLAGS2.input_width2 is None: FLAGS2.input_width2 = FLAGS2.input_height2
if FLAGS2.output_width2 is None:
FLAGS2.output_width2 = FLAGS2.output_height2
# output folders
if FLAGS2.out_name2 == "":
FLAGS2.out_name2 = '{} - {} - {}'.format(
timestamp(),
FLAGS2.data_dir2.split('/')[-1],
FLAGS2.dataset2) # penultimate folder of path
if FLAGS2.train2:
FLAGS2.out_name2 += ' - x{}.z{}.{}.y{}.b{}'.format(
FLAGS2.input_width2, FLAGS2.z_dim2, FLAGS2.z_dist2,
FLAGS2.output_width2, FLAGS2.batch_size2)
FLAGS2.out_dir2 = os.path.join(FLAGS2.out_dir2, FLAGS2.out_name2)
FLAGS2.checkpoint_dir2 = os.path.join(FLAGS2.out_dir2,
FLAGS2.checkpoint_dir2)
FLAGS2.sample_dir2 = os.path.join(FLAGS2.out_dir2, FLAGS2.sample_dir2)
if not os.path.exists(FLAGS2.checkpoint_dir2):
os.makedirs(FLAGS2.checkpoint_dir2)
if not os.path.exists(FLAGS2.sample_dir2): os.makedirs(FLAGS2.sample_dir2)
with open(os.path.join(FLAGS2.out_dir2, 'FLAGS.json'), 'w') as f:
flags_dict = {k: FLAGS2[k].value for k in FLAGS2}
json.dump(flags_dict, f, indent=4, sort_keys=True, ensure_ascii=False)
# gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
run_config = tf.ConfigProto()
run_config.gpu_options.allow_growth = True
with tf.Session(config=run_config) as sess:
dcgan = DCGAN(sess,
input_width=FLAGS.input_width,
input_height=FLAGS.input_height,
batch_size=FLAGS.batch_size,
sample_num=FLAGS.batch_size,
c_dim=FLAGS.c_dim,
z_dim=FLAGS.c_dim * FLAGS.input_height *
FLAGS.input_width,
dataset_name=FLAGS.dataset,
checkpoint_dir=FLAGS.checkpoint_dir,
f_div=FLAGS.f_div,
prior=FLAGS.prior,
lr_decay=FLAGS.lr_decay,
min_lr=FLAGS.min_lr,
model_type=FLAGS.model_type,
log_dir=FLAGS.log_dir,
alpha=FLAGS.alpha,
batch_norm_adaptive=FLAGS.batch_norm_adaptive,
init_type=FLAGS.init_type,
reg=FLAGS.reg,
n_critic=FLAGS.n_critic,
hidden_layers=FLAGS.hidden_layers,
no_of_layers=FLAGS.no_of_layers,
like_reg=FLAGS.like_reg,
df_dim=FLAGS.df_dim)
dcdcdcgan = DCDCDCGAN(sess,
dcDcgan=dcgan,
input_width=FLAGS2.input_width2,
input_height=FLAGS2.input_height2,
output_width=FLAGS2.output_width2,
output_height=FLAGS2.output_height2,
batch_size=FLAGS2.batch_size2,
sample_num=FLAGS2.batch_size2,
y_dim=10,
z_dim=FLAGS2.z_dim2,
dataset_name=FLAGS2.dataset2,
input_fname_pattern=FLAGS2.input_fname_pattern2,
crop=FLAGS2.crop2,
checkpoint_dir=FLAGS2.checkpoint_dir2,
sample_dir=FLAGS2.sample_dir2,
data_dir=FLAGS2.data_dir2,
out_dir=FLAGS2.out_dir2,
max_to_keep=FLAGS2.max_to_keep2)
'''
dcdcdcgan = DCDCDCGAN(
sess,
input_width=FLAGS.input_width,
input_height=FLAGS.input_height,
batch_size=FLAGS.batch_size,
sample_num=FLAGS.batch_size,
c_dim=FLAGS.c_dim,
z_dim=FLAGS.c_dim * FLAGS.input_height * FLAGS.input_width,
dataset_name=FLAGS.dataset,
checkpoint_dir=FLAGS.checkpoint_dir,
f_div=FLAGS.f_div,
prior=FLAGS.prior,
lr_decay=FLAGS.lr_decay,
min_lr=FLAGS.min_lr,
model_type=FLAGS.model_type,
log_dir=FLAGS.log_dir,
alpha=FLAGS.alpha,
batch_norm_adaptive=FLAGS.batch_norm_adaptive,
init_type=FLAGS.init_type,
reg=FLAGS.reg,
n_critic=FLAGS.n_critic,
hidden_layers=FLAGS.hidden_layers,
no_of_layers=FLAGS.no_of_layers,
like_reg=FLAGS.like_reg,
df_dim=FLAGS.df_dim)
'''
#dcgan.train(FLAGS)
dcgan.train(FLAGS)
#print('asdfasf OK asdfasdf')
#print('asdfasf OK asdfasdf')
#print('asdfasf OK asdfasdf')
#print('asdfasf OK asdfasdf')
#print('')
#dcdcdcgan.train(FLAGS2)
#dcdcdcgan.train(FLAGS2)
#print('asdfasdfdfasf OK OK OK asdfsdfsaasdf')
#print('asdfasdfdfasf OK OK OK asdfsdfsaasdf')
#print('asdfasdfdfasf OK OK OK asdfsdfsaasdf')
#print('asdfasdfdfasf OK OK OK asdfsdfsaasdf')
#print('asdfasdasdfasfdfasf This is OK. asdadsfasfsdfsaasdf')
#print('asdfasdasdfasfdfasf This is OK. asdadsfasfsdfsaasdf')
#print('asdfasdasdfasfdfasf This is OK. asdadsfasfsdfsaasdf')
#print('asdfasdasdfasfdfasf This is OK. asdadsfasfsdfsaasdf')
print('')
#test_nlli = self.evaluate_neg_loglikelihood(test_data, config)
#test_nlli = self.evaluate_neg_loglikelihood(test_data, config)
#test_nlli = self.evaluate_neg_loglikelihood(test_data, config)
import dataset_loaders.mnist_loader as mnist_data
#data_X, val_data, test_data, train_dist = mnist_data.load_mnist()
train_data, val_data, test_data, train_dist = mnist_data.load_mnist()
#data_X, val_data, test_data, train_dist = mnist_data.load_mnist()
test_data = np.reshape(test_data, (-1, dcgan.image_size))
#data_X, val_data, test_data, train_dist = mnist_data.load_mnist()
#test_nlli = dcgan.evaluate_neg_loglikelihood(test_data, FLAGS)
#val_nlli = self.evaluate_neg_loglikelihood(val_data, config)
#val_nlli=self.evaluate_neg_loglikelihood(val_data, config)
#val_nlli=self.evaluate_neg_loglikelihood(val_data, config)
#val_nlli = self.evaluate_neg_loglikelihood(val_data, config)
#val_nlli = self.evaluate_neg_loglikelihood(val_data, config)
#print('')
#print('asdfaassdfassdasdfasfdfasf OK. This is OK. OK. asdadsfsasfssafasddfsaasdf')
#print('asdfaassdfassdasdfasfdfasf OK. This is OK. OK. asdadsfsasfssafasddfsaasdf')
#print('asdfaassdfassdasdfasfdfasf OK. This is OK. OK. asdadsfsasfssafasddfsaasdf')
#print('asdfaassdfassdasdfasfdfasf OK. This is OK. OK. asdadsfsasfssafasddfsaasdf')
#print(test_nlli)
#print(test_nlli)
#print('')
#print(test_nlli)
val_data = np.reshape(val_data, (-1, dcgan.image_size))
#val_nlli = dcgan.evaluate_neg_loglikelihood(val_data, FLAGS)
train_data = np.reshape(train_data, (-1, dcgan.image_size))
#train_nlli = dcgan.evaluate_neg_loglikelihood(train_data, FLAGS)
#print(val_nlli)
#print(train_nlli)
#print(val_nlli)
#print(val_nlli)
#print(train_nlli)
#print(train_nlli)
#print(train_nlli)
print('')
# test_data is (10000, 784)
# the size is now (10000, 784)
#nlli_test = sess.run([dcgan.log_likelihood],
# feed_dict={dcgan.log_like_batch: test_data})
#nlli_test = sess.run([dcgan.log_likelihood],
# feed_dict={dcgan.log_like_batch: test_data[0,:].repeat(64, 1)})
# torch.cat([input]*100)
# use: torch.cat([input]*100)
# np.tile(a,(3,1))
# use: np.tile(a,(3,1))
# test_data[0, :]
# use: test_data[0, :]
nlli_test = sess.run([dcgan.log_likelihood],
feed_dict={
dcgan.log_like_batch:
np.tile(test_data[0, :],
(FLAGS.batch_size, 1))
})
nlli_val = sess.run([dcgan.log_likelihood],
feed_dict={
dcgan.log_like_batch:
np.tile(val_data[0, :], (FLAGS.batch_size, 1))
})
nlli_train = sess.run([dcgan.log_likelihood],
feed_dict={
dcgan.log_like_batch:
np.tile(train_data[0, :],
(FLAGS.batch_size, 1))
})
#train_nlli = dcgan.evaluate_neg_loglikelihood(train_data, FLAGS)
#train_nlli = dcgan.evaluate_neg_loglikelihood(train_data, FLAGS)
#train_nlli = dcgan.evaluate_neg_loglikelihood(train_data, FLAGS)
nlli_test = np.squeeze(nlli_test)
nlli_val = np.squeeze(nlli_val)
nlli_train = np.squeeze(nlli_train)
print(nlli_test)
print(nlli_val)
print(nlli_train)
#test_nlli = dcgan.evaluate_neg_loglikelihood(test_data[0, :], FLAGS)
#test_nlli = dcgan.evaluate_neg_loglikelihood(test_data[0, :].repeat(FLAGS.batch_size, 1), FLAGS)
#test_nlli = dcgan.evaluate_neg_loglikelihood(test_data[0, :].repeat(FLAGS.batch_size, 1), FLAGS)
test_nlli = dcgan.evaluate_neg_loglikelihood(
np.tile(test_data[0, :], (FLAGS.batch_size, 1)), FLAGS)
val_nlli = dcgan.evaluate_neg_loglikelihood(
np.tile(val_data[0, :], (FLAGS.batch_size, 1)), FLAGS)
train_nlli = dcgan.evaluate_neg_loglikelihood(
np.tile(train_data[0, :], (FLAGS.batch_size, 1)), FLAGS)
#val_nlli = dcgan.evaluate_neg_loglikelihood(val_data[0, :].repeat(FLAGS.batch_size, 1), FLAGS)
#train_nlli = dcgan.evaluate_neg_loglikelihood(train_data[0, :].repeat(FLAGS.batch_size, 1), FLAGS)
#print(test_nlli)
#print(test_nlli)
print('')
print(test_nlli)
print(val_nlli)
print(train_nlli)
#print(val_nlli)
#print(val_nlli)
#print(train_nlli)
#print(train_nlli)
#print(train_nlli)
#print(train_nlli)
#print(train_nlli)
#adsfadsf
#dsfasf
#adsfas
#print('')
#print('')
print('')
#print('')
#print('asdfaasdfsssasdfasdfassdasdfasfdfasf OK. This is OK. OK. asdfaasdfsssasdfasdfassdasdfasfdfasf')
#print('asdfaassasdfasdfassdasdfasfdfasf OK. This is OK. OK. asdadsfsasfsasdfsfssafasddfsaasdf')
#print('asdfaasdfsssasdfasdfassdasdfasfdfasf OK. This is OK. OK. asdfaasdfsssasdfasdfassdasdfasfdfasf')
#print('')
#print('asdfaasdfsssasdfasdfassdasdfasfdfasf OK. This is OK. OK. asdfaasdfsssasdfasdfassdasdfasfdfasf')
#print('asdfaasdfsssasdfasdfassdasdfasfdfasf OK. This is OK. OK. asdfaasdfsssasdfasdfassdasdfasfdfasf')
#print('asdfaasdfsssasdfasdfassdasdfasfdfasf OK. This is OK. OK. asdfaasdfsssasdfasdfassdasdfasfdfasf')
#print('asdfaassasdfasdfassdasdfasfdfasf OK. This is OK. OK. asdadsfsasfsasdfsfssafasddfsaasdf')
#print('asdfaassasdfasdfassdasdfasfdfasf OK. This is OK. OK. asdadsfsasfsasdfsfssafasddfsaasdf')
# evaluate_neg_loglikelihood(self, data, config)
# use: evaluate_neg_loglikelihood(self, data, config)
#train_nlli = dcgan.evaluate_neg_loglikelihood(np.tile(train_data[0, :], (FLAGS.batch_size, 1)), FLAGS)
#train_nlli = dcgan.evaluate_neg_loglikelihood(np.tile(train_data[0, :], (FLAGS.batch_size, 1)), FLAGS)
#dcdcdcgan.train(FLAGS2)
#dcdcdcgan.train(FLAGS2, dcgan, FLAGS)
#dcdcdcgan.train(FLAGS2, dcgan, FLAGS)
dcdcdcgan.train(FLAGS2)
