text stringlengths 1 93.6k |
|---|
synthesis_dir = os.path.join(output_dir, 'sr_results')
|
log_dir = os.path.join(output_dir, 'log')
|
lr_size = cube_len // scale
|
obs = tf.placeholder(tf.float32, [None, cube_len, cube_len, cube_len, 1], name='obs_data')
|
syn = tf.placeholder(tf.float32, [None, cube_len, cube_len, cube_len, 1], name='syn_data')
|
low_res = tf.placeholder(tf.float32, [None, lr_size, lr_size, lr_size, 1], name='low_res')
|
down_syn = downsample(obs, scale)
|
up_syn = upsample(low_res, scale)
|
obs_res = descriptor(obs, reuse=False)
|
syn_res = descriptor(syn, reuse=True)
|
sr_res = obs + syn - avg_pool(syn, scale)
|
recon_err = tf.square(tf.reduce_mean(syn, axis=0) - tf.reduce_mean(obs, axis=0))
|
des_loss = tf.subtract(tf.reduce_mean(syn_res, axis=0), tf.reduce_mean(obs_res, axis=0))
|
dLdI = tf.gradients(syn_res, syn)[0]
|
syn_langevin = langevin_dynamics(syn)
|
train_data = data_io.getObj(FLAGS.data_path, FLAGS.category, cube_len=cube_len, num_voxels=FLAGS.train_size)
|
num_voxels = len(train_data)
|
train_data = train_data[..., np.newaxis]
|
if not os.path.exists(output_dir):
|
os.makedirs(output_dir)
|
data_io.saveVoxelsToMat(train_data, "%s/observed_data.mat" % output_dir, cmin=0, cmax=1)
|
num_batches = int(math.ceil(num_voxels / batch_size))
|
# descriptor variables
|
des_vars = [var for var in tf.trainable_variables() if var.name.startswith('des')]
|
des_optim = tf.train.AdamOptimizer(FLAGS.d_lr, beta1=FLAGS.beta1)
|
des_grads_vars = des_optim.compute_gradients(des_loss, var_list=des_vars)
|
des_grads = [tf.reduce_mean(tf.abs(grad)) for (grad, var) in des_grads_vars if '/w' in var.name]
|
apply_d_grads = des_optim.apply_gradients(des_grads_vars)
|
saver = tf.train.Saver(max_to_keep=50)
|
with tf.Session() as sess:
|
# initialize training
|
sess.run(tf.global_variables_initializer())
|
print('Generating low resolution data')
|
up_samples = np.zeros(train_data.shape)
|
down_samples = np.zeros(shape=[num_voxels, lr_size, lr_size, lr_size, 1])
|
for i in range(num_batches):
|
indices = slice(i * batch_size, min(num_voxels, (i + 1) * batch_size))
|
obs_data = train_data[indices]
|
ds = sess.run(down_syn, feed_dict={obs: obs_data})
|
us = sess.run(up_syn, feed_dict={low_res: ds})
|
down_samples[indices] = ds
|
up_samples[indices] = us
|
data_io.saveVoxelsToMat(down_samples, "%s/down_sample.mat" % output_dir, cmin=0, cmax=1)
|
data_io.saveVoxelsToMat(up_samples, "%s/up_sample.mat" % output_dir, cmin=0, cmax=1)
|
voxel_mean = train_data.mean()
|
train_data = train_data - voxel_mean
|
up_samples = up_samples - voxel_mean
|
print('start training')
|
sample_voxels = np.random.randn(num_voxels, cube_len, cube_len, cube_len, 1)
|
des_loss_epoch = []
|
recon_err_epoch = []
|
plt.ion()
|
for epoch in range(FLAGS.num_epochs):
|
des_loss_vec = []
|
recon_err_vec = []
|
start_time = time.time()
|
for i in range(num_batches):
|
indices = slice(i * batch_size, min(num_voxels, (i + 1) * batch_size))
|
obs_data = train_data[indices]
|
us_data = up_samples[indices]
|
sr = sess.run(syn_langevin, feed_dict={syn: us_data})
|
# learn D net
|
d_loss = sess.run([des_loss, apply_d_grads], feed_dict={obs: obs_data, syn: sr})[0]
|
# Compute MSE
|
mse = sess.run(recon_err, feed_dict={obs: obs_data, syn: sr})
|
recon_err_vec.append(mse)
|
des_loss_vec.append(d_loss)
|
sample_voxels[indices] = sr
|
end_time = time.time()
|
des_loss_mean, recon_err_mean = float(np.mean(des_loss_vec)), float(np.mean(recon_err_vec))
|
des_loss_epoch.append(des_loss_mean)
|
recon_err_epoch.append(recon_err_mean)
|
print('Epoch #%d, descriptor loss: %.4f, avg MSE: %4.4f, time:%.2fs'
|
% (epoch, des_loss_mean, recon_err_mean, end_time-start_time))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.