def testBaselineGradients(self):
loss = self.op.extra.baseline_loss
grad_baseline = tf.gradients(loss, self.baseline_values)[0]
self.assertEqual(grad_baseline.get_shape(), tf.TensorShape([2, 1]))
self.assertAllEqual(tf.gradients(loss, self.policy_logits), [None])
self.assertAllEqual(tf.gradients(loss, self.invalid_grad_inputs),
self.invalid_grad_outputs)
def testTotalLossGradients(self, is_multi_actions):
with self.test_session() as sess:
if is_multi_actions:
total_loss = tf.reduce_sum(self.multi_op.loss)
policy_logits_nest = self.multi_policy_logits
else:
total_loss = tf.reduce_sum(self.op.loss)
policy_logits_nest = self.policy_logits
grad_policy_list = [
tf.gradients(total_loss, policy_logits)[0]
for policy_logits in nest.flatten(policy_logits_nest)]
grad_baseline = tf.gradients(total_loss, self.baseline_values)[0]
for grad_policy in grad_policy_list:
self.assertEqual(grad_policy.get_shape(), tf.TensorShape([2, 1, 3]))
# These values were just generated once and hard-coded here to check for
# regressions. Calculating by hand would be too time-consuming,
# error-prone and unreadable.
self.assertAllClose(sess.run(grad_policy),
[[[-0.5995, 0.1224, 0.4770]],
[[0.0288, -0.0576, 0.0288]]],
atol=1e-4)
self.assertEqual(grad_baseline.get_shape(), tf.TensorShape([2, 1]))
self.assertAllClose(sess.run(grad_baseline), [[-0.1083], [-0.0420]],
atol=1e-4)
self.assertAllEqual(tf.gradients(total_loss, self.invalid_grad_inputs),
self.invalid_grad_outputs)
def leapfrogs(self, z, T, friction, step_size, x):
v_0 = tf.random_normal((self.n_particles, self.batch_size, self.n_z), 0, 1, dtype=tf.float32)
log_p = self._log_likelihood(x, self._generator_network(z, self.network_weights['decoder_weights'], self.network_weights['decoder_biases'])) + self._log_p_z(z)
grad = -tf.gradients(log_p, [z])[0]
v = v_0 - ((.5*step_size) * grad)
z = z + (step_size * v)
for t in range(T-1):
log_p = self._log_likelihood(x, self._generator_network(z, self.network_weights['decoder_weights'], self.network_weights['decoder_biases'])) + self._log_p_z(z)
grad = -tf.gradients(log_p, [z])[0]
v = v - (step_size * grad)
z = z + (step_size * v)
v = friction * v
log_p = self._log_likelihood(x, self._generator_network(z, self.network_weights['decoder_weights'], self.network_weights['decoder_biases'])) + self._log_p_z(z)
grad = -tf.gradients(log_p, [z])[0]
v = v - ((.5*step_size) * grad)
return z, v_0, v
def get_dynamic_rebar_gradient(self):
"""Get the dynamic rebar gradient (t, eta optimized)."""
tiled_pre_temperature = tf.tile([self.pre_temperature_variable],
[self.batch_size])
temperature = tf.exp(tiled_pre_temperature)
hardELBO, nvil_gradient, logQHard = self._create_hard_elbo()
if self.hparams.quadratic:
gumbel_cv, extra = self._create_gumbel_control_variate_quadratic(logQHard, temperature=temperature)
else:
gumbel_cv, extra = self._create_gumbel_control_variate(logQHard, temperature=temperature)
f_grads = self.optimizer_class.compute_gradients(tf.reduce_mean(-nvil_gradient))
eta = {}
h_grads, eta_statistics = self.multiply_by_eta_per_layer(
self.optimizer_class.compute_gradients(tf.reduce_mean(gumbel_cv)),
eta)
model_grads = U.add_grads_and_vars(f_grads, h_grads)
total_grads = model_grads
# Construct the variance objective
g = U.vectorize(model_grads, set_none_to_zero=True)
self.maintain_ema_ops.append(self.ema.apply([g]))
gbar = 0 #tf.stop_gradient(self.ema.average(g))
variance_objective = tf.reduce_mean(tf.square(g - gbar))
reinf_g_t = 0
if self.hparams.quadratic:
for layer in xrange(self.hparams.n_layer):
gumbel_learning_signal, _ = extra[layer]
df_dt = tf.gradients(gumbel_learning_signal, tiled_pre_temperature)[0]
reinf_g_t_i, _ = self.multiply_by_eta_per_layer(
self.optimizer_class.compute_gradients(tf.reduce_mean(tf.stop_gradient(df_dt) * logQHard[layer])),
eta)
reinf_g_t += U.vectorize(reinf_g_t_i, set_none_to_zero=True)
reparam = tf.add_n([reparam_i for _, reparam_i in extra])
else:
gumbel_learning_signal, reparam = extra
df_dt = tf.gradients(gumbel_learning_signal, tiled_pre_temperature)[0]
reinf_g_t, _ = self.multiply_by_eta_per_layer(
self.optimizer_class.compute_gradients(tf.reduce_mean(tf.stop_gradient(df_dt) * tf.add_n(logQHard))),
eta)
reinf_g_t = U.vectorize(reinf_g_t, set_none_to_zero=True)
reparam_g, _ = self.multiply_by_eta_per_layer(
self.optimizer_class.compute_gradients(tf.reduce_mean(reparam)),
eta)
reparam_g = U.vectorize(reparam_g, set_none_to_zero=True)
reparam_g_t = tf.gradients(tf.reduce_mean(2*tf.stop_gradient(g - gbar)*reparam_g), self.pre_temperature_variable)[0]
variance_objective_grad = tf.reduce_mean(2*(g - gbar)*reinf_g_t) + reparam_g_t
debug = { 'ELBO': hardELBO,
'etas': eta_statistics,
'variance_objective': variance_objective,
}
return total_grads, debug, variance_objective, variance_objective_grad
def leapfrog_step(x0,
v0,
log_posterior,
step_size,
num_steps):
# Start by updating the velocity a half-step
v = v0 - 0.5 * step_size * tf.gradients(log_posterior(x0), x0)[0]
# Initalize x to be the first step
x = x0 + step_size * v
for i in xrange(num_steps):
# Compute gradient of the log-posterior with respect to x
gradient = tf.gradients(log_posterior(x), x)[0]
# Update velocity
v = v - step_size * gradient
# Update x
x = x + step_size * v
# Do a final update of the velocity for a half step
v = v - 0.5 * step_size * tf.gradients(log_posterior(x), x)[0]
# return new proposal state
return x, v
def testNanFromGradsDontPropagate(self):
"""Test that update with NaN gradients does not cause NaN in results."""
def _nan_log_prob_with_nan_gradient(x):
return np.nan * tf.reduce_sum(x)
initial_x = tf.linspace(0.01, 5, 10)
hmc = tfp.mcmc.HamiltonianMonteCarlo(
target_log_prob_fn=_nan_log_prob_with_nan_gradient,
step_size=2.,
num_leapfrog_steps=5,
seed=_set_seed(47))
updated_x, kernel_results = hmc.one_step(
current_state=initial_x,
previous_kernel_results=hmc.bootstrap_results(initial_x))
initial_x_, updated_x_, log_accept_ratio_ = self.evaluate(
[initial_x, updated_x, kernel_results.log_accept_ratio])
acceptance_probs = np.exp(np.minimum(log_accept_ratio_, 0.))
tf.logging.vlog(1, 'initial_x = {}'.format(initial_x_))
tf.logging.vlog(1, 'updated_x = {}'.format(updated_x_))
tf.logging.vlog(1, 'log_accept_ratio = {}'.format(log_accept_ratio_))
self.assertAllEqual(initial_x_, updated_x_)
self.assertEqual(acceptance_probs, 0.)
self.assertAllFinite(
self.evaluate(tf.gradients(updated_x, initial_x)[0]))
self.assertAllEqual(
[True],
[g is None for g in tf.gradients(
kernel_results.proposed_results.grads_target_log_prob,
initial_x)])
def testLSTMBasicToBlockPeeping(self):
with self.test_session(use_gpu=self._use_gpu) as sess:
batch_size = 2
input_size = 3
cell_size = 4
sequence_length = 5
inputs = []
for _ in range(sequence_length):
inp = tf.convert_to_tensor(
np.random.randn(batch_size, input_size),
dtype=tf.float32)
inputs.append(inp)
initializer = tf.random_uniform_initializer(-0.01, 0.01, seed=19890212)
with tf.variable_scope("basic", initializer=initializer):
cell = tf.nn.rnn_cell.LSTMCell(cell_size,
use_peepholes=True,
state_is_tuple=True)
outputs, _ = tf.nn.rnn(cell, inputs, dtype=tf.float32)
sess.run([tf.initialize_all_variables()])
basic_outputs = sess.run(outputs)
basic_grads = sess.run(tf.gradients(outputs, inputs))
basic_wgrads = sess.run(tf.gradients(outputs, tf.trainable_variables()))
with tf.variable_scope("block", initializer=initializer):
w = tf.get_variable("w",
shape=[input_size + cell_size, cell_size * 4],
dtype=tf.float32)
b = tf.get_variable("b",
shape=[cell_size * 4],
dtype=tf.float32,
initializer=tf.zeros_initializer)
wci = tf.get_variable("wci", shape=[cell_size], dtype=tf.float32)
wcf = tf.get_variable("wcf", shape=[cell_size], dtype=tf.float32)
wco = tf.get_variable("wco", shape=[cell_size], dtype=tf.float32)
_, _, _, _, _, _, outputs = fused_lstm(
tf.convert_to_tensor(sequence_length,
dtype=tf.int64),
inputs,
w,
b,
wci=wci,
wcf=wcf,
wco=wco,
cell_clip=0,
use_peephole=True)
sess.run([tf.initialize_all_variables()])
block_outputs = sess.run(outputs)
block_grads = sess.run(tf.gradients(outputs, inputs))
block_wgrads = sess.run(tf.gradients(outputs, [w, b, wci, wcf, wco]))
self.assertAllClose(basic_outputs, block_outputs)
self.assertAllClose(basic_grads, block_grads)
for basic, block in zip(basic_wgrads, block_wgrads):
self.assertAllClose(basic, block, rtol=1e-2, atol=1e-2)
def test_grads_at_sample_pts_with_yes_preserve_gradients(self):
dist = tfp.distributions.Normal(np.float64(0), np.float64(1))
x = dist.sample(10001, seed=0)
# 50th quantile will lie exactly on a data point.
# 49.123... will not
q = tf.constant(np.array([50, 49.123456789])) # Percentiles, in [0, 100]
analytic_pct = dist.quantile(q / 100.) # divide by 10 to make quantile.
sample_pct = tfp.stats.percentile(
x, q, interpolation='linear', preserve_gradients=True)
analytic_pct, d_analytic_pct_dq, sample_pct, d_sample_pct_dq = (
self.evaluate([
analytic_pct,
tf.gradients(analytic_pct, q)[0],
sample_pct,
tf.gradients(sample_pct, q)[0],
]))
self.assertAllClose(analytic_pct, sample_pct, atol=0.05)
# Near the median, the normal PDF is approximately constant C, with
# C = 1 / sqrt(2 * pi). So the cdf is approximately F(x) = x / C.
# Thus the quantile function is approximately F^{-1}(y) = C * y.
self.assertAllClose(np.sqrt(2 * np.pi) / 100 * np.ones([2]),
d_analytic_pct_dq, atol=1e-4)
# At the 50th percentile exactly, the sample gradient not exactly zero!
# This is due to preserve_gradient == True.
self.assertNotEqual(0., d_sample_pct_dq[0])
# Tolerance is terrible (2x), but this is a sample quantile based gradient.
self.assertAllClose(d_analytic_pct_dq, d_sample_pct_dq, atol=0, rtol=2)
# The absolute values are close though (but tiny).
self.assertAllClose(d_analytic_pct_dq, d_sample_pct_dq, atol=0.1, rtol=0)
def testCustomGetter(self):
custom_getter = snt.custom_getters.Context(snt.custom_getters.stop_gradient)
module = snt.nets.ConvNet2D(output_channels=self.output_channels,
kernel_shapes=self.kernel_shapes,
rates=self.rates,
strides=self.strides,
paddings=self.paddings,
custom_getter=custom_getter)
input_shape = [10, 100, 100, 3]
input_to_net = tf.random_normal(dtype=tf.float32, shape=input_shape)
if tf.executing_eagerly():
with tf.GradientTape() as tape0:
out0 = module(input_to_net)
with tf.GradientTape() as tape1:
with custom_getter:
out1 = module(input_to_net)
all_vars = tf.trainable_variables()
out0_grads = tape0.gradient(out0, all_vars)
out1_grads = tape1.gradient(out1, all_vars)
else:
out0 = module(input_to_net)
with custom_getter:
out1 = module(input_to_net)
all_vars = tf.trainable_variables()
out0_grads = tf.gradients(out0, all_vars)
out1_grads = tf.gradients(out1, all_vars)
for grad in out0_grads:
self.assertNotEqual(None, grad)
self.assertEqual([None] * len(out1_grads), out1_grads)
def test_second_order(self):
with self.test_session() as sess:
x = Normal(0.0, 1.0)
y = 2 * (x ** 2)
z = tf.gradients(y, x)[0]
z = tf.gradients(z, x)[0]
self.assertEqual(z.eval(), 4.0)
def testGradQtm1(self):
with self.test_session() as sess:
gradients = tf.gradients([-self.qlearning.loss], [self.q_tm1])
gradients_reference = tf.gradients([-self.qlearning_reference.loss],
[self.q_tm1])
self.assertAllClose(sess.run(gradients[0]),
sess.run(gradients_reference[0]))
def testReduction(self):
g = tf.Graph()
# BN0 is computing batch normed matrix along rows.
def BN0(x):
mean = tf.reduce_mean(x, [0])
var = tf.reduce_mean(tf.square(x - mean)) # biased var
rstd = tf.rsqrt(var + 1e-8)
return (x - mean) * rstd
# Wraps BatchNorm in a tf function.
@function.Defun(tf.float32)
def BN1(x):
return BN0(x)
with g.as_default():
x = tf.placeholder(tf.float32)
y0 = BN0(x) # A plain graph
y1 = BN1(x) # A tf function
dx0, = tf.gradients([y0], [x])
dx1, = tf.gradients([y1], [x])
# Both should produce the same result and gradient.
with self.test_session(graph=g) as sess:
vals = sess.run([y0, y1, dx0, dx1], {x: np.random.uniform(size=(3, 7))})
self.assertAllClose(vals[0], vals[1])
self.assertAllClose(vals[2], vals[3])
def _build_solvers(self, json_data):
actor_stepsize = 0.001 if (
self.ACTOR_STEPSIZE_KEY not in json_data) else json_data[self.ACTOR_STEPSIZE_KEY]
actor_momentum = 0.9 if (
self.ACTOR_MOMENTUM_KEY not in json_data) else json_data[self.ACTOR_MOMENTUM_KEY]
critic_stepsize = 0.01 if (
self.CRITIC_STEPSIZE_KEY not in json_data) else json_data[self.CRITIC_STEPSIZE_KEY]
critic_momentum = 0.9 if (
self.CRITIC_MOMENTUM_KEY not in json_data) else json_data[self.CRITIC_MOMENTUM_KEY]
critic_vars = self._tf_vars('main/critic')
critic_opt = tf.train.MomentumOptimizer(learning_rate=critic_stepsize,
momentum=critic_momentum)
self.critic_grad_tf = tf.gradients(self.critic_loss_tf, critic_vars)
self.critic_solver = MPISolver(self.sess, critic_opt, critic_vars)
self._actor_stepsize_tf = tf.get_variable(dtype=tf.float32,
name='actor_stepsize',
initializer=actor_stepsize,
trainable=False)
self._actor_stepsize_ph = tf.get_variable(dtype=tf.float32, name='actor_stepsize_ph', shape=[])
self._actor_stepsize_update_op = self._actor_stepsize_tf.assign(self._actor_stepsize_ph)
actor_vars = self._tf_vars('main/actor')
actor_opt = tf.train.MomentumOptimizer(learning_rate=self._actor_stepsize_tf,
momentum=actor_momentum)
self.actor_grad_tf = tf.gradients(self.actor_loss_tf, actor_vars)
self.actor_solver = MPISolver(self.sess, actor_opt, actor_vars)
return
def _testTensorArrayGradientWriteReadType(self, use_gpu, dtype):
with self.test_session(use_gpu=use_gpu) as sess:
h = data_flow_ops.TensorArray(
dtype=tf.as_dtype(dtype), tensor_array_name="foo", size=3)
c = lambda x: np.array(x, dtype=dtype)
value_0 = tf.constant(c([[4.0, 5.0]]))
value_1 = tf.constant(c(3.0))
w0 = h.write(0, value_0)
w1 = w0.write(1, value_1)
r0 = w1.read(0)
r1 = w1.read(1)
# Test individual components' gradients
grad_just_r0 = tf.gradients(
ys=[r0], xs=[value_0], grad_ys=[c([[2.0, 3.0]])])
grad_just_r0_vals = sess.run(grad_just_r0)
self.assertAllEqual(c([[2.0, 3.0]]), grad_just_r0_vals[0])
grad_just_r1 = tf.gradients(
ys=[r1], xs=[value_1], grad_ys=[c(-2.0)])
grad_just_r1_vals = sess.run(grad_just_r1)
self.assertAllEqual(c(-2.0), grad_just_r1_vals[0])
# Test combined gradients
grad = tf.gradients(
ys=[r0, r1], xs=[value_0, value_1],
grad_ys=[c(-1.0), c([[2.0, 3.0]])])
grad_vals = sess.run(grad)
self.assertEqual(len(grad_vals), 2)
self.assertAllClose(c(-1.0), grad_vals[0])
self.assertAllEqual(c([[2.0, 3.0]]), grad_vals[1])
def test_state_grads(sess):
v = tf.Variable([0., 0., 0.])
x = tf.ones((3,))
y0 = tf.assign(v, x)
y1 = tf.assign_add(v, x)
grad0 = tf.gradients(y0, [v, x])
grad1 = tf.gradients(y1, [v, x])
grad_vals = sess.run((grad0, grad1))
assert np.allclose(grad_vals[0][0], 0)
assert np.allclose(grad_vals[0][1], 1)
assert np.allclose(grad_vals[1][0], 1)
assert np.allclose(grad_vals[1][1], 1)
v = tf.Variable([0., 0., 0.])
x = tf.ones((1,))
y0 = tf.scatter_update(v, [0], x)
y1 = tf.scatter_add(v, [0], x)
grad0 = tf.gradients(y0, [v._ref(), x])
grad1 = tf.gradients(y1, [v._ref(), x])
grad_vals = sess.run((grad0, grad1))
assert np.allclose(grad_vals[0][0], [0, 1, 1])
assert np.allclose(grad_vals[0][1], 1)
assert np.allclose(grad_vals[1][0], 1)
assert np.allclose(grad_vals[1][1], 1)
def create_gen_train_op(hparams, learning_rate, gen_loss, global_step, mode):
"""Create Generator train op."""
del hparams
with tf.name_scope('train_generator'):
if FLAGS.generator_optimizer == 'sgd':
gen_optimizer = tf.train.GradientDescentOptimizer(learning_rate)
elif FLAGS.generator_optimizer == 'adam':
gen_optimizer = tf.train.AdamOptimizer(learning_rate)
else:
raise NotImplementedError
gen_vars = [
v for v in tf.trainable_variables() if v.op.name.startswith('gen')
]
print('Optimizing Generator vars.')
for v in gen_vars:
print(v)
if mode == 'MINIMIZE':
gen_grads = tf.gradients(gen_loss, gen_vars)
elif mode == 'MAXIMIZE':
gen_grads = tf.gradients(-gen_loss, gen_vars)
else:
raise ValueError("Must be one of 'MINIMIZE' or 'MAXIMIZE'")
gen_grads_clipped, _ = tf.clip_by_global_norm(gen_grads,
FLAGS.grad_clipping)
gen_train_op = gen_optimizer.apply_gradients(
zip(gen_grads_clipped, gen_vars), global_step=global_step)
return gen_train_op, gen_grads_clipped, gen_vars
def testEntropyGradient(self):
with self.cached_session() as sess:
logits = tf.constant([[1., 2., 3.], [2., 5., 1.]])
probabilities = tf.nn.softmax(logits)
log_probabilities = tf.nn.log_softmax(logits)
true_entropy = - tf.reduce_sum(
probabilities * log_probabilities, axis=-1)
categorical_distribution = categorical.Categorical(probs=probabilities)
categorical_entropy = categorical_distribution.entropy()
# works
true_entropy_g = tf.gradients(true_entropy, [logits])
categorical_entropy_g = tf.gradients(
categorical_entropy, [logits])
res = sess.run({"true_entropy": true_entropy,
"categorical_entropy": categorical_entropy,
"true_entropy_g": true_entropy_g,
"categorical_entropy_g": categorical_entropy_g})
self.assertAllClose(res["true_entropy"],
res["categorical_entropy"])
self.assertAllClose(res["true_entropy_g"],
res["categorical_entropy_g"])
def build_loss_and_gradients(self, var_list):
x_true = list(six.itervalues(self.data))[0]
x_fake = list(six.iterkeys(self.data))[0]
with tf.variable_scope("Disc"):
d_true = self.discriminator(x_true)
with tf.variable_scope("Disc", reuse=True):
d_fake = self.discriminator(x_fake)
if self.logging:
tf.summary.histogram("discriminator_outputs",
tf.concat([d_true, d_fake], axis=0),
collections=[self._summary_key])
loss_d = tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.ones_like(d_true), logits=d_true) + \
tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.zeros_like(d_fake), logits=d_fake)
loss = tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.ones_like(d_fake), logits=d_fake)
loss_d = tf.reduce_mean(loss_d)
loss = tf.reduce_mean(loss)
var_list_d = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope="Disc")
if var_list is None:
var_list = [v for v in tf.trainable_variables() if v not in var_list_d]
grads_d = tf.gradients(loss_d, var_list_d)
grads = tf.gradients(loss, var_list)
grads_and_vars_d = list(zip(grads_d, var_list_d))
grads_and_vars = list(zip(grads, var_list))
return loss, grads_and_vars, loss_d, grads_and_vars_d
def main():
x_data = np.asarray([2])
t_data = np.asarray([3])
W = tf.constant([3.0])
y = W * x_data
z = y * t_data
# Before starting, initialize the variables. We will 'run' this first.
init = tf.initialize_all_variables()
# Launch the graph.
sess = tf.Session()
sess.run(init)
print sess.run(y)
print sess.run(z)
gd1 = tf.gradients(y, W)
print sess.run(gd1)
gd2 = tf.gradients(z, y, gd1)
print sess.run(gd2)
gd = tf.gradients(z, W)
print sess.run(gd)
return
def generate_system(self, eqs):
resolve = lambda eq: eval(eq, self.env) if type(eq) is str else eq
self.eqn_exp = {nm: resolve(eq) for (nm, eq) in eqs.items()}
# equations system
self.eqn_vec = tf.concat(list(self.eqn_exp.values()), 0)
self.eqn_spec = {nm: int(eq.get_shape()[0]) for (nm, eq) in self.eqn_exp.items()}
self.eqn_sz = sum(self.eqn_spec.values())
# find gradients
n_eqns = self.eqn_vec.get_shape()[0]
eqn_list = tf.split(self.eqn_vec, n_eqns)
self.par_jac = tf.stack([tf.gradients(eqn, self.par_vec)[0] for eqn in eqn_list])
self.var_jac = tf.stack([tf.gradients(eqn, self.var_vec)[0] for eqn in eqn_list])
# create functions
def state_evaler(f, matrix=False):
def ev(p, v):
y = f.eval({self.par_vec: p, self.var_vec: v})
return ensure_matrix(y) if matrix else y
return ev
self.eqn_fun = state_evaler(self.eqn_vec)
self.parjac_fun = state_evaler(self.par_jac, matrix=True)
self.varjac_fun = state_evaler(self.var_jac, matrix=True)
def rothk_penalty(self, d_real, d_fake):
config = self.config
g_sample = self.gan.uniform_sample
x = self.gan.inputs.x
gradx = tf.gradients(d_real, [x])[0]
gradg = tf.gradients(d_fake, [g_sample])[0]
gradx = tf.reshape(gradx, [self.ops.shape(gradx)[0], -1])
gradg = tf.reshape(gradg, [self.ops.shape(gradg)[0], -1])
gradx_norm = tf.norm(gradx, axis=1, keep_dims=True)
gradg_norm = tf.norm(gradg, axis=1, keep_dims=True)
if int(gradx_norm.get_shape()[0]) != int(d_real.get_shape()[0]):
print("Condensing along batch for rothk")
gradx_norm = tf.reduce_mean(gradx_norm, axis=0)
gradg_norm = tf.reduce_mean(gradg_norm, axis=0)
gradx = tf.square(gradx_norm) * tf.square(1-tf.nn.sigmoid(d_real))
gradg = tf.square(gradg_norm) * tf.square(tf.nn.sigmoid(d_fake))
loss = gradx + gradg
loss *= config.rothk_lambda or 1
if config.rothk_decay:
decay_function = config.decay_function or tf.train.exponential_decay
decay_steps = config.decay_steps or 50000
decay_rate = config.decay_rate or 0.9
decay_staircase = config.decay_staircase or False
global_step = tf.train.get_global_step()
loss = decay_function(loss, global_step, decay_steps, decay_rate, decay_staircase)
return loss
def central_step():
# restore v1, slots
op5 = tf.group(*[ tf.assign(w,v) for w,v in zip(restored_vars, tmp_vars)])
with tf.get_default_graph().control_dependencies([op5]):
back = tf.group(*[tf.assign_sub(v, -self._lr_t*grad) for grad,v in grads_and_vars])
with tf.get_default_graph().control_dependencies([back]):
return tf.gradients(self.gan.trainer.d_loss, d_vars) + tf.gradients(self.gan.trainer.g_loss, g_vars)
def config(self,
loss,
train_batch_size,
learning_rate = 0.5,
momentum = 0.9,
permute = False,
ecrit = 0.01,
test_func = None,
wrange = None):
self._loss = loss(self.model['labels'], self.model['network'][-1].act)
self._opt = tf.train.MomentumOptimizer(learning_rate, momentum)
self.settings['loss_func'] = loss
self.settings['batch_size'] = train_batch_size
self.settings['lrate'] = learning_rate
self.settings['mrate'] = momentum
self.settings['permute'] = permute
self.settings['ecrit'] = ecrit
self.settings['test_func'] = test_func
self.settings['opt_task'] = self._opt.minimize(self._loss, global_step=self._global_step)
self.settings['saver'] = tf.train.Saver(max_to_keep = 0)
for l in self.model['network']:
# When run in current session tf.gradients returns a list of numpy arrays with
# batch_size number of rows and Layer.size number of columns.
if wrange is not None:
with self.sess.as_default():
l.assign_weights(wrange)
l.ded_net = tf.gradients(self._loss, l.net)
l.ded_act = tf.gradients(self._loss, l.act)
l.ded_W = tf.gradients(self._loss, l.W)
l.ded_b = tf.gradients(self._loss, l.b)
init = init_rest()
self.sess.run(init)
def build_model(self):
self.x = tf.placeholder(tf.float32, [self.reader.vocab_size], name="input")
self.x_idx = tf.placeholder(tf.int32, [None], name='x_idx') # mask paddings
self.build_encoder()
self.build_generator()
self.objective = self.kl +self.recons_loss
# optimizer for alternative update
optimizer1 = tf.train.AdamOptimizer(learning_rate=self.learning_rate)
optimizer2 = tf.train.AdamOptimizer(learning_rate=0.1)
fullvars = tf.GraphKeys.TRAINABLE_VARIABLES
print 'fullvars:',fullvars
enc_vars = tf.get_collection(fullvars,scope='encoder')
print enc_vars
dec_vars = tf.get_collection(fullvars,scope='generator')
print dec_vars
self.lossL2_enc = tf.add_n([ tf.nn.l2_loss(v) for v in enc_vars if 'bias' not in v.name]) * 0.0001
self.lossL2_dec = tf.add_n([ tf.nn.l2_loss(v) for v in dec_vars if 'bias' not in v.name])
print 'lossL2_enc:',self.lossL2_enc
print 'lossL2_dec:',self.lossL2_dec
enc_grads = tf.gradients(self.kl+self.lossL2_enc, enc_vars)
dec_grads = tf.gradients(self.recons_loss+self.lossL2_dec, dec_vars)
self.optim_enc = optimizer1.apply_gradients(zip(enc_grads, enc_vars))
self.optim_dec = optimizer2.apply_gradients(zip(dec_grads, dec_vars))
def apply_gradients(self, grads_and_vars, global_step=None, name=None):
var_list = [ v for _,v in grads_and_vars]
d_vars = []
g_vars = []
all_grads = [ g for g, _ in grads_and_vars ]
for grad,var in grads_and_vars:
if var in self.gan.d_vars():
d_vars += [var]
elif var in self.gan.g_vars():
g_vars += [var]
else:
raise("Couldn't find var in g_vars or d_vars")
with ops.init_scope():
self.optimizer._create_slots([v for g,v in grads_and_vars])
self._prepare()
d_grads = all_grads[:len(d_vars)]
if self.config.type == 'sga':
Jgrads = tf.gradients(d_grads, d_vars, grad_ys=d_grads, stop_gradients=d_vars) + [tf.zeros_like(g) for g in g_vars]
elif self.config.type == 'magnitude':
consensus_reg = [tf.square(g) for g in d_grads if g is not None]
Jgrads = tf.gradients(consensus_reg, d_vars) + [tf.zeros_like(g) for g in g_vars]
else:
consensus_reg = 0.5 * sum(
tf.reduce_sum(tf.square(g)) for g in d_grads if g is not None
)
Jgrads = tf.gradients(consensus_reg, d_vars, stop_gradients=d_vars) + [tf.zeros_like(g) for g in g_vars]
new_grads = [g+jg*self._beta if jg is not None else g for g,v,jg in zip(all_grads, var_list, Jgrads)]
new_grads_and_vars = list(zip(new_grads, var_list)).copy()
return self.optimizer.apply_gradients(new_grads_and_vars, global_step=global_step, name=name)
def test_gradient(self):
"""
Test the correctness of the gradient against tensorflow
"""
if ovl.cuda_enabled:
devices = ['/cpu:0', '/gpu:0']
else:
devices = ['/cpu:0']
# ensure TF runs on GPU when asked
test_config=tf.ConfigProto(allow_soft_placement=False)
test_config.graph_options.optimizer_options.opt_level = -1
with tf.Session(config=test_config) as sess:
for dev_string in devices:
with tf.device(dev_string):
a = np.random.random(100)
grad_input = tf.constant(np.random.random(100))
arg = tf.constant(a)
ovl_op = log1p(arg)
ones = tf.constant(np.ones_like(a))
ovl_out = ovl.as_tensorflow(ovl_op)
tf_out = tf.log(arg + ones)
ovl_grad = tf.gradients(ovl_out, arg, grad_input)[0]
tf_grad = tf.gradients(tf_out, arg, grad_input)[0]
ovl_out, tf_out, ovl_grad, tf_grad = sess.run([ovl_out, tf_out, ovl_grad, tf_grad])
assert np.allclose(ovl_out, tf_out)
assert np.allclose(ovl_grad, tf_grad)
sess.close()
def testDerivativeOfBlockGRUToGRUCellMultiSteps(self):
batch_size = 2
cell_size = 3
input_size = 4
time_steps = 2
with self.test_session(use_gpu=self._use_gpu, graph=tf.Graph()) as sess:
# Random initializers.
seed = 1994
initializer = tf.random_uniform_initializer(-0.01, 0.01, seed=seed)
np.random.seed(seed)
# Inputs
concat_x = tf.placeholder(tf.float32, shape=(time_steps, batch_size, input_size))
h = tf.zeros([batch_size, cell_size])
# Values for the inputs.
x_values = np.random.rand(time_steps, batch_size, input_size)
h_value = np.random.rand(batch_size, cell_size)
feeds = {concat_x: x_values, h: h_value}
# Gradients from the block GRU cell implementation.
with tf.variable_scope("block", initializer=initializer):
cell = gru_ops.GRUBlockCell(cell_size)
outputs_dynamic, _ = tf.nn.dynamic_rnn(
cell, inputs=concat_x, initial_state=h, time_major=True, dtype=tf.float32
)
grad_output_wrt_x = tf.gradients([outputs_dynamic[0]], concat_x)
grad_output_wrt_h = tf.gradients([outputs_dynamic[0]], h)
sess.run([tf.initialize_all_variables()])
block_grad_res_x, block_grad_res_h = sess.run([grad_output_wrt_x, grad_output_wrt_h], feeds)
# Gradients from the basic GRU cell implementation.
with tf.variable_scope("basic", initializer=initializer):
cell = tf.nn.rnn_cell.GRUCell(cell_size)
outputs_dynamic, _ = tf.nn.dynamic_rnn(
cell, inputs=concat_x, initial_state=h, time_major=True, dtype=tf.float32
)
grad_output_wrt_x = tf.gradients([outputs_dynamic[0]], concat_x)
grad_output_wrt_h = tf.gradients([outputs_dynamic[0]], h)
sess.run([tf.initialize_all_variables()])
basic_grad_res_x, basic_grad_res_h = sess.run([grad_output_wrt_x, grad_output_wrt_h], feeds)
# Check derivatives values of the outputs wrt to x.
self.assertEqual(len(block_grad_res_x), len(basic_grad_res_x))
# Check derivatives values of the outputs wrt to h.
for block, basic in zip(block_grad_res_x, basic_grad_res_x):
self.assertAllClose(block, basic)
# Check derivatives values of the outputs wrt to x.
self.assertEqual(len(block_grad_res_h), len(basic_grad_res_h))
# Check derivatives values of the outputs wrt to h.
for block, basic in zip(block_grad_res_h, basic_grad_res_h):
self.assertAllClose(block, basic)
def testA(self):
with self.test_context():
mu = tf.placeholder(settings.float_type)
var = tf.placeholder(settings.float_type)
Y = tf.placeholder(tf.int32)
lik = gpflow.likelihoods.MultiClass(3)
ve = lik.variational_expectations(mu, var, Y)
tf.gradients(tf.reduce_sum(ve), mu)
def __init__(self, sess, state, action, learning_rate, tau):
self.sess = sess
self.state_dim = len(state)
self.action_dim = len(action)
self.rate = learning_rate
self.tau = tau
# create critic network
train_network = self.create_network('critic_train')
self.inputs = train_network[0]
self.actions = train_network[1]
self.q_outputs = train_network[2]
self.state_outputs = train_network[3]
self.train_net = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=train_network[4]
)
# create target critic network
target_network = self.create_network('critic_target')
self.target_inputs = target_network[0]
self.target_actions = target_network[1]
self.target_q_outputs = target_network[2]
self.target_state_outputs = target_network[3]
self.target_net = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=target_network[4]
)
# op for updating target network with train network weights
self.update = [self.target_net[i].assign(
tf.mul(self.train_net[i], self.tau) +
tf.mul(self.target_net[i], 1. - self.tau)
)
for i in range(len(self.target_net))]
# define loss and optimization op
self.state_prime = tf.placeholder(fl32, [None, self.state_dim])
self.batch_state_loss = \
tf.squared_difference(self.s_prime, self.state_outputs)
self.state_loss = tf.reduce_mean(self.batch_state_loss)
self.y = tf.placeholder(fl32, [None, 1])
self.batch_q_loss = tf.squared_difference(self.y, self.q_outputs)
self.q_loss = tf.reduce_mean(self.batch_loss)
self.train_q = \
tf.train.AdamOptimizer(self.rate).minimize(self.q_loss)
self.train_state = \
tf.train.AdamOptimizer(self.rate).minimize(self.state_loss)
# get the gradient of the train net with respect to actions
self.policy_gradient = tf.gradients(self.q_outputs, self.actions)
self.explore_gradient = tf.gradients(self.state_loss, self.actions)
# print total number of parameters (neurons)
vars = self.train_net
print sum([sum([reduce(
lambda x, y: x * y, l.get_shape().as_list()) for l in e])
for e in [vars]])
def __init__(self, scope, globalAC=None):
self.scope = scope
if scope == GLOBAL_NET_SCOPE:
## global network only do inference
with tf.variable_scope(scope):
self.s = tf.placeholder(tf.float32, [None, N_S], 'S')
self._build_net()
self.a_params = tl.layers.get_variables_with_name(scope + '/actor', True, False)
self.c_params = tl.layers.get_variables_with_name(scope + '/critic', True, False)
normal_dist = tf.contrib.distributions.Normal(self.mu, self.sigma) # for continuous action space
with tf.name_scope('choose_a'): # use local params to choose action
self.A = tf.clip_by_value(tf.squeeze(normal_dist.sample(1), axis=0), *A_BOUND)
else:
## worker network calculate gradient locally, update on global network
with tf.variable_scope(scope):
self.s = tf.placeholder(tf.float32, [None, N_S], 'S')
self.a_his = tf.placeholder(tf.float32, [None, N_A], 'A')
self.v_target = tf.placeholder(tf.float32, [None, 1], 'Vtarget')
self._build_net()
td = tf.subtract(self.v_target, self.v, name='TD_error')
with tf.name_scope('c_loss'):
self.c_loss = tf.reduce_mean(tf.square(td))
with tf.name_scope('wrap_a_out'):
self.test = self.sigma[0]
self.mu, self.sigma = self.mu * A_BOUND[1], self.sigma + 1e-5
normal_dist = tf.contrib.distributions.Normal(self.mu, self.sigma) # for continuous action space
with tf.name_scope('a_loss'):
log_prob = normal_dist.log_prob(self.a_his)
exp_v = log_prob * td
entropy = normal_dist.entropy() # encourage exploration
self.exp_v = ENTROPY_BETA * entropy + exp_v
self.a_loss = tf.reduce_mean(-self.exp_v)
with tf.name_scope('choose_a'): # use local params to choose action
self.A = tf.clip_by_value(tf.squeeze(normal_dist.sample(1), axis=0), *A_BOUND)
with tf.name_scope('local_grad'):
self.a_params = tl.layers.get_variables_with_name(scope + '/actor', True, False)
self.c_params = tl.layers.get_variables_with_name(scope + '/critic', True, False)
self.a_grads = tf.gradients(self.a_loss, self.a_params)
self.c_grads = tf.gradients(self.c_loss, self.c_params)
with tf.name_scope('sync'):
with tf.name_scope('pull'):
self.pull_a_params_op = [l_p.assign(g_p) for l_p, g_p in zip(self.a_params, globalAC.a_params)]
self.pull_c_params_op = [l_p.assign(g_p) for l_p, g_p in zip(self.c_params, globalAC.c_params)]
with tf.name_scope('push'):
self.update_a_op = OPT_A.apply_gradients(zip(self.a_grads, globalAC.a_params))
self.update_c_op = OPT_C.apply_gradients(zip(self.c_grads, globalAC.c_params))
def test_vgg():
"""Loads the VGG network and applies it to a test image.
"""
with tf.Session() as sess:
net = get_vgg_model()
tf.import_graph_def(net['graph_def'], name='vgg')
g = tf.get_default_graph()
names = [op.name for op in g.get_operations()]
input_name = names[0] + ':0'
x = g.get_tensor_by_name(input_name)
softmax = g.get_tensor_by_name(names[-2] + ':0')
og = plt.imread('aimotive_car.png')
img = preprocess(og)[np.newaxis, ...]
res = np.squeeze(softmax.eval(feed_dict={
x: img,
'vgg/dropout_1/random_uniform:0': [[1.0]],
'vgg/dropout/random_uniform:0': [[1.0]]}))
print([(res[idx], net['labels'][idx])
for idx in res.argsort()[-5:][::-1]])
"""Let's visualize the network's gradient activation
when backpropagated to the original input image. This
is effectively telling us which pixels contribute to the
predicted class or given neuron"""
features = [name for name in names if 'BiasAdd' in name.split()[-1]]
from math import sqrt, ceil
n_plots = ceil(sqrt(len(features) + 1))
fig, axs = plt.subplots(n_plots, n_plots)
plot_i = 0
axs[0][0].imshow(img[0])
for feature_i, featurename in enumerate(features):
plot_i += 1
feature = g.get_tensor_by_name(featurename + ':0')
neuron = tf.reduce_max(feature, 1)
saliency = tf.gradients(tf.reduce_sum(neuron), x)
neuron_idx = tf.arg_max(feature, 1)
this_res = sess.run([saliency[0], neuron_idx], feed_dict={
x: img,
'vgg/dropout_1/random_uniform:0': [[1.0]],
'vgg/dropout/random_uniform:0': [[1.0]]})
grad = this_res[0][0] / np.max(np.abs(this_res[0]))
ax = axs[plot_i // n_plots][plot_i % n_plots]
ax.imshow((grad * 127.5 + 127.5).astype(np.uint8))
ax.set_title(featurename)
"""Deep Dreaming takes the backpropagated gradient activations
and simply adds it to the image, running the same process again
and again in a loop. There are many tricks one can add to this
idea, such as infinitely zooming into the image by cropping and
scaling, adding jitter by randomly moving the image around, or
adding constraints on the total activations."""
og = plt.imread('street.png')
crop = 2
img = preprocess(og)[np.newaxis, ...]
layer = g.get_tensor_by_name(features[3] + ':0')
n_els = layer.get_shape().as_list()[1]
neuron_i = np.random.randint(1000)
layer_vec = np.zeros((1, n_els))
layer_vec[0, neuron_i] = 1
neuron = tf.reduce_max(layer, 1)
saliency = tf.gradients(tf.reduce_sum(neuron), x)
for it_i in range(3):
print(it_i)
this_res = sess.run(saliency[0], feed_dict={
x: img,
layer: layer_vec,
'vgg/dropout_1/random_uniform:0': [[1.0]],
'vgg/dropout/random_uniform:0': [[1.0]]})
grad = this_res[0] / np.mean(np.abs(grad))
img = img[:, crop:-crop - 1, crop:-crop - 1, :]
img = imresize(img[0], (224, 224))[np.newaxis]
img += grad
plt.imshow(deprocess(img[0]))
def buildActorNetwork(self,d=128,dv=16,dout=128,nv=8):
init_w = tf.random_normal_initializer(0., 0.01)
init_b = tf.constant_initializer(0.01)
with tf.variable_scope('update_Actor_network' + self.name):
# enc
f_dim = 128
encode_layer1 = tf.layers.Dense(512, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='encoder_l1',
trainable=True)
encode_layer2 = tf.layers.Dense(f_dim, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='encoder_l2',
trainable=True)
for i in range(self.agent_num):
e1 = encode_layer1(self.state_holder[:, i * self.state_dim:(i + 1) * self.state_dim])
feature = encode_layer2(e1)
if i == 0:
self.feature_a = feature
else:
self.feature_a = tf.concat([self.feature_a, feature], axis=1)
self.feature_a = tf.reshape(self.feature_a, [-1, f_dim, self.agent_num]) ##gai
# relation1
d = d
dv = dv
dout = dout
nv = nv
r1_l1_v = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l1_v',
trainable=True)
r1_l1_q = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l1_q',
trainable=True)
r1_l1_k = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l1_k',
trainable=True)
r1_out = tf.layers.Dense(dout, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l1_k',
trainable=True)
for i in range(self.agent_num):
v1 = tf.matmul(self.feature_a, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
q1 = tf.matmul(self.feature_a, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
k1 = tf.matmul(self.feature_a, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
v1 = tf.transpose(v1, [0, 2, 1])
q1 = tf.transpose(q1, [0, 2, 1])
k1 = tf.transpose(k1, [0, 2, 1])
v2 = r1_l1_v(v1)
q2 = r1_l1_q(q1)
k2 = r1_l1_k(k1)
v = tf.reshape(v2, shape=[-1, self.neighbors, nv, dv])
q = tf.reshape(q2, shape=[-1, self.neighbors, nv, dv])
k = tf.reshape(k2, shape=[-1, self.neighbors, nv, dv])
v = tf.transpose(v, [0, 2, 1, 3])
k = tf.transpose(k, [0, 2, 3, 1])
q = tf.transpose(q, [0, 2, 1, 3])
att = tf.matmul(q, k) / np.sqrt(dv)
att = tf.nn.softmax(att, axis=-1)
out = tf.matmul(att, v)
out = tf.transpose(out, [0, 2, 1, 3])
out = tf.reshape(out, shape=[-1, self.neighbors, dv * nv])
T = tf.matmul(self.vecholder, out)
out = r1_out(T)
if i == 0:
self.relation_1_a = out
else:
self.relation_1_a = tf.concat([self.relation_1_a, out], axis=1)
self.relation_1_a = tf.reshape(self.relation_1_a, [-1, dv * nv, self.agent_num]) ##gai
# relation 2
r2_l1_v = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l2_v',
trainable=True)
r2_l1_q = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l2_q',
trainable=True)
r2_l1_k = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l2_k',
trainable=True)
r2_out = tf.layers.Dense(dout, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l2_k',
trainable=True)
for i in range(self.agent_num):
v1 = tf.matmul(self.relation_1_a, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
q1 = tf.matmul(self.relation_1_a, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
k1 = tf.matmul(self.relation_1_a, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
v1 = tf.transpose(v1, [0, 2, 1])
q1 = tf.transpose(q1, [0, 2, 1])
k1 = tf.transpose(k1, [0, 2, 1])
v2 = r2_l1_v(v1)
q2 = r2_l1_q(q1)
k2 = r2_l1_k(k1)
v = tf.reshape(v2, shape=[-1, self.neighbors, nv, dv])
q = tf.reshape(q2, shape=[-1, self.neighbors, nv, dv])
k = tf.reshape(k2, shape=[-1, self.neighbors, nv, dv])
v = tf.transpose(v, [0, 2, 1, 3])
k = tf.transpose(k, [0, 2, 3, 1])
q = tf.transpose(q, [0, 2, 1, 3])
att = tf.matmul(q, k) / np.sqrt(dv)
att = tf.nn.softmax(att, axis=-1)
out = tf.matmul(att, v)
out = tf.transpose(out, [0, 2, 1, 3])
out = tf.reshape(out, shape=[-1, self.neighbors, dv * nv])
T = tf.matmul(self.vecholder, out)
out = r2_out(T)
if i == 0:
self.relation_2_a = out
else:
self.relation_2_a = tf.concat([self.relation_2_a, out], axis=1)
self.action_mean = tf.layers.Dense(1, activation=None,
kernel_initializer=init_w, bias_initializer=init_b, name='mean',
trainable=True)
self.action_sigma = tf.layers.Dense(1, activation=None,
kernel_initializer=init_w, bias_initializer=init_b, name='sigma',
trainable=True)
self.pi = []
self.action = []
for i in range(self.agent_num):
h = tf.concat([self.feature_a[:, :, i], self.relation_1_a[:, i, :],
self.relation_2_a[:, i, :]], axis=1)
dis = tf.distributions.Normal(loc=self.action_mean(h), scale=self.action_sigma(h))
self.pi.append(dis)
self.action.append(tf.squeeze(dis.sample([1])))
with tf.variable_scope('target_Actor_network' + self.name):
# enc
f_dim = 128
encode_layer1 = tf.layers.Dense(512, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='encoder_l1',
trainable=True)
encode_layer2 = tf.layers.Dense(f_dim, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='encoder_l2',
trainable=True)
for i in range(self.agent_num):
e1 = encode_layer1(self.state_holder[:, i * self.state_dim:(i + 1) * self.state_dim])
feature = encode_layer2(e1)
if i == 0:
self.feature_a_old = feature
else:
self.feature_a_old = tf.concat([self.feature_a_old, feature], axis=1)
self.feature_a_old = tf.reshape(self.feature_a_old, [-1, 128, self.agent_num]) ##gai
# relation1
d = 128
dv = 16
dout = 128
nv = 8
r1_l1_v = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l1_v',
trainable=True)
r1_l1_q = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l1_q',
trainable=True)
r1_l1_k = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l1_k',
trainable=True)
r1_out = tf.layers.Dense(dout, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l1_k',
trainable=True)
for i in range(self.agent_num):
v1 = tf.matmul(self.feature_a_old, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
q1 = tf.matmul(self.feature_a_old, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
k1 = tf.matmul(self.feature_a_old, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
v1 = tf.transpose(v1, [0, 2, 1])
q1 = tf.transpose(q1, [0, 2, 1])
k1 = tf.transpose(k1, [0, 2, 1])
v2 = r1_l1_v(v1)
q2 = r1_l1_q(q1)
k2 = r1_l1_k(k1)
v = tf.reshape(v2, shape=[-1, self.neighbors, nv, dv])
q = tf.reshape(q2, shape=[-1, self.neighbors, nv, dv])
k = tf.reshape(k2, shape=[-1, self.neighbors, nv, dv])
v = tf.transpose(v, [0, 2, 1, 3])
k = tf.transpose(k, [0, 2, 3, 1])
q = tf.transpose(q, [0, 2, 1, 3])
att = tf.matmul(q, k) / np.sqrt(dv)
att = tf.nn.softmax(att, axis=-1)
out = tf.matmul(att, v)
out = tf.transpose(out, [0, 2, 1, 3])
out = tf.reshape(out, shape=[-1, self.neighbors, dv * nv])
T = tf.matmul(self.vecholder, out)
out = r1_out(T)
if i == 0:
self.relation_1_a_old = out
else:
self.relation_1_a_old = tf.concat([self.relation_1_a_old, out], axis=1)
self.relation_1_a_old = tf.reshape(self.relation_1_a_old, [-1, dv * nv, self.agent_num]) ##
# relation 2
r2_l1_v = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l2_v',
trainable=True)
r2_l1_q = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l2_q',
trainable=True)
r2_l1_k = tf.layers.Dense(dv * nv, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l2_k',
trainable=True)
r2_out = tf.layers.Dense(dout, activation=tf.nn.relu,
kernel_initializer=init_w, bias_initializer=init_b, name='relation_l2_k',
trainable=True)
for i in range(self.agent_num):
v1 = tf.matmul(self.relation_1_a_old, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
q1 = tf.matmul(self.relation_1_a_old, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
k1 = tf.matmul(self.relation_1_a_old, tf.transpose(self.adj[:, i, :, :], [0, 2, 1]))
v1 = tf.transpose(v1, [0, 2, 1])
q1 = tf.transpose(q1, [0, 2, 1])
k1 = tf.transpose(k1, [0, 2, 1])
v2 = r2_l1_v(v1)
q2 = r2_l1_q(q1)
k2 = r2_l1_k(k1)
v = tf.reshape(v2, shape=[-1, self.neighbors, nv, dv])
q = tf.reshape(q2, shape=[-1, self.neighbors, nv, dv])
k = tf.reshape(k2, shape=[-1, self.neighbors, nv, dv])
v = tf.transpose(v, [0, 2, 1, 3])
k = tf.transpose(k, [0, 2, 3, 1])
q = tf.transpose(q, [0, 2, 1, 3])
att = tf.matmul(q, k) / np.sqrt(dv)
att = tf.nn.softmax(att, axis=-1)
out = tf.matmul(att, v)
out = tf.transpose(out, [0, 2, 1, 3])
out = tf.reshape(out, shape=[-1, self.neighbors, dv * nv])
T = tf.matmul(self.vecholder, out)
out = r2_out(T)
if i == 0:
self.relation_2_a_old = out
else:
self.relation_2_a_old = tf.concat([self.relation_2_a_old, out], axis=1)
self.action_mean_old = tf.layers.Dense(1, activation=None,
kernel_initializer=init_w, bias_initializer=init_b, name='mean_old',
trainable=False)
self.action_sigma_old = tf.layers.Dense(1, activation=None,
kernel_initializer=init_w, bias_initializer=init_b, name='sigma_old',
trainable=False)
self.pi_old = []
self.action_old = []
for i in range(self.agent_num):
h = tf.concat([self.feature_a_old[:, :, i], self.relation_1_a_old[:, i, :],
self.relation_2_a_old[:, i, :]], axis=1)
dis = tf.distributions.Normal(loc=self.action_mean_old(h), scale=self.action_sigma_old(h))
self.pi_old.append(dis)
self.action_old.append(tf.squeeze(dis.sample([1])))
self.p_e_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='update_Actor_network' + self.name)
self.p_t_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='target_Actor_network' + self.name)
# train setting modify the loss!!!
self.p_trainOp = []
for i in range(self.agent_num):
ratio = tf.exp(
tf.reshape(self.pi[i].log_prob(self.action_holder[:, i]), [-1, 1]) - tf.reshape(
tf.clip_by_value(self.pi_old[i].log_prob(self.action_holder[:, i]),
-20, 20), [-1, 1]))
self.surrogate = ratio * self.advantage[:, i]
self.clip_surrogate = tf.clip_by_value(ratio, 1. - self.epsilon_holder,
1 + self.epsilon_holder) * self.advantage[:, i]
self.p_loss = -tf.reduce_mean(tf.minimum(self.surrogate, self.clip_surrogate))
grads, _ = tf.clip_by_global_norm(tf.gradients(self.p_loss, self.p_e_params), 5.)
grads_and_vars = list(zip(grads, self.p_e_params))
self.p_trainOp.append(
tf.train.AdamOptimizer(learning_rate=0.0001).apply_gradients(grads_and_vars, name="apply_gradients"))
self.Actor_network_update = [tf.assign(tar, eva) for tar, eva in zip(self.p_t_params, self.p_e_params)]
def __init__(self,
session,
action_size,
width,
height,
states_size,
optimizer=tf.train.AdamOptimizer(1e-4),
eta=0.5,
beta=0.01):
self.layers = {}
self.action_size = action_size
self.optimizer = optimizer
self.session = session
self.width = width
self.height = height
self.states_size = states_size
# beta is the entropy strength regularization term, a bigger entropy means higher emphasis on exploration
self.beta = beta
# eta regularizes the value to give more emphasis on the action taken, rather than the current states
self.eta = eta
with tf.device('/cpu:0'):
with tf.variable_scope('network'):
self.action = tf.placeholder('int32', [None], name='action')
self.target_value = tf.placeholder('float32', [None],
name='target_value')
self.state, self.policy, self.value = self.build_model(
self.width, self.height, self.states_size)
self.weights = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope='network')
self.advantages = tf.placeholder('float32', [None],
name='advantages')
with tf.variable_scope('optimizer'):
# Compute the one hot vectors for each action given.
action_one_hot = tf.one_hot(self.action, self.action_size, 1.0,
0.0)
# There are some issues when taking the log of the policy when it is exactly 1 or 0
min_policy = 1e-8
max_policy = 1 - min_policy
# log policy is the expected log probability of arriving in the current states
self.log_policy = tf.log(
tf.clip_by_value(self.policy, min_policy, max_policy))
# log pi for action is the expected log probability of arriving in the current states given the
# action taken
self.log_pi_for_action = tf.reduce_sum(tf.multiply(
self.log_policy, action_one_hot),
axis=1)
# We want to perform gradient ascent to maximize the discounted rewards, tf automatically tries to
# reduce the loss, therefore we feed it the negative log policy multiplied by the estimate of the
# advantage given by taking the current action in the current states
self.policy_loss = -tf.reduce_mean(
self.log_pi_for_action * self.advantages)
# The value loss is just the squared deference between the current states's value and the desired value
self.value_loss = tf.reduce_mean(
tf.square(self.target_value - self.value))
# The entropy improves exploration by discouraging premature convergence to suboptimal deterministic
# policies, in other words, to penalize a small entropy ( which means that the probability distribution
# is concentrated in one action ) we subtract the entropy from the loss
self.entropy = tf.reduce_sum(
tf.multiply(self.policy, -self.log_policy))
# We try to minimize the loss such that the best actions are chosen more often
self.loss = self.eta * self.value_loss + self.policy_loss - self.entropy * self.beta
# Create a list of tuples of gradients and their respective weights
grads = tf.gradients(self.loss, self.weights)
# clip by global norm reduces the chances of gradients exploding
grads, _ = tf.clip_by_global_norm(grads, 40.0)
grads_vars = list(zip(grads, self.weights))
# Create an operator to apply the gradients using the optimizer.
self.train_op = optimizer.apply_gradients(grads_vars)
def main(_):
"""
The core of the model consists of an LSTM cell that processes one word at
a time and computes probabilities of the possible continuations of the
sentence. The memory state of the network is initialized with a vector
of zeros and gets updated after reading each word. Also, for computational
reasons, we will process data in mini-batches of size batch_size.
"""
if FLAGS.model == "small":
init_scale = 0.1
learning_rate = 1.
max_grad_norm = 5
num_steps = 20
hidden_size = 200
max_epoch = 4
max_max_epoch = 13
keep_prob = 1.0
lr_decay = 0.5
batch_size = 20
vocab_size = 10000
elif FLAGS.model == "medium":
init_scale = 0.05
learning_rate = 1.0
max_grad_norm = 5
# num_layers = 2
num_steps = 35
hidden_size = 650
max_epoch = 6
max_max_epoch = 39
keep_prob = 0.5
lr_decay = 0.8
batch_size = 20
vocab_size = 10000
elif FLAGS.model == "large":
init_scale = 0.04
learning_rate = 1.0
max_grad_norm = 10
# num_layers = 2
num_steps = 35
hidden_size = 1500
max_epoch = 14
max_max_epoch = 55
keep_prob = 0.35
lr_decay = 1 / 1.15
batch_size = 20
vocab_size = 10000
else:
raise ValueError("Invalid model: %s", FLAGS.model)
# Load PTB dataset
train_data, valid_data, test_data, vocab_size = tl.files.load_ptb_dataset()
# train_data = train_data[0:int(100000/5)] # for fast testing
print('len(train_data) {}'.format(len(train_data))) # 929589 a list of int
print('len(valid_data) {}'.format(len(valid_data))) # 73760 a list of int
print('len(test_data) {}'.format(len(test_data))) # 82430 a list of int
print('vocab_size {}'.format(vocab_size)) # 10000
sess = tf.InteractiveSession()
# One int represents one word, the meaning of batch_size here is not the
# same with MNIST example, it is the number of concurrent processes for
# computational reasons.
# Training and Validation
input_data = tf.placeholder(tf.int32, [batch_size, num_steps])
targets = tf.placeholder(tf.int32, [batch_size, num_steps])
# Testing (Evaluation)
input_data_test = tf.placeholder(tf.int32, [1, 1])
targets_test = tf.placeholder(tf.int32, [1, 1])
def inference(x, is_training, num_steps, reuse=None):
"""If reuse is True, the inferences use the existing parameters,
then different inferences share the same parameters.
Note :
- For DynamicRNNLayer, you can set dropout and the number of RNN layer internally.
"""
print("\nnum_steps : %d, is_training : %s, reuse : %s" %
(num_steps, is_training, reuse))
init = tf.random_uniform_initializer(-init_scale, init_scale)
with tf.variable_scope("model", reuse=reuse):
net = tl.layers.EmbeddingInputlayer(x,
vocab_size,
hidden_size,
init,
name='embedding')
net = tl.layers.DropoutLayer(net,
keep=keep_prob,
is_fix=True,
is_train=is_training,
name='drop1')
net = tl.layers.RNNLayer(
net,
cell_fn=tf.contrib.rnn.
BasicLSTMCell, # tf.nn.rnn_cell.BasicLSTMCell,
cell_init_args={
'forget_bias': 0.0,
'state_is_tuple': True
},
n_hidden=hidden_size,
initializer=init,
n_steps=num_steps,
return_last=False,
name='basic_lstm1')
lstm1 = net
net = tl.layers.DropoutLayer(net,
keep=keep_prob,
is_fix=True,
is_train=is_training,
name='drop2')
net = tl.layers.RNNLayer(
net,
cell_fn=tf.contrib.rnn.
BasicLSTMCell, # tf.nn.rnn_cell.BasicLSTMCell,
cell_init_args={
'forget_bias': 0.0,
'state_is_tuple': True
},
n_hidden=hidden_size,
initializer=init,
n_steps=num_steps,
return_last=False,
return_seq_2d=True,
name='basic_lstm2')
lstm2 = net
# Alternatively, if return_seq_2d=False, in the above RNN layer,
# you can reshape the outputs as follow:
# net = tl.layers.ReshapeLayer(net,
# shape=[-1, int(net.outputs._shape[-1])], name='reshape')
net = tl.layers.DropoutLayer(net,
keep=keep_prob,
is_fix=True,
is_train=is_training,
name='drop3')
net = tl.layers.DenseLayer(net,
vocab_size,
W_init=init,
b_init=init,
act=None,
name='output')
return net, lstm1, lstm2
# Inference for Training
net, lstm1, lstm2 = inference(input_data,
is_training=True,
num_steps=num_steps,
reuse=None)
# Inference for Validating
net_val, lstm1_val, lstm2_val = inference(input_data,
is_training=False,
num_steps=num_steps,
reuse=True)
# Inference for Testing (Evaluation)
net_test, lstm1_test, lstm2_test = inference(input_data_test,
is_training=False,
num_steps=1,
reuse=True)
# sess.run(tf.global_variables_initializer())
tl.layers.initialize_global_variables(sess)
def loss_fn(outputs, targets, batch_size):
# See tl.cost.cross_entropy_seq()
# Returns the cost function of Cross-entropy of two sequences, implement
# softmax internally.
# outputs : 2D tensor [batch_size*num_steps, n_units of output layer]
# targets : 2D tensor [batch_size, num_steps], need to be reshaped.
# batch_size : RNN batch_size, number of concurrent processes.
# n_examples = batch_size * num_steps
# so
# cost is the averaged cost of each mini-batch (concurrent process).
loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example(
[outputs], [tf.reshape(targets, [-1])],
[tf.ones_like(tf.reshape(targets, [-1]), dtype=tf.float32)])
# [tf.ones([batch_size * num_steps])])
cost = tf.reduce_sum(loss) / batch_size
return cost
# Cost for Training
cost = loss_fn(net.outputs, targets, batch_size)
# Cost for Validating
cost_val = loss_fn(net_val.outputs, targets, batch_size)
# Cost for Testing (Evaluation)
cost_test = loss_fn(net_test.outputs, targets_test, 1)
# Truncated Backpropagation for training
with tf.variable_scope('learning_rate'):
lr = tf.Variable(0.0, trainable=False)
tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars), max_grad_norm)
optimizer = tf.train.GradientDescentOptimizer(lr)
train_op = optimizer.apply_gradients(zip(grads, tvars))
# sess.run(tf.global_variables_initializer())
tl.layers.initialize_global_variables(sess)
net.print_params()
net.print_layers()
tl.layers.print_all_variables()
print("nStart learning a language model by using PTB dataset")
for i in range(max_max_epoch):
# decreases the initial learning rate after several
# epoachs (defined by ``max_epoch``), by multipling a ``lr_decay``.
new_lr_decay = lr_decay**max(i - max_epoch, 0.0)
sess.run(tf.assign(lr, learning_rate * new_lr_decay))
# Training
print("Epoch: %d/%d Learning rate: %.3f" %
(i + 1, max_max_epoch, sess.run(lr)))
epoch_size = ((len(train_data) // batch_size) - 1) // num_steps
start_time = time.time()
costs = 0.0
iters = 0
# reset all states at the begining of every epoch
state1 = tl.layers.initialize_rnn_state(lstm1.initial_state)
state2 = tl.layers.initialize_rnn_state(lstm2.initial_state)
for step, (x, y) in enumerate(
tl.iterate.ptb_iterator(train_data, batch_size, num_steps)):
feed_dict = {
input_data: x,
targets: y,
lstm1.initial_state.c: state1[0],
lstm1.initial_state.h: state1[1],
lstm2.initial_state.c: state2[0],
lstm2.initial_state.h: state2[1],
}
# For training, enable dropout
feed_dict.update(net.all_drop)
_cost, state1_c, state1_h, state2_c, state2_h, _ = sess.run(
[
cost, lstm1.final_state.c, lstm1.final_state.h,
lstm2.final_state.c, lstm2.final_state.h, train_op
],
feed_dict=feed_dict)
state1 = (state1_c, state1_h)
state2 = (state2_c, state2_h)
costs += _cost
iters += num_steps
if step % (epoch_size // 10) == 10:
print("%.3f perplexity: %.3f speed: %.0f wps" %
(step * 1.0 / epoch_size, np.exp(costs / iters),
iters * batch_size / (time.time() - start_time)))
train_perplexity = np.exp(costs / iters)
print("Epoch: %d/%d Train Perplexity: %.3f" %
(i + 1, max_max_epoch, train_perplexity))
# Validation
start_time = time.time()
costs = 0.0
iters = 0
# reset all states at the begining of every epoch
state1 = tl.layers.initialize_rnn_state(lstm1_val.initial_state)
state2 = tl.layers.initialize_rnn_state(lstm2_val.initial_state)
for step, (x, y) in enumerate(
tl.iterate.ptb_iterator(valid_data, batch_size, num_steps)):
feed_dict = {
input_data: x,
targets: y,
lstm1_val.initial_state.c: state1[0],
lstm1_val.initial_state.h: state1[1],
lstm2_val.initial_state.c: state2[0],
lstm2_val.initial_state.h: state2[1],
}
_cost, state1_c, state1_h, state2_c, state2_h, _ = sess.run(
[
cost_val, lstm1_val.final_state.c, lstm1_val.final_state.h,
lstm2_val.final_state.c, lstm2_val.final_state.h,
tf.no_op()
],
feed_dict=feed_dict)
state1 = (state1_c, state1_h)
state2 = (state2_c, state2_h)
costs += _cost
iters += num_steps
valid_perplexity = np.exp(costs / iters)
print("Epoch: %d/%d Valid Perplexity: %.3f" %
(i + 1, max_max_epoch, valid_perplexity))
print("Evaluation")
# Testing
# go through the test set step by step, it will take a while.
start_time = time.time()
costs = 0.0
iters = 0
# reset all states at the begining
state1 = tl.layers.initialize_rnn_state(lstm1_test.initial_state)
state2 = tl.layers.initialize_rnn_state(lstm2_test.initial_state)
for step, (x, y) in enumerate(
tl.iterate.ptb_iterator(test_data, batch_size=1, num_steps=1)):
feed_dict = {
input_data_test: x,
targets_test: y,
lstm1_test.initial_state.c: state1[0],
lstm1_test.initial_state.h: state1[1],
lstm2_test.initial_state.c: state2[0],
lstm2_test.initial_state.h: state2[1],
}
_cost, state1_c, state1_h, state2_c, state2_h = sess.run(
[
cost_test,
lstm1_test.final_state.c,
lstm1_test.final_state.h,
lstm2_test.final_state.c,
lstm2_test.final_state.h,
],
feed_dict=feed_dict)
state1 = (state1_c, state1_h)
state2 = (state2_c, state2_h)
costs += _cost
iters += 1
test_perplexity = np.exp(costs / iters)
print("Test Perplexity: %.3f took %.2fs" %
(test_perplexity, time.time() - start_time))
print(
"More example: Text generation using Trump's speech data: https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_generate_text.py -- def main_lstm_generate_text():"
)
def train_gan(train_set,
indices: List,
samples_per_N: int,
repetition_n: int,
identifier: str,
experiment_name: str,
batch_size: int = 256,
desired_epochs: int = 2000):
"""
The GAN is trained for 1000 epochs. If a a set of 60k samples is trained with a batchsize of 256,
then a epoch equals 226 iterations. A budget of 100,000 iterations would equals to 426
"""
assert train_set.shape[0] > len(indices)
print(train_set.shape)
print(len(indices))
my_ds = DataSetManager(train_set[indices])
# print("Set number of iterations to train\n")
v5 = (desired_epochs * (train_set[indices].shape[0])) // batch_size + 1
print("ITERS " + str(v5))
print("SIZE " + str(train_set[indices].shape))
# print("Use pretrained model? (0 means No, some number different to 0 means yes)\n")
decision_number = 0 #int( input() )
# print("Type a name to save the model with?\n")
model_tag = str(round(samples_per_N)) + '_' + str(repetition_n)
storing_path = 'data/' + experiment_name + "/" + model_tag + '_data/'
model_path = storing_path + model_tag + '.ckpt'
# Recall that os.mkdir isn't recursive, so it only makes on directoryt at a time
try:
# Create target Directory
os.mkdir(storing_path)
print("Directory ", storing_path, " Created ")
except FileExistsError:
print("Directory ", storing_path, " already exists")
# ===> Auxiliar functions <===
"""
----------------8<-------------[ cut here ]------------------
------------------------------------------------
"""
def save_history(files_prefix, gen_loss_record, disc_loss_record,
jsd_error, current_epoch, epoch_record, my_ds, iter_,
epochs, global_iters):
# Save losses per epoch
df = pd.DataFrame(np.array(gen_loss_record))
with open(files_prefix + '_gen_loss.csv', 'w+') as f:
df.to_csv(f, header=False, index=False)
df = pd.DataFrame(np.array(disc_loss_record))
with open(files_prefix + '_disc_loss.csv', 'w+') as f:
df.to_csv(f, header=False, index=False)
df = pd.DataFrame(np.array(epoch_record))
with open(files_prefix + '_epoch_record.csv', 'w+') as f:
df.to_csv(f, header=False, index=False)
# Save current iter and epochs
df = pd.DataFrame(
np.array([epochs + my_ds.epochs_completed, global_iters + iter_]))
with open(files_prefix + '_training.csv', 'w+') as f:
df.to_csv(f, header=False, index=False)
with open(files_prefix + '_jsd_error.csv', 'a') as csvFile:
writer = csv.writer(csvFile)
writer.writerow([current_epoch, jsd_error])
def send_bot_message(bot, my_ds, iter_, ITERS, identifier):
"""
Not quite straighforward since the critic draws many more samples.
"""
message = "\nEpochs [" + str(
my_ds.epochs_completed) + "] Iter: " + str(iter_) + ";\t" + str(
np.round(100 * iter_ / ITERS, 2)) + "% "
message = message + identifier
print(message)
bot.set_status(message)
# Send update message
if bot.verbose:
bot.send_message(message)
print("\n")
def save_gen_samples(gen_op, disc_op, sess, path, k, n=4):
"""
k: is the number of epochs used to trained the generator
n: is the number of batches to draw samples
"""
suffix = '_gen_samples_' + str(k) + '_epochs_' + '.csv'
for k in range(n):
samples = sess.run(gen_op)
df = pd.DataFrame(np.array(samples))
with open(path + suffix, 'a') as f:
df.to_csv(f, header=False, index=False)
# Score the samples using the critic
scores = sess.run(disc_op)
df = pd.DataFrame(np.array(scores))
with open(path + 'scores_' + suffix, 'a') as f:
df.to_csv(f, header=False, index=False)
# ===> Model Parameters <===
"""
----------------8<-------------[ cut here ]------------------
------------------------------------------------
"""
DIM = 512 # model dimensionality
GEN_DIM = 100 # output dimension of the generator
DIS_DIM = 1 # outptu dimension fo the discriminator
FIXED_GENERATOR = False # wheter to hold the generator fixed at ral data plus Gaussian noise, as in the plots in the paper
LAMBDA = .1 # smaller lambda makes things faster for toy tasks, but isn't necessary if you increase CRITIC_ITERS enough
BATCH_SIZE = batch_size # batch size
ITERS = v5 #100000 # how many generator iterations to train for
FREQ = 250 # sample frequency
CRITIC_ITERS = 5 # homw many critic iteractions per generator iteration
def Generator_Softmax(n_samples, name='gen'):
with tf.variable_scope(name):
noise = tf.random_normal([n_samples, GEN_DIM])
output01 = tf_utils.linear(noise, 2 * DIM, name='fc-1')
output01 = tf_utils.relu(output01, name='relu-1')
output02 = tf_utils.linear(output01, 2 * DIM, name='fc-2')
output02 = tf_utils.relu(output02, name='relu-2')
output03 = tf_utils.linear(output02, 2 * DIM, name='fc-3')
output03 = tf_utils.relu(output03, name='relu-3')
output04 = tf_utils.linear(output03, GEN_DIM, name='fc-4')
# Reminder: a logit can be modeled as a linear function of the predictors
output05 = tf.nn.softmax(output04, name='softmax-1')
return output05
def Discriminator(inputs, is_reuse=True, name='disc'):
with tf.variable_scope(name, reuse=is_reuse):
print('is_reuse: {}'.format(is_reuse))
output01 = tf_utils.linear(inputs, 2 * DIM, name='fc-1')
output01 = tf_utils.relu(output01, name='relu-1')
output02 = tf_utils.linear(output01, 2 * DIM, name='fc-2')
output02 = tf_utils.relu(output02, name='relu-2')
output03 = tf_utils.linear(output02, 2 * DIM, name='fc-3')
output03 = tf_utils.relu(output03, name='relu-3')
output04 = tf_utils.linear(output03, DIS_DIM, name='fc-4')
return output04
real_data = tf.placeholder(tf.float32, shape=[None, GEN_DIM])
fake_data = Generator_Softmax(BATCH_SIZE)
disc_real = Discriminator(real_data, is_reuse=False)
disc_fake = Discriminator(fake_data)
disc_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real)
gen_cost = -tf.reduce_mean(disc_fake)
# WGAN gradient penalty parameters
alpha = tf.random_uniform(shape=[BATCH_SIZE, 1], minval=0., maxval=1.)
interpolates = alpha * real_data + (1. - alpha) * fake_data
disc_interpolates = Discriminator(interpolates)
gradients = tf.gradients(disc_interpolates, [interpolates][0])
slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients),
reduction_indices=[1]))
gradient_penalty = tf.reduce_mean((slopes - 1)**2)
disc_cost += LAMBDA * gradient_penalty
disc_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='disc')
gen_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='gen')
disc_lr = tf.placeholder(tf.float32, shape=()) # 1e-4
gen_lr = tf.placeholder(tf.float32, shape=()) # 1e-4
disc_train_op = tf.train.AdamOptimizer(learning_rate=disc_lr,
beta1=0.5,
beta2=0.9).minimize(
disc_cost, var_list=disc_vars)
if len(gen_vars) > 0:
gen_train_op = tf.train.AdamOptimizer(learning_rate=gen_lr,
beta1=0.5,
beta2=0.9).minimize(
gen_cost, var_list=gen_vars)
else:
gen_train_op = tf.no_op()
"""
----------------8<-------------[ cut here ]------------------
------------------------------------------------
"""
# ===> Model Parameters <===
session_saver = tf.train.Saver()
# files_prefix = 'model/'+ model_tag
if decision_number == 0:
pre_trained = False
gen_loss_record = [] # type: List[float]
disc_loss_record = [] # type: List[float]
epoch_record = [] # type: List[float]
epochs = 0
global_iters = 0
df = pd.DataFrame(np.array(indices))
with open(storing_path + 'training_indices.csv', 'a') as f:
df.to_csv(f, header=False, index=False)
else:
pre_trained = True
print(storing_path)
print(storing_path + 'training_indices.csv')
_indices = (pd.read_csv(storing_path + 'training_indices.csv',
header=None).values).tolist()
print(len(_indices))
print(train_set[indices].shape)
print(train_set[_indices].squeeze().shape)
assert train_set[_indices].squeeze().shape == train_set[indices].shape
my_ds = DataSetManager(train_set[_indices].squeeze())
temp = pd.read_csv(storing_path + '_training.csv', header=None).values
epochs, global_iters = temp.flatten()
my_ds.epochs_completed = epochs
gen_loss_record = (pd.read_csv(storing_path + '_gen_loss.csv',
header=None).values).tolist()
disc_loss_record = (pd.read_csv(storing_path + '_disc_loss.csv',
header=None).values).tolist()
epoch_record = (pd.read_csv(storing_path + '_epoch_record.csv',
header=None).values).tolist()
print("State has been restored")
# Create a DLBot instance
bot = DLBot(token=telegram_token, user_id=telegram_user_id)
# Activate the bot
bot.activate_bot()
print("\nTelegram bot has been activated ")
iters_per_epoch = my_ds.num_examples / BATCH_SIZE
total_iters = int(
np.ceil((desired_epochs * iters_per_epoch) / CRITIC_ITERS))
critic_iters = np.round((5 / 6) * total_iters)
gen_iters = np.round((1 / 6) * total_iters)
ITERS = total_iters
# Train loop
with tf.Session() as sess:
if pre_trained == False: # false by default:
sess.run(tf.global_variables_initializer())
if pre_trained == True:
session_saver.restore(sess, model_path)
#
# DUCK TAPE SOLUTION
iter_ = 0
"""
while my_ds.epochs_completed < desired_epochs:
iter_ +=1
"""
gen_lr_ = CyclicLR(base_lr=10**-4.72,
max_lr=10**-3.72,
step_size=gen_iters)
disc_lr_ = CyclicLR(base_lr=10**-4.72,
max_lr=10**-3.72,
step_size=critic_iters)
for iter_ in range(ITERS):
batch_data, disc_cost_ = None, None
previous_epoch = my_ds.epochs_completed
# train critic
for i_ in range(CRITIC_ITERS):
batch_data = my_ds.next_batch(
BATCH_SIZE) # data_gen.__next__()
disc_cost_, _ = sess.run([disc_cost, disc_train_op],
feed_dict={
real_data: batch_data,
disc_lr: disc_lr_.clr()
})
disc_lr_.on_batch_end()
# train generator
sess.run(gen_train_op, feed_dict={gen_lr: gen_lr_.clr()})
gen_lr_.on_batch_end()
gen_cost2 = sess.run(gen_cost)
current_epoch = my_ds.epochs_completed
condition2 = current_epoch % 5 == 0
if current_epoch > previous_epoch and condition2:
disc_loss_record.append(disc_cost_)
gen_loss_record.append(gen_cost2)
epoch_record.append(my_ds.epochs_completed)
# print("Diff "+str(current_epoch - previous_epoch))
if (np.mod(iter_, FREQ) == 0) or (iter_ + 1 == ITERS):
"""
print("===> Debugging")
print(disc_loss_record)
print(gen_loss_record)
"""
bot.loss_hist.append(disc_cost_)
fake_samples = sess.run(
fake_data) # , feed_dict={real_data: batch_data}
# print("\n==> Sum-Simplex condition: " +str(np.sum(fake_samples, axis=1)))
fake_population = np.array([
sess.run(fake_data) for k in range(40)
]).reshape(40 * 256, 100)
print(fake_population.shape)
jsd_error = gan_error_all_species(fake_population, k3_test_set)
print("JSD Error " + str(jsd_error))
send_bot_message(bot, my_ds, iter_, ITERS, identifier)
current_epoch = my_ds.epochs_completed
session_saver.save(sess, model_path)
save_history(storing_path, gen_loss_record, disc_loss_record,
jsd_error, current_epoch, epoch_record, my_ds,
iter_, epochs, global_iters)
# save_gen_samples(fake_data, disc_fake ,sess, storing_path, k) # fake_data = Generator_Softmax(BATCH_SIZE)
utils.tick() # _iter[0] += 1
if iter_ == ITERS:
session_saver.save(sess, model_path)
# Create gan samples
n_samples = len(indices)
k_iter = n_samples // BATCH_SIZE + 1
gan_samples_path = storing_path + "gan_samples_" + model_tag + '.csv'
for k in range(k_iter):
fake_samples = sess.run(fake_data)
df = pd.DataFrame(fake_samples)
with open(gan_samples_path, 'a') as f:
df.to_csv(f, header=False, index=False)
# Clear variables valuies
tf.reset_default_graph()
current_epoch = my_ds.epochs_completed
save_history(storing_path, gen_loss_record, disc_loss_record, jsd_error,
current_epoch, epoch_record, my_ds, iter_, epochs,
global_iters)
bot.stop_bot()
print("Training is done")
# Duct tapping the size of gan sample set to avoid changing the TF Graph
temp1 = pd.read_csv(gan_samples_path, header=None).values
temp1 = temp1[0:n_samples]
df = pd.DataFrame(temp1)
with open(gan_samples_path, 'w+') as f:
df.to_csv(f, header=False, index=False)
print("Training is done")
def __init__(self, sess, node_input_dim, job_input_dim, hid_dims, output_dim,
max_depth, executor_levels, type_num, exec_mem,exec_num,eps=1e-6, act_fn=leaky_relu,
optimizer=tf.train.AdamOptimizer, scope='actor_agent'): #加了type_num
Agent.__init__(self)
self.sess = sess
self.node_input_dim = node_input_dim
self.job_input_dim = job_input_dim
self.hid_dims = hid_dims
self.output_dim = output_dim
self.max_depth = max_depth
self.executor_levels = executor_levels
self.type_num = type_num
self.exec_mem = exec_mem
self.exec_num = exec_num
self.eps = eps
self.act_fn = act_fn
self.optimizer = optimizer
self.scope = scope
# for computing and storing message passing path
self.postman = Postman()
# node input dimension: [total_num_nodes, num_features]
self.node_inputs = tf.placeholder(tf.float32, [None, self.node_input_dim])
# job input dimension: [total_num_jobs, num_features]
self.job_inputs = tf.placeholder(tf.float32, [None, self.job_input_dim])
self.gcn = GraphCNN(
self.node_inputs, self.node_input_dim, self.hid_dims,
self.output_dim, self.max_depth, self.act_fn, self.scope)
self.gsn = GraphSNN(
tf.concat([self.node_inputs, self.gcn.outputs], axis=1),
self.node_input_dim + self.output_dim, self.hid_dims,
self.output_dim, self.act_fn, self.scope)
# valid mask for node action ([batch_size, total_num_nodes])
self.node_valid_mask = tf.placeholder(tf.float32, [None, None])
# 执行者种类的掩码
self.type_valid_mask = tf.placeholder(tf.float32, [None, None])
# valid mask for executor limit on jobs ([batch_size, num_jobs * num_exec_limits])
self.job_valid_mask = tf.placeholder(tf.float32, [None, None])
# map back the dag summeraization to each node ([total_num_nodes, num_dags])
self.dag_summ_backward_map = tf.placeholder(tf.float32, [None, None])
# map gcn_outputs and raw_inputs to action probabilities
# node_act_probs: [batch_size, total_num_nodes]
# job_act_probs: [batch_size, total_num_dags]
# 预测结果，加上了执行者选择种类
self.node_act_probs, self.job_act_probs, self.type_act_probs= self.actor_network(
self.node_inputs, self.gcn.outputs, self.job_inputs,
self.gsn.summaries[0], self.gsn.summaries[1],
self.node_valid_mask, self.job_valid_mask,self.type_valid_mask,
self.dag_summ_backward_map, self.act_fn)
# draw action based on the probability (from OpenAI baselines)
# node_acts [batch_size, 1]
logits = tf.log(self.node_act_probs)
noise = tf.random_uniform(tf.shape(logits))
self.node_acts = tf.argmax(logits - tf.log(-tf.log(noise)), 1)
# job_acts [batch_size, num_jobs, 1]
logits = tf.log(self.job_act_probs)
noise = tf.random_uniform(tf.shape(logits))
self.job_acts = tf.argmax(logits - tf.log(-tf.log(noise)), 2)
# type_acts得出结论 [batch_size, num_jobs, 1]
logits = tf.log(self.type_act_probs)
noise = tf.random_uniform(tf.shape(logits))
self.type_acts = tf.argmax(logits - tf.log(-tf.log(noise)), 2)
# Selected action for node, 0-1 vector ([batch_size, total_num_nodes])
self.node_act_vec = tf.placeholder(tf.float32, [None, None])
# Selected action for job, 0-1 vector ([batch_size, num_jobs, num_limits])
self.job_act_vec = tf.placeholder(tf.float32, [None, None, None])
# 关于种类的，维度暂时未知 train里也要改
self.type_act_vec = tf.placeholder(tf.float32, [None, None, None])
# advantage term (from Monte Calro or critic) ([batch_size, 1]) reward-baseline
self.adv = tf.placeholder(tf.float32, [None, 1])
# use entropy to promote exploration, this term decays over time
self.entropy_weight = tf.placeholder(tf.float32, ()) #一个参数，类似于未来value的折扣，一般这种都是参数
# select node action probability
self.selected_node_prob = tf.reduce_sum(tf.multiply(
self.node_act_probs, self.node_act_vec),
reduction_indices=1, keep_dims=True)
# select job action probability
self.selected_job_prob = tf.reduce_sum(tf.reduce_sum(tf.multiply(
self.job_act_probs, self.job_act_vec),
reduction_indices=2), reduction_indices=1, keep_dims=True)
# 选择种类
self.selected_type_prob = tf.reduce_sum(tf.reduce_sum(tf.multiply(
self.type_act_probs, self.type_act_vec),
reduction_indices=2), reduction_indices=1, keep_dims=True)
# actor loss due to advantge (negated) tf.multiply（）两个矩阵中对应元素各自相乘 ?
self.adv_loss = tf.reduce_sum(tf.multiply(
tf.log(self.selected_node_prob * self.selected_job_prob*self.selected_type_prob + \
self.eps), -self.adv))
# node_entropy 信息熵
self.node_entropy = tf.reduce_sum(tf.multiply(
self.node_act_probs, tf.log(self.node_act_probs + self.eps)))
# prob on each job
self.prob_each_job = tf.reshape(
tf.sparse_tensor_dense_matmul(self.gsn.summ_mats[0],
tf.reshape(self.node_act_probs, [-1, 1])),
[tf.shape(self.node_act_probs)[0], -1])
# job entropy
self.job_entropy = \
tf.reduce_sum(tf.multiply(self.prob_each_job,
tf.reduce_sum(tf.multiply(self.job_act_probs,
tf.log(self.job_act_probs + self.eps)), reduction_indices=2)))
#type
self.type_entropy = \
tf.reduce_sum(tf.multiply(self.prob_each_job,
tf.reduce_sum(tf.multiply(self.type_act_probs,
tf.log(self.type_act_probs + self.eps)), reduction_indices=2)))
# entropy loss
self.entropy_loss = self.node_entropy + self.job_entropy + self.type_entropy
# normalize entropy
self.entropy_loss /= \
(tf.log(tf.cast(tf.shape(self.node_act_probs)[1], tf.float32)) + \
tf.log(float(len(self.executor_levels)))+tf.log(float(len(self.type_num)))) #这里加一个种类总数,然后取log
# normalize over batch size (note: adv_loss is sum)
# * tf.cast(tf.shape(self.node_act_probs)[0], tf.float32)
# define combined loss
self.act_loss = self.adv_loss + self.entropy_weight * self.entropy_loss
# get training parameters 网络的参数
self.params = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.scope)
# operations for setting network parameters
self.input_params, self.set_params_op = \
self.define_params_op()
# actor gradients
self.act_gradients = tf.gradients(self.act_loss, self.params)
# adaptive learning rate
self.lr_rate = tf.placeholder(tf.float32, shape=[])
# actor optimizer
self.act_opt = self.optimizer(self.lr_rate).minimize(self.act_loss)
# apply gradient directly to update parameters
self.apply_grads = self.optimizer(self.lr_rate).\
apply_gradients(zip(self.act_gradients, self.params))
# network paramter saver
self.saver = tf.train.Saver(max_to_keep=args.num_saved_models)
self.sess.run(tf.global_variables_initializer())
if args.saved_model is not None:
self.saver.restore(self.sess, args.saved_model)
def main():
"""Create the model and start the training."""
args = get_arguments()
# setup used GPU
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = args.GPU
h, w = map(int, args.input_size.split(','))
input_size = (h, w)
tf.set_random_seed(args.random_seed)
# Create queue coordinator.
coord = tf.train.Coordinator()
# Load reader.
with tf.name_scope("create_inputs"):
reader = ImageReader(args.data_dir, args.data_list, input_size,
args.random_scale, args.random_mirror,
args.ignore_label, IMG_MEAN, coord)
image_batch, label_batch = reader.dequeue(args.batch_size)
image_batch_up = tf.image.resize_bilinear(
image_batch, [h * args.up_scale, w * args.up_scale])
# Create network.
net = DeepLabResNetModel({'data': image_batch_up},
is_training=args.is_training,
num_classes=args.num_classes)
# For a small batch size, it is better to keep
# the statistics of the BN layers (running means and variances)
# frozen, and to not update the values provided by the pre-trained model.
# If is_training=True, the statistics will be updated during the training.
# Note that is_training=False still updates BN parameters gamma (scale) and beta (offset)
# if they are presented in var_list of the optimiser definition.
# Predictions.
raw_output = net.layers['fc1_voc12']
# Which variables to load. Running means and variances are not trainable,
# thus all_variables() should be restored.
restore_var = [
v for v in tf.global_variables()
if 'fc' not in v.name or not args.not_restore_last
]
all_trainable = [
v for v in tf.trainable_variables()
if 'beta' not in v.name and 'gamma' not in v.name
]
fc_trainable = [v for v in all_trainable if 'fc' in v.name]
conv_trainable = [v for v in all_trainable
if 'fc' not in v.name] # lr * 1.0
fc_w_trainable = [v for v in fc_trainable
if 'weights' in v.name] # lr * 10.0
fc_b_trainable = [v for v in fc_trainable
if 'biases' in v.name] # lr * 20.0
assert (len(all_trainable) == len(fc_trainable) + len(conv_trainable))
assert (len(fc_trainable) == len(fc_w_trainable) + len(fc_b_trainable))
# Predictions: ignoring all predictions with labels greater or equal than n_classes
raw_prediction = tf.reshape(raw_output, [-1, args.num_classes])
label_proc = prepare_label(label_batch,
tf.stack(raw_output.get_shape()[1:3]),
num_classes=args.num_classes,
one_hot=False) # [batch_size, h, w]
raw_gt = tf.reshape(label_proc, [
-1,
])
indices = tf.squeeze(tf.where(tf.less_equal(raw_gt, args.num_classes - 1)),
1)
gt = tf.cast(tf.gather(raw_gt, indices), tf.int32)
prediction = tf.gather(raw_prediction, indices)
# Pixel-wise softmax loss.
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=prediction,
labels=gt)
l2_losses = [
args.weight_decay * tf.nn.l2_loss(v) for v in tf.trainable_variables()
if 'weights' in v.name
]
reduced_loss = tf.reduce_mean(loss) + tf.add_n(l2_losses)
# Processed predictions: for visualisation.
raw_output_up = tf.image.resize_bilinear(raw_output,
tf.shape(image_batch)[1:3, ])
raw_output_up = tf.argmax(raw_output_up, dimension=3)
pred = tf.expand_dims(raw_output_up, dim=3)
# Define loss and optimisation parameters.
base_lr = tf.constant(args.learning_rate)
step_ph = tf.placeholder(dtype=tf.float32, shape=())
# learning_rate = tf.scalar_mul(base_lr, tf.pow((1 - step_ph / args.num_steps), args.power))
learning_rate = base_lr
global_step = tf.Variable(0,
dtype=tf.int32,
trainable=False,
name='global_step')
opt_conv = tf.train.MomentumOptimizer(learning_rate, args.momentum)
opt_fc_w = tf.train.MomentumOptimizer(learning_rate * 10.0, args.momentum)
opt_fc_b = tf.train.MomentumOptimizer(learning_rate * 20.0, args.momentum)
grads = tf.gradients(reduced_loss,
conv_trainable + fc_w_trainable + fc_b_trainable)
grads_conv = grads[:len(conv_trainable)]
grads_fc_w = grads[len(conv_trainable):(len(conv_trainable) +
len(fc_w_trainable))]
grads_fc_b = grads[(len(conv_trainable) + len(fc_w_trainable)):]
train_op_conv = opt_conv.apply_gradients(zip(grads_conv, conv_trainable),
global_step=global_step)
train_op_fc_w = opt_fc_w.apply_gradients(zip(grads_fc_w, fc_w_trainable))
train_op_fc_b = opt_fc_b.apply_gradients(zip(grads_fc_b, fc_b_trainable))
train_op = tf.group(train_op_conv, train_op_fc_w, train_op_fc_b)
# Image summary.
images_summary = tf.py_func(inv_preprocess,
[image_batch, args.save_num_images, IMG_MEAN],
tf.uint8)
labels_summary = tf.py_func(
decode_labels, [label_batch, args.save_num_images, args.num_classes],
tf.uint8)
preds_summary = tf.py_func(decode_labels,
[pred, args.save_num_images, args.num_classes],
tf.uint8)
image_summary = tf.summary.image(
'images',
tf.concat(axis=2,
values=[images_summary, labels_summary, preds_summary]),
max_outputs=args.save_num_images) # Concatenate row-wise.
loss_summary = tf.summary.scalar("loss", reduced_loss)
entropy_summary = tf.summary.scalar("entropy", tf.reduce_mean(loss))
l2_loss_summary = tf.summary.scalar("L2_loss", tf.add_n(l2_losses))
learning_rate_summary = tf.summary.scalar(
"learning_rate", learning_rate) # summary recording learning rate
summary_writer = tf.summary.FileWriter(args.snapshot_dir,
graph=tf.get_default_graph())
print("Setting up summary op...")
total_summary = tf.summary.merge_all()
# Set up tf session and initialize variables.
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
init = tf.global_variables_initializer()
sess.run(init)
# Saver for storing checkpoints of the model.
saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=2)
# load weights from saved checkpoint or initial pre-trained model
if os.path.isdir(args.snapshot_dir):
# search checkpoint at given path
ckpt = tf.train.get_checkpoint_state(args.snapshot_dir)
if ckpt and ckpt.model_checkpoint_path:
# load checkpoint file
load(saver, sess, ckpt.model_checkpoint_path)
elif os.path.isfile(args.snapshot_dir):
# load checkpoint file
load(saver, sess, args.snapshot_dir)
elif args.restore_from is not None:
loader = tf.train.Saver(
var_list=restore_var) # loader for part of pre-trained model
load(loader, sess, args.restore_from)
else:
print("No model found at{}".format(args.restore_from))
# Start queue threads.
threads = tf.train.start_queue_runners(coord=coord, sess=sess)
# Initial status
loss_value, entropy_loss, summary, itr = sess.run(
[reduced_loss,
tf.reduce_mean(loss), total_summary, global_step])
print('step {:d} \t loss = {:.3f}, entropy_loss = {:.3f})'.format(
itr, loss_value, entropy_loss))
summary_writer.add_summary(summary, itr)
# Iterate over training steps.
for step in range(args.num_steps):
start_time = time.time()
feed_dict = {step_ph: step}
_, itr = sess.run([train_op, global_step], feed_dict=feed_dict)
# save summary file
if itr % 100 == 0:
duration = time.time() - start_time
loss_value, entropy_loss, summary, itr = sess.run([
reduced_loss,
tf.reduce_mean(loss), total_summary, global_step
])
summary_writer.add_summary(summary, itr)
print(
'step {:d} \t loss = {:.3f}, entropy_loss = {:.3f}, ({:.3f} sec/step)'
.format(itr, loss_value, entropy_loss, duration))
# save checkpoint
if itr % args.save_pred_every == 0:
# images, labels, preds = sess.run([image_batch, label_batch, pred])
save(saver, sess, args.snapshot_dir, global_step)
# final status
loss_value, entropy_loss, summary, itr = sess.run(
[reduced_loss,
tf.reduce_mean(loss), total_summary, global_step])
print('step {:d} \t loss = {:.3f}, entropy_loss = {:.3f}'.format(
itr, loss_value, entropy_loss))
save(saver, sess, args.snapshot_dir, global_step)
summary_writer.add_summary(summary, itr)
coord.request_stop()
coord.join(threads)
def __init__(self, args):
self.batch_size = batch_size = args.batch_size
self.seq_length = seq_length = args.seq_length
size = args.latent_dimensions
num_layers = args.num_layers
vocab_size = args.vocab_size
x_dim = 200
x2s_dim = 200
self._input_data = tf.placeholder(tf.int32, [batch_size, seq_length])
self._targets = tf.placeholder(tf.int32, [batch_size, seq_length])
with tf.device('/cpu:0'):
embedding = tf.get_variable('embedding',
[vocab_size, x_dim],
dtype=tf.float32)
inputs = tf.nn.embedding_lookup(embedding, self._input_data)
inputs = [tf.squeeze(input_step, [1])
for input_step in tf.split(1, seq_length, inputs)]
inputs = tf.reshape(inputs, [-1, seq_length * x_dim])
phi_1 = FullyConnected(inputs,
[x_dim * seq_length, x2s_dim],
unit='relu',
name='phi_1')
phi_2 = FullyConnected(phi_1,
[x2s_dim, x2s_dim],
unit='relu',
name='phi_2')
phi_3 = FullyConnected(phi_2,
[x2s_dim, x2s_dim],
unit='relu',
name='phi_3')
phi_4 = FullyConnected(phi_3,
[x2s_dim, x2s_dim],
unit='relu',
name='phi_4')
rnn_inputs = \
[tf.squeeze(tf.reshape(input_step,
[batch_size, 1, x2s_dim // seq_length]),[1])
for input_step in tf.split(1, seq_length, phi_4)]
cell = LatentHiddensVRNNCell(size, state_is_tuple=True)
cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)
self._initial_state = cell.zero_state(batch_size, tf.float32)
z, last_state = tf.nn.rnn(cell,
rnn_inputs,
initial_state=self._initial_state)
z = tf.reshape(tf.concat(1, z), [-1, size])
logits = FullyConnected(z,
[size, vocab_size],
unit='linear',
name='logits')
self._probs = tf.nn.softmax(logits)
recon_loss = tf.nn.seq2seq.sequence_loss_by_example(
[logits],
[tf.reshape(self._targets, [-1])],
[tf.ones([batch_size * seq_length], dtype=tf.float32)],
vocab_size)
kl_loss = [KLGaussianStdGaussian(z_mean, z_log_sigma_sq)
for _, z_mean, z_log_sigma_sq in last_state]
self._cost = tf.reduce_mean(kl_loss) \
+ tf.reduce_sum(recon_loss) / batch_size / seq_length
self._final_state = last_state
self._lr = tf.Variable(0.0, trainable=False)
tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(self._cost, tvars),
args.max_grad_norm)
optimizer = tf.train.AdamOptimizer(self._lr)
self._train_op = optimizer.apply_gradients(zip(grads, tvars))
self._new_lr = tf.placeholder(tf.float32, shape=[],
name='new_learning_rate')
self._lr_update = tf.assign(self._lr, self._new_lr)
layer1 = tf.nn.relu(tf.matmul(observations,W1))
W2 = tf.get_variable("W2", shape=[H, 1],
initializer=tf.contrib.layers.xavier_initializer())
score = tf.matmul(layer1,W2)
probability = tf.nn.sigmoid(score)
#From here we define the parts of the network needed for learning a good policy.
tvars = tf.trainable_variables()
input_y = tf.placeholder(tf.float32,[None,1], name="input_y")
advantages = tf.placeholder(tf.float32,name="reward_signal")
# The loss function. This sends the weights in the direction of making actions
# that gave good advantage (reward over time) more likely, and actions that didn't less likely.
loglik = tf.log(input_y*(input_y - probability) + (1 - input_y)*(input_y + probability))
loss = -tf.reduce_mean(loglik * advantages)
newGrads = tf.gradients(loss,tvars)
# Once we have collected a series of gradients from multiple episodes, we apply them.
# We don't just apply gradeients after every episode in order to account for noise in the reward signal.
adam = tf.train.AdamOptimizer(learning_rate=learning_rate) # Our optimizer
W1Grad = tf.placeholder(tf.float32,name="batch_grad1") # Placeholders to send the final gradients through when we update.
W2Grad = tf.placeholder(tf.float32,name="batch_grad2")
batchGrad = [W1Grad,W2Grad]
updateGrads = adam.apply_gradients(zip(batchGrad,tvars))
def discount_rewards(r):
""" take 1D float array of rewards and compute discounted reward """
discounted_r = np.zeros_like(r)
running_add = 0
for t in reversed(xrange(0, r.size)):
def build_graph(self, args, maxTimeSteps):
self.graph = tf.Graph()
with self.graph.as_default():
self.inputX = tf.placeholder(
tf.float32,
shape=(maxTimeSteps, args.batch_size,
args.num_feature)) # [maxL,32,39]
inputXrs = tf.reshape(self.inputX, [-1, args.num_feature])
# self.inputList = tf.split(0, maxTimeSteps, inputXrs) #convert inputXrs from [32*maxL,39] to [32,maxL,39]
self.inputList = tf.split(
inputXrs, maxTimeSteps,
0) # convert inputXrs from [32*maxL,39] to [32,maxL,39]
self.targetIxs = tf.placeholder(tf.int64)
self.targetVals = tf.placeholder(tf.int32)
self.targetShape = tf.placeholder(tf.int64)
self.targetY = tf.SparseTensor(self.targetIxs, self.targetVals,
self.targetShape)
self.seqLengths = tf.placeholder(tf.int32, shape=(args.batch_size))
self.config = {
'name': args.model,
'rnncell': self.cell_fn,
'num_layer': args.num_layer,
'num_hidden': args.num_hidden,
'num_class': args.num_class,
'activation': args.activation,
'optimizer': args.optimizer,
'learning rate': args.learning_rate,
'keep prob': args.keep_prob,
'batch size': args.batch_size
}
fbHrs = build_multi_dynamic_brnn(self.args, maxTimeSteps,
self.inputX, self.cell_fn,
self.seqLengths)
with tf.name_scope('fc-layer'):
with tf.variable_scope('fc'):
weightsClasses = tf.Variable(
tf.truncated_normal([args.num_hidden, args.num_class],
name='weightsClasses'))
biasesClasses = tf.Variable(tf.zeros([args.num_class]),
name='biasesClasses')
logits = [
tf.matmul(t, weightsClasses) + biasesClasses
for t in fbHrs
]
logits3d = tf.stack(logits)
self.loss = tf.reduce_mean(
tf.nn.ctc_loss(self.targetY, logits3d, self.seqLengths))
self.var_op = tf.global_variables()
self.var_trainable_op = tf.trainable_variables()
if args.grad_clip == -1:
# not apply gradient clipping
self.optimizer = tf.train.AdamOptimizer(
args.learning_rate).minimize(self.loss)
else:
# apply gradient clipping
grads, _ = tf.clip_by_global_norm(
tf.gradients(self.loss, self.var_trainable_op),
args.grad_clip)
opti = tf.train.AdamOptimizer(args.learning_rate)
self.optimizer = opti.apply_gradients(
zip(grads, self.var_trainable_op))
self.predictions = tf.to_int32(
tf.nn.ctc_beam_search_decoder(logits3d,
self.seqLengths,
merge_repeated=False)[0][0])
if args.level == 'cha':
self.errorRate = tf.reduce_sum(
tf.edit_distance(self.predictions,
self.targetY,
normalize=True))
self.initial_op = tf.global_variables_initializer()
self.saver = tf.train.Saver(tf.global_variables(),
max_to_keep=5,
keep_checkpoint_every_n_hours=1)
def __init__(self, x_dim=784, w=31, h=10, c=512, z_dim=64, latent_dim=64,nf=64, batch_size=80,
c_gp_x=10., lamda=0.1, output_path='./',training=True):
with tf.variable_scope('wgan'):
self.bn_params = {
"decay": 0.99,
"epsilon": 1e-5,
"scale": True,
"is_training": training
}
self.x_dim = x_dim
self.z_dim = z_dim
self.w = w
self.h = h
self.c =c
self.nf = nf
self.restime = 3
self.latent_dim = latent_dim
self.batch_size = batch_size
self.c_gp_x = c_gp_x
self.lamda = lamda
self.output_path = output_path
self.gen_params = self.dis_params = self.inv_params = None
self.z = tf.placeholder(tf.float32, shape=[None, self.z_dim])
self.x_p = self.generate(self.z)
self.x = tf.placeholder(tf.float32, shape=[None, self.h,self.w,self.c])
#self.x += tf.random_normal(shape=tf.shape(self.x), mean=0.0, stddev=0.01)
self.z_p = self.invert(self.x)
self.dis_x = self.discriminate(self.x)
self.dis_x_p = self.discriminate(self.x_p,reuse=True)
self.rec_x = self.generate(self.z_p,reuse=True)
self.rec_z = self.invert(self.x_p,reuse=True)
self.gen_cost = -tf.reduce_mean(self.dis_x_p)
#self.gen_cost = tf.reduce_mean(-self.dis_x_p)
self.inv_cost = tf.reduce_mean(tf.square(self.x - self.rec_x))
self.inv_cost += self.lamda * tf.reduce_mean(tf.square(self.z - self.rec_z))
self.dis_cost = tf.reduce_mean(self.dis_x_p) - tf.reduce_mean(self.dis_x)
#self.dis_cost = -tf.reduce_mean(self.dis_x - self.dis_x_p)
alpha = tf.random_uniform(shape=[self.batch_size,1,1,1], minval=0., maxval=1.)
difference = self.x_p - self.x
print("xp",self.x_p.shape)
print("x",self.x.shape)
print("diff",difference.shape)
#interpolate = self.x + alpha * difference
interpolate = alpha*self.x + (1.-alpha)*self.x_p
#gradient = tf.gradients(self.discriminate(interpolate,reuse=True), [interpolate])[0]
gradient = tf.gradients(self.discriminate(interpolate,reuse=True), [interpolate])[0]
gradient=slim.flatten(gradient)
#slope = tf.sqrt(tf.reduce_sum(tf.square(gradient), axis=1))
slope = tf.norm(gradient, axis=1)
gradient_penalty = tf.reduce_mean((slope - 1.)**2)
self.dis_cost += self.c_gp_x * gradient_penalty
train_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=tf.contrib.framework.get_name_scope())
self.gen_param=[v for v in train_vars if v.name.split("/")[1] == "generate"]
self.inv_param=[v for v in train_vars if v.name.split("/")[1] == "invert"]
self.dis_param=[v for v in train_vars if v.name.split("/")[1] == "discriminate"]
"""
self.gen_train_op = tf.train.AdamOptimizer(
learning_rate=2e-8, beta1=0.5, beta2=0.9).minimize(
self.gen_cost, var_list=self.gen_params)
self.inv_train_op = tf.train.AdamOptimizer(
learning_rate=2e-8, beta1=0.5, beta2=0.9).minimize(
self.inv_cost, var_list=self.inv_params)
self.dis_train_op = tf.train.AdamOptimizer(
learning_rate=2e-8, beta1=0.5, beta2=0.9).minimize(
self.dis_cost, var_list=self.dis_params)
"""
genopt = tf.train.AdamOptimizer(
learning_rate=1e-4, beta1=0.5, beta2=0.9)
self.gen_train_op= slim.learning.create_train_op(self.gen_cost,genopt,summarize_gradients=True,variables_to_train=self.gen_params)
invopt = tf.train.AdamOptimizer(
learning_rate=1e-4, beta1=0.5, beta2=0.9)
self.inv_train_op= slim.learning.create_train_op(self.inv_cost,invopt,summarize_gradients=True,variables_to_train=self.inv_params)
disopt = tf.train.AdamOptimizer(
learning_rate=1e-4, beta1=0.5, beta2=0.9)
#learning_rate=1.52*1e-5, beta1=0.5, beta2=0.9)
self.dis_train_op= slim.learning.create_train_op(self.dis_cost,disopt,summarize_gradients=True,variables_to_train=self.dis_params)
def create_network(self, input_tensor, label_tensor, class_tensor, action_history_tensor, is_training):
self.input_tensor = input_tensor
self.label_tensor = label_tensor
self.class_tensor = class_tensor
self.action_history_tensor = action_history_tensor
# feature extractor - convolutions
net = slim.convolution(input_tensor, 96, [7, 7], 2, padding='VALID', scope='conv1',
activation_fn=tf.nn.relu)
net = tf.nn.lrn(net, depth_radius=5, bias=2, alpha=1e-4*5, beta=0.75)
net = slim.pool(net, [3, 3], 'MAX', stride=2, padding='VALID', scope='pool1')
net = slim.convolution(net, 256, [5, 5], 2, padding='VALID', scope='conv2',
activation_fn=tf.nn.relu)
net = tf.nn.lrn(net, depth_radius=5, bias=2, alpha=1e-4*5, beta=0.75)
net = slim.pool(net, [3, 3], 'MAX', stride=2, padding='VALID', scope='pool2')
net = slim.convolution(net, 512, [3, 3], 1, padding='VALID', scope='conv3',
activation_fn=tf.nn.relu)
self.layer_feat = net
# fc layers
net = slim.convolution(net, 512, [3, 3], 1, padding='VALID', scope='fc4',
activation_fn=tf.nn.relu)
net = slim.dropout(net, keep_prob=0.5, is_training=is_training, scope='dropout')
net = tf.concat([net, action_history_tensor], axis=-1)
net = slim.convolution(net, 512, [1, 1], 1, padding='VALID', scope='fc5',
activation_fn=tf.nn.relu)
net = slim.dropout(net, keep_prob=0.5, is_training=is_training, scope='dropout_x16')
# auxilaries
out_actions = slim.convolution(net, 11, [1, 1], 1, padding='VALID', scope='fc6_1', activation_fn=None)
out_scores = slim.convolution(net, 2, [1, 1], 1, padding='VALID', scope='fc6_2', activation_fn=None)
out_actions = flatten_convolution(out_actions)
out_scores = flatten_convolution(out_scores)
self.layer_actions = tf.nn.softmax(out_actions)
self.layer_scores = tf.nn.softmax(out_scores)
# losses
self.loss_actions = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=label_tensor, logits=out_actions)
self.loss_cls = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=class_tensor, logits=out_scores)
# finetune ops
var_fc = [var for var in tf.trainable_variables() if 'fc' in var.name and 'fc6_2' not in var.name]
self.var_grads_fc1 = var_fc
gradients1 = tf.gradients(self.loss_actions, xs=var_fc) # only finetune on fc1 layers
self.weighted_grads_fc1 = []
for var, grad in zip(var_fc, gradients1):
self.weighted_grads_fc1.append(10 * grad)
continue
if 'fc6_1/weights' in var.name:
self.weighted_grads_fc1.append(20 * grad)
elif 'fc6_1/biases' in var.name:
self.weighted_grads_fc1.append(40 * grad)
elif 'weights' in var.name:
self.weighted_grads_fc1.append(20 * grad)
elif 'biases' in var.name:
self.weighted_grads_fc1.append(10 * grad)
else:
raise
var_fc = [var for var in tf.trainable_variables() if 'fc' in var.name and 'fc6_1' not in var.name]
self.var_grads_fc2 = var_fc
gradients2 = tf.gradients(self.loss_cls, xs=var_fc) # only finetune on fc2 layers
self.weighted_grads_fc2 = []
for var, grad in zip(var_fc, gradients2):
self.weighted_grads_fc2.append(10 * grad)
continue
if 'weights' in var.name:
self.weighted_grads_fc2.append(20 * grad)
elif 'biases' in var.name:
self.weighted_grads_fc2.append(10 * grad)
else:
raise
self.weighted_grads_op1 = self.optimizer.apply_gradients(zip(self.weighted_grads_fc1, self.var_grads_fc1))
self.weighted_grads_op2 = self.optimizer.apply_gradients(zip(self.weighted_grads_fc2, self.var_grads_fc2))
return cost
network, lstm1 = inference(input_data, is_train=True, sequence_length=sequence_length, reuse=None)
network_test, lstm1_test = inference(input_data_test, is_train=False, sequence_length=1, reuse=True)
y_linear = network_test.outputs
y_soft = tf.nn.softmax(y_linear)
cost = loss_fn(network.outputs, targets, batch_size, sequence_length)
with tf.variable_scope('learning_rate'):
lr = tf.Variable(0.0, trainable=False)
tvars = network.all_params[1:]
grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars), max_grad_norm)
# optimizer = tf.train.GradientDescentOptimizer(lr)
# train_op = optimizer.apply_gradients(zip(grads, tvars))
train_op = tf.train.AdamOptimizer(0.01).apply_gradients(zip(grads, tvars))
sess = tf.InteractiveSession()
tl.layers.initialize_global_variables(sess)
train_data = words_id
for i in range(max_max_epoch):
new_lr_decay = lr_decay ** max(i - max_epoch, 0.0)
sess.run(tf.assign(lr, learning_rate * new_lr_decay))
print(f'Epoch: {i+1}/{max_max_epoch} Learning rate: {sess.run(lr)}')
epoch_size = ((len(train_data) // batch_size) - 1) // sequence_length
def task_metalearn(inp, reuse=True):
inputa, inputb, labela, labelb = inp
if FLAGS.datasource in ['2D']:
input_task_emb = tf.concat((inputa, labela), axis=-1)
with tf.variable_scope('first_embedding_sync', reuse=tf.AUTO_REUSE):
input_task_emb = tf.layers.dense(input_task_emb, units=FLAGS.sync_filters,
name='first_embedding_sync_dense')
if FLAGS.num_classes < FLAGS.update_batch_size:
with tf.variable_scope('reg_clustering', reuse=tf.AUTO_REUSE):
assign_mat = tf.nn.softmax(tf.layers.dense(input_task_emb, units=FLAGS.num_classes), dim=1)
input_task_emb_cat = tf.matmul(tf.transpose(assign_mat, perm=[1, 0]), input_task_emb)
elif FLAGS.datasource in ['plainmulti', 'artmulti']:
input_task_emb = self.image_embed.model(tf.reshape(inputa,
[-1, self.img_size, self.img_size,
self.channels]))
proto_emb = []
labela2idx = tf.argmax(labela, axis=1)
for class_idx in range(FLAGS.num_classes):
tmp_gs = tf.equal(labela2idx, class_idx)
gs = tf.where(tmp_gs)
new_vec = tf.reduce_mean(tf.gather(input_task_emb, gs), axis=0)
proto_emb.append(new_vec)
proto_emb = tf.squeeze(tf.stack(proto_emb))
label_cat = tf.eye(5)
input_task_emb_cat = tf.concat((proto_emb, label_cat), axis=-1)
if FLAGS.datasource in ['2D']:
task_embed_vec, task_emb_loss = self.lstmae.model(input_task_emb)
propagate_knowledge = self.metagraph.model(input_task_emb_cat)
elif FLAGS.datasource in ['plainmulti', 'artmulti']:
task_embed_vec, task_emb_loss = self.lstmae.model(input_task_emb_cat)
propagate_knowledge = self.metagraph.model(proto_emb)
task_embed_vec_graph, task_emb_loss_graph = self.lstmae_graph.model(propagate_knowledge)
task_enhanced_emb_vec = tf.concat([task_embed_vec, task_embed_vec_graph], axis=1)
with tf.variable_scope('task_specific_mapping', reuse=tf.AUTO_REUSE):
eta = []
for key in weights.keys():
weight_size = np.prod(weights[key].get_shape().as_list())
eta.append(tf.reshape(
tf.layers.dense(task_enhanced_emb_vec, weight_size, activation=tf.nn.sigmoid,
name='eta_{}'.format(key)), tf.shape(weights[key])))
eta = dict(zip(weights.keys(), eta))
task_weights = dict(zip(weights.keys(), [weights[key] * eta[key] for key in weights.keys()]))
task_outputbs, task_lossesb = [], []
if self.classification:
task_accuraciesb = []
task_outputa = self.forward(inputa, task_weights, reuse=reuse)
task_lossa = self.loss_func(task_outputa, labela)
grads = tf.gradients(task_lossa, list(task_weights.values()))
if FLAGS.stop_grad:
grads = [tf.stop_gradient(grad) for grad in grads]
gradients = dict(zip(task_weights.keys(), grads))
fast_weights = dict(
zip(task_weights.keys(),
[task_weights[key] - self.update_lr * gradients[key] for key in task_weights.keys()]))
output = self.forward(inputb, fast_weights, reuse=True)
task_outputbs.append(output)
task_lossesb.append(self.loss_func(output, labelb))
for j in range(num_updates - 1):
loss = self.loss_func(self.forward(inputa, fast_weights, reuse=True), labela)
grads = tf.gradients(loss, list(fast_weights.values()))
if FLAGS.stop_grad:
grads = [tf.stop_gradient(grad) for grad in grads]
gradients = dict(zip(fast_weights.keys(), grads))
fast_weights = dict(zip(fast_weights.keys(),
[fast_weights[key] - self.update_lr * gradients[key] for key in
fast_weights.keys()]))
output = self.forward(inputb, fast_weights, reuse=True)
task_outputbs.append(output)
task_lossesb.append(self.loss_func(output, labelb))
task_output = [task_emb_loss, task_emb_loss_graph, task_outputa, task_outputbs, task_lossa,
task_lossesb]
if self.classification:
task_accuracya = tf.contrib.metrics.accuracy(tf.argmax(tf.nn.softmax(task_outputa), 1),
tf.argmax(labela, 1))
for j in range(num_updates):
task_accuraciesb.append(
tf.contrib.metrics.accuracy(tf.argmax(tf.nn.softmax(task_outputbs[j]), 1),
tf.argmax(labelb, 1)))
task_output.extend([task_accuracya, task_accuraciesb])
return task_output
def _build_model(self):
# input points
self.x = tf.placeholder(tf.float32, shape=[self.batch_size, int(np.prod(self.x_dims))], name="X")
x = tf.tile(self.x, multiples=[self.n_samples, 1])
self.lr = tf.placeholder(tf.float32, shape=(), name="lr")
self.p_z = dbns.Normal(loc=tf.zeros(shape=[self.batch_size * self.n_samples, self.z_dim]),
scale=tf.ones(shape=[self.batch_size * self.n_samples, self.z_dim]))
# self.p_h1 = dbns.Normal(loc=tf.zeros(shape=[self.batch_size * self.n_samples, 100]),
# scale=tf.ones(shape=[self.batch_size * self.n_samples, 100]))
# self.p_h2 = dbns.Normal(loc=tf.zeros(shape=[self.batch_size * self.n_samples, 50]),
# scale=tf.ones(shape=[self.batch_size * self.n_samples, 50]))
# self.p_h1_ = dbns.Normal(loc=tf.zeros(shape=[self.batch_size * self.n_samples, 100]),
# scale=tf.ones(shape=[self.batch_size * self.n_samples, 100]))
# encoder
z_params = self.encoder(x)
z_mu = z_params[:, self.z_dim:]
z_sigma = tf.exp(z_params[:, :self.z_dim])
self.q_z = dbns.Normal(loc=z_mu, scale=z_sigma)
# params_q_h1_x = self.encoder(x, scope="q_h1_x", hidden_dim=200, z_dim=100)
# h1_mu = params_q_h1_x[:, 100:]
# h1_sigma = tf.exp(params_q_h1_x[:, :100])
# self.q_h1_x = dbns.Normal(loc=h1_mu, scale=h1_sigma)
# h1 = h1_mu + tf.multiply(h1_sigma, self.p_h1.sample())
# params_q_h2_h1 = self.encoder(h1, scope="q_h2_h1", hidden_dim=100, z_dim=50)
# h2_mu = params_q_h2_h1[:, 50:]
# h2_sigma = tf.exp(params_q_h2_h1[:, :50])
# self.q_h2_h1 = dbns.Normal(loc=h2_mu, scale=h2_sigma)
# h2 = h2_mu + tf.multiply(h2_sigma, self.p_h2.sample())
z = z_mu + tf.multiply(z_sigma, self.p_z.sample())
# params_p_h1_h2 = self.encoder(h2, scope="p_h1_h2", hidden_dim=100, z_dim=100)
# h1_mu_ = params_p_h1_h2[:, 100:]
# h1_sigma_ = tf.exp(params_p_h1_h2[:, :100])
# self.p_h1_h2 = dbns.Normal(loc=h1_mu_, scale=h1_sigma_)
# h1_ = h1_mu_ + tf.multiply(h1_sigma_, self.p_h1_.sample())
# x_hat = self.decoder(h1_, hidden_dim=200)
# x_hat = self.decoder(h1, hidden_dim=200)
x_hat = self.decoder(z)
self.out_dbn = dbns.Bernoulli(logits=x_hat)
log_lik = tf.reduce_sum(x * tf.log(1e-8 + x_hat) + (1 - x) * tf.log(1e-8 + 1 - x_hat), 1)
neg_kld = tf.reduce_sum(self.p_z.log_prob(z) - self.q_z.log_prob(z), 1)
# log_lik = (tf.reduce_sum(x * tf.log(1e-8 + x_hat) + (1 - x) * tf.log(1e-8 + 1 - x_hat), 1) +
# tf.reduce_sum(self.p_h1_h2.log_prob(h1), 1))
# neg_kld = (tf.reduce_sum(self.p_h1_h2.log_prob(h1_) - self.q_h1_x.log_prob(h1), 1) +
# tf.reduce_sum(self.p_h1.log_prob(h1) - self.q_h1_x.log_prob(h1), 1) +
# tf.reduce_sum(self.p_h2.log_prob(h2) - self.q_h2_h1.log_prob(h2), 1))
# log_lik = (tf.reduce_sum(x * tf.log(1e-8 + x_hat) + (1 - x) * tf.log(1e-8 + 1 - x_hat), 1) +
# tf.reduce_sum(self.p_h1_h2.log_prob(h1), 1) + tf.reduce_sum(self.p_h2.log_prob(h2), 1))
# neg_kld = tf.reduce_sum(self.q_h1_x.log_prob(h1), 1) + tf.reduce_sum(self.q_h2_h1.log_prob(h2), 1)
# calculate importance weights using logsumexp and exp-normalize tricks
log_iws = (tf.reshape(log_lik, [self.batch_size, self.n_samples]) -
tf.reshape(neg_kld, [self.batch_size, self.n_samples]))
max_log_iws = tf.reduce_max(log_iws, axis=1, keepdims=True)
log_iws -= max_log_iws
self.elbo = tf.reduce_mean(max_log_iws + tf.log(1e-8 + tf.reduce_mean(
tf.exp(log_iws), axis=1, keepdims=True)))
self.loss = -self.elbo
# compute gradients
log_norm_const = tf.log(tf.clip_by_value(tf.reduce_sum(tf.exp(log_iws), 1, keepdims=True), 1e-9, np.inf))
log_norm_iws = tf.reshape(log_iws - log_norm_const, shape=[-1])
norm_iws = tf.stop_gradient(tf.exp(log_norm_iws))
trainable_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)
grads = tf.gradients(-tf.reshape(log_iws, [-1]) * norm_iws, trainable_vars)
grads_and_vars = zip(grads, trainable_vars)
# for now, hardcoding the Adam optimizer parameters used in the paper
optimizer = tf.train.AdamOptimizer(learning_rate=self.lr, beta1=0.9, beta2=0.999, epsilon=0.0001)
optimizer.apply_gradients(grads_and_vars)
self.train_op = optimizer.minimize(self.loss)
# for sampling
self.z = self.encoder(self.x, trainable=False, reuse=True)
self.z_pl = tf.placeholder(tf.float32, shape=[None, self.z_dim])
self.sample = self.decoder(self.z_pl, trainable=False, reuse=True)
# tensorboard summaries
x_img = tf.reshape(x, [-1] + self.x_dims)
tf.summary.image('data', x_img)
sample_img = tf.reshape(x_hat, [-1] + self.x_dims)
tf.summary.image('samples', sample_img)
tf.summary.scalar('log_lik', tf.reduce_mean(log_lik))
tf.summary.scalar('neg_kld', tf.reduce_mean(neg_kld))
tf.summary.scalar('loss', self.loss)
tf.summary.scalar('elbo', self.elbo)
self.merged = tf.summary.merge_all()
def minimize(self, loss, x, optim_state):
grads = tf.gradients(
loss,
x,
colocate_gradients_with_ops=self._colocate_gradients_with_ops)
return self._apply_gradients(grads, x, optim_state)
def main():
args = parser.parse_args()
enc = encoder.get_encoder(args.model_name)
hparams = model.default_hparams()
with open(os.path.join('models', args.model_name, 'hparams.json')) as f:
hparams.override_from_dict(json.load(f))
if args.sample_length > hparams.n_ctx:
raise ValueError(
"Can't get samples longer than window size: %s" % hparams.n_ctx)
if args.model_name == '345M':
args.memory_saving_gradients = True
if args.optimizer == 'adam':
args.only_train_transformer_layers = True
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
config.graph_options.rewrite_options.layout_optimizer = rewriter_config_pb2.RewriterConfig.OFF
with tf.compat.v1.Session(config=config) as sess:
context = tf.placeholder(tf.int32, [args.batch_size, None])
context_in = randomize(context, hparams, args.noise)
output = model.model(hparams=hparams, X=context_in)
loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=context[:, 1:], logits=output['logits'][:, :-1]))
if args.val_every > 0:
val_context = tf.placeholder(tf.int32, [args.val_batch_size, None])
val_output = model.model(hparams=hparams, X=val_context)
val_loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=val_context[:, 1:], logits=val_output['logits'][:, :-1]))
val_loss_summary = tf.summary.scalar('val_loss', val_loss)
tf_sample = sample.sample_sequence(
hparams=hparams,
length=args.sample_length,
context=context,
batch_size=args.batch_size,
temperature=1.0,
top_k=args.top_k,
top_p=args.top_p)
all_vars = [v for v in tf.compat.v1.trainable_variables() if 'model' in v.name]
train_vars = [v for v in all_vars if '/h' in v.name] if args.only_train_transformer_layers else all_vars
if args.optimizer == 'adam':
opt = tf.compat.v1.train.AdamOptimizer(learning_rate=args.learning_rate)
elif args.optimizer == 'sgd':
opt = tf.train.GradientDescentOptimizer(learning_rate=args.learning_rate)
else:
exit('Bad optimizer:', args.optimizer)
if args.accumulate_gradients > 1:
if args.memory_saving_gradients:
exit("Memory saving gradients are not implemented for gradient accumulation yet.")
opt = AccumulatingOptimizer(
opt=opt,
var_list=train_vars)
opt_reset = opt.reset()
opt_compute = opt.compute_gradients(loss)
opt_apply = opt.apply_gradients()
summary_loss = tf.summary.scalar('loss', opt_apply)
else:
if args.memory_saving_gradients:
opt_grads = memory_saving_gradients.gradients(loss, train_vars)
else:
opt_grads = tf.gradients(loss, train_vars)
opt_grads = list(zip(opt_grads, train_vars))
opt_apply = opt.apply_gradients(opt_grads)
summary_loss = tf.compat.v1.summary.scalar('loss', loss)
summary_lr = tf.compat.v1.summary.scalar('learning_rate', args.learning_rate)
summaries = tf.compat.v1.summary.merge([summary_lr, summary_loss])
summary_log = tf.compat.v1.summary.FileWriter(
os.path.join(CHECKPOINT_DIR, args.run_name))
saver = tf.compat.v1.train.Saver(
var_list=all_vars,
max_to_keep=5,
keep_checkpoint_every_n_hours=2)
sess.run(tf.compat.v1.global_variables_initializer())
if args.restore_from == 'latest':
ckpt = tf.train.latest_checkpoint(
os.path.join(CHECKPOINT_DIR, args.run_name))
if ckpt is None:
# Get fresh GPT weights if new run.
ckpt = tf.train.latest_checkpoint(
os.path.join('models', args.model_name))
elif args.restore_from == 'fresh':
ckpt = tf.train.latest_checkpoint(
os.path.join('models', args.model_name))
else:
ckpt = tf.train.latest_checkpoint(args.restore_from)
print('Loading checkpoint', ckpt)
saver.restore(sess, ckpt)
print('Loading dataset...')
chunks = load_dataset(enc, args.dataset, args.combine, encoding=args.encoding)
data_sampler = Sampler(chunks)
if args.val_every > 0:
if args.val_dataset:
val_chunks = load_dataset(enc, args.val_dataset, args.combine, encoding=args.encoding)
else:
val_chunks = chunks
print('dataset has', data_sampler.total_size, 'tokens')
print('Training...')
if args.val_every > 0:
# Sample from validation set once with fixed seed to make
# it deterministic during training as well as across runs.
val_data_sampler = Sampler(val_chunks, seed=1)
val_batches = [[val_data_sampler.sample(1024) for _ in range(args.val_batch_size)]
for _ in range(args.val_batch_count)]
counter = 1
counter_path = os.path.join(CHECKPOINT_DIR, args.run_name, 'counter')
if os.path.exists(counter_path):
# Load the step number if we're resuming a run
# Add 1 so we don't immediately try to save again
with open(counter_path, 'r') as fp:
counter = int(fp.read()) + 1
def save():
maketree(os.path.join(CHECKPOINT_DIR, args.run_name))
print(
'Saving',
os.path.join(CHECKPOINT_DIR, args.run_name,
'model-{}').format(counter))
saver.save(
sess,
os.path.join(CHECKPOINT_DIR, args.run_name, 'model'),
global_step=counter)
with open(counter_path, 'w') as fp:
fp.write(str(counter) + '\n')
def generate_samples():
print('Generating samples...')
context_tokens = data_sampler.sample(1)
all_text = []
index = 0
while index < args.sample_num:
out = sess.run(
tf_sample,
feed_dict={context: args.batch_size * [context_tokens]})
for i in range(min(args.sample_num - index, args.batch_size)):
text = enc.decode(out[i])
text = '======== SAMPLE {} ========\n{}\n'.format(
index + 1, text)
all_text.append(text)
index += 1
print(text)
maketree(os.path.join(SAMPLE_DIR, args.run_name))
with open(
os.path.join(SAMPLE_DIR, args.run_name,
'samples-{}').format(counter), 'w', encoding=args.encoding) as fp:
fp.write('\n'.join(all_text))
def validation():
print('Calculating validation loss...')
losses = []
for batch in tqdm.tqdm(val_batches):
losses.append(sess.run(val_loss, feed_dict={val_context: batch}))
v_val_loss = np.mean(losses)
v_summary = sess.run(val_loss_summary, feed_dict={val_loss: v_val_loss})
summary_log.add_summary(v_summary, counter)
summary_log.flush()
print(
'[{counter} | {time:2.2f}] validation loss = {loss:2.2f}'
.format(
counter=counter,
time=time.time() - start_time,
loss=v_val_loss))
def sample_batch():
return [data_sampler.sample(1024) for _ in range(args.batch_size)]
avg_loss = (0.0, 0.0)
start_time = time.time()
try:
while True:
if counter % args.save_every == 0:
save()
if counter % args.sample_every == 0:
generate_samples()
if args.val_every > 0 and (counter % args.val_every == 0 or counter == 1):
validation()
if args.accumulate_gradients > 1:
sess.run(opt_reset)
for _ in range(args.accumulate_gradients):
sess.run(
opt_compute, feed_dict={context: sample_batch()})
(v_loss, v_summary) = sess.run((opt_apply, summaries))
else:
(_, v_loss, v_summary) = sess.run(
(opt_apply, loss, summaries),
feed_dict={context: sample_batch()})
summary_log.add_summary(v_summary, counter)
avg_loss = (avg_loss[0] * 0.99 + v_loss,
avg_loss[1] * 0.99 + 1.0)
print(
'[{counter} | {time:2.2f}] loss={loss:2.2f} avg={avg:2.2f}'
.format(
counter=counter,
time=time.time() - start_time,
loss=v_loss,
avg=avg_loss[0] / avg_loss[1]))
counter += 1
except KeyboardInterrupt:
print('interrupted')
save()
def __init__(self, args, training=True):
self.args = args
if not training:
args.batch_size = 1
args.seq_length = 1
if args.model == 'rnn':
#Basic tanh cell
cell_fn = rnn.BasicRNNCell
elif args.model == 'gru':
cell_fn = rnn.GRUCell
elif args.model == 'lstm':
cell_fn = rnn.BasicLSTMCell
elif args.model == 'nas':
#a new gating cell which can be used
cell_fn = rnn.NASCell
else:
raise Exception("model type not supported: {}".format(args.model))
cells = []
for _ in range(args.num_layers):
#num_layers is the stacking height of the rnn/lstm unit
cell = cell_fn(args.rnn_size)
#Dropout done only during training
if training and (args.output_keep_prob < 1.0
or args.input_keep_prob < 1.0):
cell = rnn.DropoutWrapper(
cell,
input_keep_prob=args.input_keep_prob,
output_keep_prob=args.output_keep_prob)
cells.append(cell)
#Defined lstm cell to be a stacked one.
self.cell = cell = rnn.MultiRNNCell(cells, state_is_tuple=True)
#training on multi-length batch_size ie multiple sequence parallelly
self.input_data = tf.placeholder(tf.int32,
[args.batch_size, args.seq_length])
self.targets = tf.placeholder(tf.int32,
[args.batch_size, args.seq_length])
self.initial_state = cell.zero_state(args.batch_size, tf.float32)
#Standard way of declaring variables
with tf.variable_scope('rnnlm'):
softmax_w = tf.get_variable("softmax_w",
[args.rnn_size, args.vocab_size])
softmax_b = tf.get_variable("softmax_b", [args.vocab_size])
#converting inputs to word or char embedding using look-up
embedding = tf.get_variable("embedding",
[args.vocab_size, args.rnn_size])
inputs = tf.nn.embedding_lookup(embedding, self.input_data)
# dropout beta testing: double check which one should affect next line
if training and args.output_keep_prob:
inputs = tf.nn.dropout(inputs, args.output_keep_prob)
#Split all of the given inputs into batches of size seq_length
inputs = tf.split(inputs, args.seq_length, 1)
inputs = [tf.squeeze(input_, [1]) for input_ in inputs]
def loop(prev, _):
"""During the testing time to get the input for the next time step
given the output of the current time step
"""
prev = tf.matmul(prev, softmax_w) + softmax_b
prev_symbol = tf.stop_gradient(tf.argmax(prev, 1))
return tf.nn.embedding_lookup(embedding, prev_symbol)
outputs, last_state = legacy_seq2seq.rnn_decoder(
inputs,
self.initial_state,
cell,
loop_function=loop if not training else None,
scope='rnnlm')
output = tf.reshape(tf.concat(outputs, 1), [-1, args.rnn_size])
self.logits = tf.matmul(output, softmax_w) + softmax_b
self.probs = tf.nn.softmax(self.logits)
loss = legacy_seq2seq.sequence_loss_by_example(
[self.logits], [tf.reshape(self.targets, [-1])],
[tf.ones([args.batch_size * args.seq_length])])
with tf.name_scope('cost'):
self.cost = tf.reduce_sum(loss) / args.batch_size / args.seq_length
self.final_state = last_state
self.lr = tf.Variable(0.0, trainable=False)
tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, tvars),
args.grad_clip)
with tf.name_scope('optimizer'):
optimizer = tf.train.AdamOptimizer(self.lr)
self.train_op = optimizer.apply_gradients(zip(grads, tvars))
# instrument tensorboard
tf.summary.histogram('logits', self.logits)
tf.summary.histogram('loss', loss)
tf.summary.scalar('train_loss', self.cost)
def train(self, reload=True):
"""train model"""
print("training...")
gtX = tf.placeholder(tf.int32, shape=[self.config.batchSize,
None]) # input
gtY = tf.placeholder(tf.int32, shape=[self.config.batchSize,
None]) # output
logits, probs, a, b, c = self.buildModel(self.trainData.wordNum, gtX)
targets = tf.reshape(gtY, [-1])
#loss
loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example(
[logits], [targets], [tf.ones_like(targets, dtype=tf.float32)])
globalStep = tf.Variable(0, trainable=False)
addGlobalStep = globalStep.assign_add(1)
cost = tf.reduce_mean(loss)
trainableVariables = tf.trainable_variables()
grads, a = tf.clip_by_global_norm(
tf.gradients(cost, trainableVariables),
5) # prevent loss divergence caused by gradient explosion
learningRate = tf.train.exponential_decay(
self.config.learningRateBase,
global_step=globalStep,
decay_steps=self.config.learningRateDecayStep,
decay_rate=self.config.learningRateDecayRate)
optimizer = tf.train.AdamOptimizer(learningRate)
trainOP = optimizer.apply_gradients(zip(grads, trainableVariables))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
if not os.path.exists(self.config.checkpointsPath):
os.mkdir(self.config.checkpointsPath)
if reload:
checkPoint = tf.train.get_checkpoint_state(
self.config.checkpointsPath)
# if have checkPoint, restore checkPoint
if checkPoint and checkPoint.model_checkpoint_path:
saver.restore(sess, checkPoint.model_checkpoint_path)
print("restored %s" % checkPoint.model_checkpoint_path)
else:
print("no checkpoint found!")
for epoch in range(self.config.epochNum):
X, Y = self.trainData.generateBatch()
epochSteps = len(X) # equal to batch
for step, (x, y) in enumerate(zip(X, Y)):
a, loss, gStep = sess.run([trainOP, cost, addGlobalStep],
feed_dict={
gtX: x,
gtY: y
})
print("epoch: %d, steps: %d/%d, loss: %3f" %
(epoch + 1, step + 1, epochSteps, loss))
if gStep % self.config.saveStep == self.config.saveStep - 1: # prevent save at the beginning
print("save model")
saver.save(sess,
os.path.join(self.config.checkpointsPath,
self.config.type),
global_step=gStep)
def __init__(self,
no_inputs,
no_outputs,
modelA,
modelB,
actor_net=[3],
critic_net=[3],
**network_args):
self.no_inputs = no_inputs
self.no_outputs = no_outputs
self.modelA = modelA
self.modelB = modelB
self.sess = tf.Session()
self.state = tf.placeholder(tf.float32,
shape=[None, self.no_inputs],
name="state")
# self.state_1 = tf.placeholder(tf.float32, shape = [1,self.no_inputs], name = 'state_1')
with tf.variable_scope('actor'):
weights = [
tf.constant_initializer(
np.array([[1, 2, 3], [4, 0.5, 2], [3, 2, 0.5]]).T),
tf.constant_initializer(np.array([0.8, 0.3, 0.5]))
]
biases = [
tf.constant_initializer(np.array([[0.3, -0.2, 0.1]])),
tf.constant_initializer(np.array([[0.2]]))
] #
self.node1 = tf.layers.dense(self.state,
3,
name="layer1",
kernel_initializer=weights[0],
bias_initializer=biases[0],
activation=tf.nn.tanh)
self.output = tf.layers.dense(self.node1,
1,
name="output",
kernel_initializer=weights[-1],
bias_initializer=biases[-1],
activation=None)
self.action = self.output #build_network(self.state, self.no_outputs, actor_net, **network_args)
logging.info('actor created')
# with tf.variable_scope('critic'):
# self.critic = build_network(self.state, self.no_inputs-1, critic_net, **network_args)
# logging.info('critic created')
with tf.variable_scope('model'):
self.modelA = tf.constant(self.modelA, dtype=tf.float32, name='A')
self.modelB = tf.constant(self.modelB, dtype=tf.float32, name='B')
self.gamma = tf.constant(0.9, dtype=tf.float32, name='gamma')
logging.info('model created')
with tf.variable_scope('loop'):
self.sliced_state = tf.transpose(self.state[:1, :2])
test = tf.matmul(self.modelB, self.action)
print('test: ', test.shape,
tf.matmul(self.modelA, self.sliced_state).shape,
self.sliced_state.shape)
self.next_state = tf.transpose(
tf.matmul(self.modelA, self.sliced_state) +
tf.matmul(self.modelB, self.action))
self.df_ds = self.modelA
self.df_da = self.modelB
self.reward = -tf.square(
(self.next_state[0, 1] - self.state[0, 2]), name='reward')
self.dr_ds = tf.gradients(self.reward, self.next_state)
# self.dr_ds = tf.multiply(self.next_state[0,1]-self.state[0,2], tf.constant([-2], dtype=tf.float32), name='dr_ds')
self.ds1_ds = tf.gradients(self.next_state, self.state)
self.action_grad = tf.gradients(self.action, self.state)
# print(self.dr_ds[0].shape, self.gamma.shape, self.critic[1,:].shape, self.ds1_ds[0].shape, self.critic[0,:].shape, (-1*(self.dr_ds[0] + self.gamma * self.critic[1,:])).shape)
# self.critic_error = -(self.dr_ds[0] + self.gamma * self.critic[1,:])*self.ds1_ds[0] + self.critic[0,:]
# self.critic_loss = 0.5 * tf.matmul(self.critic_error, tf.transpose(self.critic_error))
writer = tf.summary.FileWriter("test", self.sess.graph)
writer.close()
def build_loss_and_gradients(self, var_list):
"""Build loss function
$-\Big(\mathbb{E}_{q(\\beta)} [\log p(\\beta) - \log q(\\beta) ] +
\sum_{n=1}^N \mathbb{E}_{q(\\beta)q(z_n\mid\\beta)} [
r^*(x_n, z_n, \\beta) ] \Big).$
We minimize it with respect to parameterized variational
families $q(z, \\beta; \lambda)$.
$r^*(x_n, z_n, \\beta)$ is a function of a single data point
$x_n$, single local variable $z_n$, and all global
variables $\\beta$. It is equal to the log-ratio
$\log p(x_n, z_n\mid \\beta) - \log q(x_n, z_n\mid \\beta),$
where $q(x_n)$ is the empirical data distribution. Rather
than explicit calculation, $r^*(x, z, \\beta)$ is the
solution to a ratio estimation problem, minimizing the specified
`ratio_loss`.
Gradients are taken using the reparameterization trick
[@kingma2014auto].
#### Notes
This also includes model parameters $p(x, z, \\beta; \\theta)$
and variational distributions with inference networks
$q(z\mid x)$.
There are a bunch of extensions we could easily do in this
implementation:
+ further factorizations can be used to better leverage the
graph structure for more complicated models;
+ score function gradients for global variables;
+ use more samples; this would require the `copy()` utility
function for q's as well, and an additional loop. we opt not to
because it complicates the code;
+ analytic KL/swapping out the penalty term for the globals.
"""
# Collect tensors used in calculation of losses.
scope = tf.get_default_graph().unique_name("inference")
qbeta_sample = {}
pbeta_log_prob = 0.0
qbeta_log_prob = 0.0
for beta, qbeta in six.iteritems(self.global_vars):
# Draw a sample beta' ~ q(beta) and calculate
# log p(beta') and log q(beta').
qbeta_sample[beta] = qbeta.value()
pbeta_log_prob += tf.reduce_sum(beta.log_prob(qbeta_sample[beta]))
qbeta_log_prob += tf.reduce_sum(qbeta.log_prob(qbeta_sample[beta]))
pz_sample = {}
qz_sample = {}
for z, qz in six.iteritems(self.latent_vars):
if z not in self.global_vars:
# Copy local variables p(z), q(z) to draw samples
# z' ~ p(z | beta'), z' ~ q(z | beta').
pz_copy = copy(z, dict_swap=qbeta_sample, scope=scope)
pz_sample[z] = pz_copy.value()
qz_sample[z] = qz.value()
# Collect x' ~ p(x | z', beta') and x' ~ q(x).
dict_swap = qbeta_sample.copy()
dict_swap.update(qz_sample)
x_psample = {}
x_qsample = {}
for x, x_data in six.iteritems(self.data):
if isinstance(x, tf.Tensor):
if "Placeholder" not in x.op.type:
# Copy p(x | z, beta) to get draw p(x | z', beta').
x_copy = copy(x, dict_swap=dict_swap, scope=scope)
x_psample[x] = x_copy
x_qsample[x] = x_data
elif isinstance(x, RandomVariable):
# Copy p(x | z, beta) to get draw p(x | z', beta').
x_copy = copy(x, dict_swap=dict_swap, scope=scope)
x_psample[x] = x_copy.value()
x_qsample[x] = x_data
with tf.variable_scope("Disc"):
r_psample = self.discriminator(x_psample, pz_sample, qbeta_sample)
with tf.variable_scope("Disc", reuse=True):
r_qsample = self.discriminator(x_qsample, qz_sample, qbeta_sample)
# Form ratio loss and ratio estimator.
if len(self.scale) <= 1:
loss_d = tf.reduce_mean(self.ratio_loss(r_psample, r_qsample))
scale = list(six.itervalues(self.scale))
scale = scale[0] if scale else 1.0
scaled_ratio = tf.reduce_sum(scale * r_qsample)
else:
loss_d = [
tf.reduce_mean(self.ratio_loss(r_psample[key], r_qsample[key]))
for key in six.iterkeys(self.scale)
]
loss_d = tf.reduce_sum(loss_d)
scaled_ratio = [
tf.reduce_sum(self.scale[key] * r_qsample[key])
for key in six.iterkeys(self.scale)
]
scaled_ratio = tf.reduce_sum(scaled_ratio)
# Form variational objective.
loss = -(pbeta_log_prob - qbeta_log_prob + scaled_ratio)
var_list_d = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope="Disc")
if var_list is None:
var_list = [
v for v in tf.trainable_variables() if v not in var_list_d
]
grads = tf.gradients(loss, var_list)
grads_d = tf.gradients(loss_d, var_list_d)
grads_and_vars = list(zip(grads, var_list))
grads_and_vars_d = list(zip(grads_d, var_list_d))
return loss, grads_and_vars, loss_d, grads_and_vars_d
impute_finished=True)
training_logits = training_decoder_outputs.rnn_output
softmax_cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=y_true_output, logits=training_logits)
# l2_loss = 0.01 * tf.add_n([tf.nn.l2_loss(v)
# for v in tf.trainable_variables() if 'bias' not in v.name])
# loss = tf.reduce_mean(softmax_cross_entropy) + l2_loss
loss = tf.reduce_mean(softmax_cross_entropy)
optimizer = tf.train.AdamOptimizer(learning_rate)
if clipping > 0:
trainable_variables = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(loss, trainable_variables),
clipping)
optimizer = optimizer.apply_gradients(zip(grads, trainable_variables))
else:
optimizer = optimizer.minimize(loss)
if beam_search:
y_start_tokens = tf.fill([batch_sizzzz], hindi_vocab.index("<START>"))
y_end_token = hindi_vocab.index("<STOP>")
inference_decoder = tf.contrib.seq2seq.BeamSearchDecoder(
decoder_LSTMCell, decoder_input_embedding_mat, y_start_tokens,
y_end_token, decoder_initial_state, beam_width,
decoder_output_to_hindi_vocab)
inference_decoder_outputs, _, _ = tf.contrib.seq2seq.dynamic_decode(
inference_decoder,
def __init__(self,
vocab_size,
label_size,
size,
num_layers,
batch_size,
learning_rate,
learning_rate_decay_factor,
dropout,
embedding,
src_steps,
tgt_steps,
mode='sq2sq',
max_gradient_norm=5.0,
forward_only=False):
self.size = size
self.mode = mode
self.vocab_size = vocab_size
self.label_size = label_size
self.embedding = embedding
self.src_steps = src_steps
self.tgt_steps = tgt_steps
self.batch_size = batch_size
self.num_layers = num_layers
self.keep_prob = 1.0 - dropout
self.learning_rate = tf.Variable(float(learning_rate), trainable=False)
self.learning_rate_decay_op = self.learning_rate.assign(
self.learning_rate * learning_rate_decay_factor)
self.global_step = tf.Variable(0, trainable=False)
self.source_tokens = tf.placeholder(tf.int32,
shape=[None, self.src_steps],
name='srcInput')
self.target_tokens = tf.placeholder(tf.int32,
shape=[None, self.tgt_steps],
name='targetInput')
self.label_placeholder = tf.placeholder(tf.float32,
shape=[None, self.label_size])
self.decoder_state_input, self.decoder_state_output = [], []
self.tgt_encoder_state_input, self.tgt_encoder_state_output = [], []
for i in xrange(num_layers):
self.decoder_state_input.append(
tf.placeholder(tf.float32, shape=[None, size]))
self.tgt_encoder_state_input.append(
tf.placeholder(tf.float32, shape=[None, size]))
self.setup_embeddings()
self.setup_encoder()
self.setup_decoder()
if mode == 'sq2sq':
self.setup_label_loss()
else:
raise NotImplementedError
params = tf.trainable_variables()
if not forward_only:
opt = tf.train.AdamOptimizer(self.learning_rate)
gradients = tf.gradients(self.losses, params)
clipped_gradients, _ = tf.clip_by_global_norm(
gradients, max_gradient_norm)
self.gradient_norm = tf.global_norm(clipped_gradients)
self.param_norm = tf.global_norm(params)
self.updates = opt.apply_gradients(zip(clipped_gradients, params),
global_step=self.global_step)
self.saver = tf.train.Saver(tf.all_variables())
def train(self,
dataset_path,
list_files,
epochs,
mode_save_path,
learning_rate=0.01,
l1_rate=0.001,
penalty_rate=10,
save_index=1,
restore_index=1):
tf.reset_default_graph()
input = tf.placeholder(tf.float32,
shape=(None, self.image_shape[0],
self.image_shape[1], 1),
name='input')
condition = tf.placeholder(tf.float32,
shape=(None, self.image_shape[0],
self.image_shape[1], 3),
name='condition')
target = tf.placeholder(tf.float32,
shape=(None, self.image_shape[0],
self.image_shape[1], 3),
name='output')
is_training = tf.placeholder(tf.bool, name='is_training')
random_e = tf.placeholder(tf.float32,
shape=[None, 1, 1, 1],
name='random_e')
g_logits = self.generator(input, condition, is_training)
tf.add_to_collection('g_logits', g_logits)
d_logits_real = self.discriminator(target, condition, reuse=False)
d_logits_fake = self.discriminator(g_logits, condition, reuse=True)
tf.add_to_collection('d_logits_real', d_logits_real)
tf.add_to_collection('d_logits_fake', d_logits_fake)
eps = 1e-16
l1_loss = tf.reduce_mean(
tf.reduce_sum(tf.abs(g_logits - target), axis=[1, 2, 3]))
g_loss = -tf.reduce_mean(d_logits_fake) + l1_rate * l1_loss
x_hat = random_e * target + (1 - random_e) * g_logits
d_logits_xhat = self.discriminator(x_hat, condition, reuse=True)
grads = tf.gradients(d_logits_xhat, [x_hat])[0]
penalty = tf.reduce_mean(
tf.square(
tf.sqrt(tf.reduce_sum(tf.square(grads), axis=[1, 2, 3]) +
eps) - 1))
d_loss = tf.reduce_mean(d_logits_fake -
d_logits_real) + penalty_rate * penalty
# tf.summary.scalar('g_loss', g_loss)
# tf.summary.scalar('d_loss', d_loss)
bn_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
bn_ops_g = [var for var in bn_ops if var.name.startswith('generator')]
bn_ops_d = [
var for var in bn_ops if var.name.startswith('discriminator')
]
var_g = [
var for var in tf.trainable_variables()
if var.name.startswith('generator')
]
var_d = [
var for var in tf.trainable_variables()
if var.name.startswith('discriminator')
]
with tf.control_dependencies(bn_ops_g):
g_optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(g_loss, var_list=var_g)
with tf.control_dependencies(bn_ops_d):
d_optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(d_loss, var_list=var_d)
data_parser = DataParserV2(dataset_path,
self.image_shape,
list_files=list_files,
batch_size=self.batch_size)
# data_parser_test = DataParserV2(dataset_path, self.image_shape, list_files=['../dataset/image_list_8.txt'],
# batch_size=20)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
losses = []
losses_epoch = []
# test_input = data_parser_test.get_batch_sketch()
# test_target = data_parser_test.get_batch_raw()
# test_condition = data_parser_test.get_batch_condition_add()
# test = {'input': test_input, 'target': test_target, 'condition': test_condition}
# np.save('./results/test_data_{}.npy'.format(save_index), test)
test = np.load(
'./results/test_data_{}.npy'.format(restore_index)).item()
outputs = []
model_dir = os.path.join(mode_save_path, 'unet{}'.format(save_index))
try:
os.makedirs(model_dir)
except FileExistsError as e:
print(e)
var_list = tf.trainable_variables('generator')
# bn_var = [var for var in tf.global_variables('generator') if 'moving_mean' in var.name]
# bn_var += [var for var in tf.global_variables('generator') if 'moving_variance' in var.name]
# var_list += bn_var
saver = tf.train.Saver(var_list)
saver_model = tf.train.Saver(max_to_keep=100)
run_options = tf.RunOptions(report_tensor_allocations_upon_oom=True)
# init_var = [var for var in tf.global_variables() if 'generator' not in var.name]
# for var in tf.global_variables():
# print(var)
with tf.Session(config=config) as sess:
# writer = tf.summary.FileWriter('./logs/train', sess.graph)
# writer_val = tf.summary.FileWriter('./logs/val')
# merged = tf.summary.merge_all()
sess.run(tf.global_variables_initializer())
saver.restore(sess, './checkpoints/unet_simple27/model-100.ckpt')
for epoch in range(epochs):
loss_g = 0
loss_d = 0
i_d = 1
i_g = 1
for i in range(data_parser.iteration):
batch_input = data_parser.get_batch_sketch()
batch_target = data_parser.get_batch_raw()
batch_condition = data_parser.get_batch_condition_add()
data_parser.update_iterator()
for _ in range(i_d):
e = np.random.uniform(0, 1,
[batch_target.shape[0], 1, 1, 1])
_, loss_d = sess.run(
[d_optimizer, d_loss],
feed_dict={
input: batch_input,
condition: batch_condition,
target: batch_target,
random_e: e,
is_training: True
},
options=run_options)
for _ in range(i_g):
_, loss_g, loss_l1 = sess.run(
[g_optimizer, g_loss, l1_loss],
feed_dict={
input: batch_input,
condition: batch_condition,
target: batch_target,
is_training: True
},
options=run_options)
e = np.random.uniform(0, 1, [20, 1, 1, 1])
loss_d_val, loss_g_val, loss_l1_val = sess.run(
[d_loss, g_loss, l1_loss],
feed_dict={
input: test['input'],
condition: test['condition'],
target: test['target'],
random_e: e,
is_training: False
})
losses.append(
[loss_d, loss_g, loss_d_val, loss_g_val, loss_l1])
losses_epoch.append(
[loss_d, loss_g, loss_d_val, loss_g_val, loss_l1_val])
if i % 10 == 0:
print(
'Epoch: {}, Iteration: {}/{}, g_loss: {}, d_loss: {}, l1:loss: {},'
' g_loss_val: {}, d_loss_val: {}, l1_loss_val: {}'.
format(epoch + 1, i + 1, data_parser.iteration,
loss_g, loss_d, loss_l1, loss_g_val,
loss_d_val, loss_l1_val))
print('*' * 10, 'Epoch {}/{} ...'.format(epoch + 1, epochs),
'g_loss: {:.4f} ...'.format(loss_g),
'd_loss: {:.4f} ...'.format(loss_d),
'g_loss_val: {:.4f} ...'.format(loss_g_val),
'd_loss_val: {:.4f} ...'.format(loss_d_val),
'l1_loss: {:.4f} ...'.format(loss_l1),
'l1_loss_val: {:.4f} ...'.format(loss_l1_val), '*' * 10)
if (epoch + 1) % 10 == 0:
print('*' * 10, 'save results', '*' * 10)
output = sess.run(g_logits,
feed_dict={
input: test['input'],
condition: test['condition'],
target: test['target'],
is_training: False
})
np.save(
'./results/predicted_pre_{}-{}.npy'.format(
save_index, epoch + 1), np.asarray(output))
np.save(
'./logs/train/losses_{}-{}.npy'.format(
save_index, epoch + 1), losses_epoch)
losses_epoch = []
print('*' * 10, 'save model', '*' * 10)
saver_model.save(
sess,
os.path.join(model_dir,
'checkpoint-{}.ckpt'.format(epoch + 1)))
np.save('./results/predicted_{}.npy'.format(save_index),
np.asarray(outputs))
return losses
with tf.name_scope("SoftMax") as scope:
regularizers = (tf.nn.l2_loss(W_conv1) + tf.nn.l2_loss(b_conv1) +
tf.nn.l2_loss(W_conv2) + tf.nn.l2_loss(b_conv2) +
tf.nn.l2_loss(W_conv3) + tf.nn.l2_loss(b_conv3) +
tf.nn.l2_loss(W_fc1) + tf.nn.l2_loss(b_fc1) +
tf.nn.l2_loss(W_fc2) + tf.nn.l2_loss(b_fc2))
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=h_fc2,labels=y_)
cost = tf.reduce_sum(loss) / batch_size
cost += regularization*regularizers
# define train optimizer
with tf.name_scope("train") as scope:
tvars = tf.trainable_variables()
#We clip the gradients to prevent explosion
grads = tf.gradients(cost, tvars)
optimizer = tf.train.AdamOptimizer(learning_rate)
gradients = zip(grads, tvars)
train_step = optimizer.apply_gradients(gradients)
numel = tf.constant([[0]])
for gradient, variable in gradients:
if isinstance(gradient, ops.IndexedSlices):
grad_values = gradient.values
else:
grad_values = gradient
numel +=tf.reduce_sum(tf.size(variable))
with tf.name_scope("Evaluating_accuracy") as scope:
correct_prediction = tf.equal(tf.argmax(h_fc2,1), y_)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
def init_network(self):
"""
[input]
self.obs
self.action_n
self.advant
self.old_dist_means_n
self.old_dist_logstds_n
[output]
self.action_dist_means_n
self.action_dist_logstds_n
var_list
"""
self.net = NetworkContinousImage("network_continous")
if pms.min_std is not None:
log_std_var = tf.maximum(self.net.action_dist_logstds_n,
np.log(pms.min_std))
self.action_dist_stds_n = tf.exp(log_std_var)
self.old_dist_info_vars = dict(mean=self.net.old_dist_means_n,
log_std=self.net.old_dist_logstds_n)
self.new_dist_info_vars = dict(mean=self.net.action_dist_means_n,
log_std=self.net.action_dist_logstds_n)
self.likehood_action_dist = self.distribution.log_likelihood_sym(
self.net.action_n, self.new_dist_info_vars)
self.ratio_n = self.distribution.likelihood_ratio_sym(
self.net.action_n, self.new_dist_info_vars,
self.old_dist_info_vars)
surr = -tf.reduce_mean(
self.ratio_n * self.net.advant) # Surrogate loss
batch_size = tf.shape(self.net.obs)[0]
batch_size_float = tf.cast(batch_size, tf.float32)
kl = tf.reduce_mean(
self.distribution.kl_sym(self.old_dist_info_vars,
self.new_dist_info_vars))
ent = self.distribution.entropy(self.old_dist_info_vars)
# ent = tf.reduce_sum(-p_n * tf.log(p_n + eps)) / Nf
self.losses = [surr, kl, ent]
var_list = self.net.var_list
self.gf = GetFlat(var_list) # get theta from var_list
self.gf.session = self.session
self.sff = SetFromFlat(var_list) # set theta from var_List
self.sff.session = self.session
# get g
self.pg = flatgrad(surr, var_list)
# get A
# KL divergence where first arg is fixed
# replace old->tf.stop_gradient from previous kl
kl_firstfixed = self.distribution.kl_sym_firstfixed(
self.new_dist_info_vars) / batch_size_float
grads = tf.gradients(kl_firstfixed, var_list)
self.flat_tangent = tf.placeholder(dtype, shape=[None])
shapes = map(var_shape, var_list)
start = 0
tangents = []
for shape in shapes:
size = np.prod(shape)
param = tf.reshape(self.flat_tangent[start:(start + size)], shape)
tangents.append(param)
start += size
self.gvp = [tf.reduce_sum(g * t) for (g, t) in zip(grads, tangents)]
self.fvp = flatgrad(tf.reduce_sum(self.gvp), var_list) # get kl''*p
self.session.run(tf.initialize_all_variables())
def main(argv=None): # pylint: disable=unused-argument
data_dir = 'data/training/'
train_data_filename = data_dir + 'images/'
train_labels_filename = data_dir + 'groundtruth/'
# Extract it into numpy arrays.
train_data = extract_data(train_data_filename, TRAINING_SIZE)
train_labels = extract_labels(train_labels_filename, TRAINING_SIZE)
num_epochs = NUM_EPOCHS
c0 = 0
c1 = 0
for i in range(len(train_labels)):
if train_labels[i][0] == 1:
c0 = c0 + 1
else:
c1 = c1 + 1
print('Number of data points per class: c0 = ' + str(c0) + ' c1 = ' +
str(c1))
print('Balancing training data...')
min_c = min(c0, c1)
idx0 = [i for i, j in enumerate(train_labels) if j[0] == 1]
idx1 = [i for i, j in enumerate(train_labels) if j[1] == 1]
new_indices = idx0[0:min_c] + idx1[0:min_c]
print(len(new_indices))
print(train_data.shape)
train_data = train_data[new_indices, :, :, :]
train_labels = train_labels[new_indices]
train_size = train_labels.shape[0]
c0 = 0
c1 = 0
for i in range(len(train_labels)):
if train_labels[i][0] == 1:
c0 = c0 + 1
else:
c1 = c1 + 1
print('Number of data points per class: c0 = ' + str(c0) + ' c1 = ' +
str(c1))
# This is where training samples and labels are fed to the graph.
# These placeholder nodes will be fed a batch of training data at each
# training step using the {feed_dict} argument to the Run() call below.
train_data_node = tf.placeholder(tf.float32,
shape=(BATCH_SIZE, IMG_PATCH_SIZE,
IMG_PATCH_SIZE, NUM_CHANNELS))
train_labels_node = tf.placeholder(tf.float32,
shape=(BATCH_SIZE, NUM_LABELS))
train_all_data_node = tf.constant(train_data)
# The variables below hold all the trainable weights. They are passed an
# initial value which will be assigned when when we call:
# {tf.initialize_all_variables().run()}
conv1_weights = tf.Variable(
tf.truncated_normal(
[5, 5, NUM_CHANNELS, 32], # 5x5 filter, depth 32.
stddev=0.1,
seed=SEED))
conv1_biases = tf.Variable(tf.zeros([32]))
conv2_weights = tf.Variable(
tf.truncated_normal([5, 5, 32, 64], stddev=0.1, seed=SEED))
conv2_biases = tf.Variable(tf.constant(0.1, shape=[64]))
fc1_weights = tf.Variable( # fully connected, depth 512.
tf.truncated_normal(
[int(IMG_PATCH_SIZE / 4 * IMG_PATCH_SIZE / 4 * 64), 512],
stddev=0.1,
seed=SEED))
fc1_biases = tf.Variable(tf.constant(0.1, shape=[512]))
fc2_weights = tf.Variable(
tf.truncated_normal([512, NUM_LABELS], stddev=0.1, seed=SEED))
fc2_biases = tf.Variable(tf.constant(0.1, shape=[NUM_LABELS]))
# Make an image summary for 4d tensor image with index idx
def get_image_summary(img, idx=0):
V = tf.slice(img, (0, 0, 0, idx), (1, -1, -1, 1))
img_w = img.get_shape().as_list()[1]
img_h = img.get_shape().as_list()[2]
min_value = tf.reduce_min(V)
V = V - min_value
max_value = tf.reduce_max(V)
V = V / (max_value * PIXEL_DEPTH)
V = tf.reshape(V, (img_w, img_h, 1))
V = tf.transpose(V, (2, 0, 1))
V = tf.reshape(V, (-1, img_w, img_h, 1))
return V
# Make an image summary for 3d tensor image with index idx
def get_image_summary_3d(img):
V = tf.slice(img, (0, 0, 0), (1, -1, -1))
img_w = img.get_shape().as_list()[1]
img_h = img.get_shape().as_list()[2]
V = tf.reshape(V, (img_w, img_h, 1))
V = tf.transpose(V, (2, 0, 1))
V = tf.reshape(V, (-1, img_w, img_h, 1))
return V
# Get prediction for given input image
def get_prediction(img):
data = numpy.asarray(img_crop(img, IMG_PATCH_SIZE, IMG_PATCH_SIZE))
data_node = tf.constant(data)
output = tf.nn.softmax(model(data_node))
output_prediction = s.run(output)
img_prediction = label_to_img(img.shape[0], img.shape[1],
IMG_PATCH_SIZE, IMG_PATCH_SIZE,
output_prediction)
return img_prediction
# Get a concatenation of the prediction and groundtruth for given input file
def get_prediction_with_groundtruth(filename, image_idx):
imageid = "satImage_%.3d" % image_idx
image_filename = filename + imageid + ".png"
img = mpimg.imread(image_filename)
img_prediction = get_prediction(img)
cimg = concatenate_images(img, img_prediction)
return cimg
# Get prediction overlaid on the original image for given input file
def get_prediction_with_overlay(filename, image_idx):
imageid = "satImage_%.3d" % image_idx
image_filename = filename + imageid + ".png"
img = mpimg.imread(image_filename)
img_prediction = get_prediction(img)
oimg = make_img_overlay(img, img_prediction)
return oimg
# We will replicate the model structure for the training subgraph, as well
# as the evaluation subgraphs, while sharing the trainable parameters.
def model(data, train=False):
"""The Model definition."""
# 2D convolution, with 'SAME' padding (i.e. the output feature map has
# the same size as the input). Note that {strides} is a 4D array whose
# shape matches the data layout: [image index, y, x, depth].
conv = tf.nn.conv2d(data,
conv1_weights,
strides=[1, 1, 1, 1],
padding='SAME')
# Bias and rectified linear non-linearity.
relu = tf.nn.relu(tf.nn.bias_add(conv, conv1_biases))
# Max pooling. The kernel size spec {ksize} also follows the layout of
# the data. Here we have a pooling window of 2, and a stride of 2.
pool = tf.nn.max_pool(relu,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
conv2 = tf.nn.conv2d(pool,
conv2_weights,
strides=[1, 1, 1, 1],
padding='SAME')
relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases))
pool2 = tf.nn.max_pool(relu2,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
# Uncomment these lines to check the size of each layer
# print 'data ' + str(data.get_shape())
# print 'conv ' + str(conv.get_shape())
# print 'relu ' + str(relu.get_shape())
# print 'pool ' + str(pool.get_shape())
# print 'pool2 ' + str(pool2.get_shape())
# Reshape the feature map cuboid into a 2D matrix to feed it to the
# fully connected layers.
pool_shape = pool2.get_shape().as_list()
reshape = tf.reshape(
pool2,
[pool_shape[0], pool_shape[1] * pool_shape[2] * pool_shape[3]])
# Fully connected layer. Note that the '+' operation automatically
# broadcasts the biases.
hidden = tf.nn.relu(tf.matmul(reshape, fc1_weights) + fc1_biases)
# Add a 50% dropout during training only. Dropout also scales
# activations such that no rescaling is needed at evaluation time.
#if train:
# hidden = tf.nn.dropout(hidden, 0.5, seed=SEED)
out = tf.matmul(hidden, fc2_weights) + fc2_biases
if train == True:
summary_id = '_0'
s_data = get_image_summary(data)
filter_summary0 = tf.summary.image('summary_data' + summary_id,
s_data)
s_conv = get_image_summary(conv)
filter_summary2 = tf.summary.image('summary_conv' + summary_id,
s_conv)
s_pool = get_image_summary(pool)
filter_summary3 = tf.summary.image('summary_pool' + summary_id,
s_pool)
s_conv2 = get_image_summary(conv2)
filter_summary4 = tf.summary.image('summary_conv2' + summary_id,
s_conv2)
s_pool2 = get_image_summary(pool2)
filter_summary5 = tf.summary.image('summary_pool2' + summary_id,
s_pool2)
return out
# Training computation: logits + cross-entropy loss.
logits = model(train_data_node, True) # BATCH_SIZE*NUM_LABELS
# print 'logits = ' + str(logits.get_shape()) + ' train_labels_node = ' + str(train_labels_node.get_shape())
loss_pure = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=logits,
labels=train_labels_node))
tf.summary.scalar('loss', loss_pure)
all_params_node = [
conv1_weights, conv1_biases, conv2_weights, conv2_biases, fc1_weights,
fc1_biases, fc2_weights, fc2_biases
]
all_params_names = [
'conv1_weights', 'conv1_biases', 'conv2_weights', 'conv2_biases',
'fc1_weights', 'fc1_biases', 'fc2_weights', 'fc2_biases'
]
all_grads_node = tf.gradients(loss_pure, all_params_node)
all_grad_norms_node = []
for i in range(0, len(all_grads_node)):
norm_grad_i = tf.global_norm([all_grads_node[i]])
all_grad_norms_node.append(norm_grad_i)
tf.summary.scalar(all_params_names[i], norm_grad_i)
# L2 regularization for the fully connected parameters.
regularizers = (tf.nn.l2_loss(fc1_weights) + tf.nn.l2_loss(fc1_biases) +
tf.nn.l2_loss(fc2_weights) + tf.nn.l2_loss(fc2_biases))
# Add the regularization term to the loss.
loss = loss_pure + 5e-4 * regularizers
# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
batch = tf.Variable(0)
# Decay once per epoch, using an exponential schedule starting at 0.01.
learning_rate = tf.train.exponential_decay(
0.01, # Base learning rate.
batch * BATCH_SIZE, # Current index into the dataset.
train_size, # Decay step.
0.95, # Decay rate.
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Use simple momentum for the optimization.
optimizer = tf.train.MomentumOptimizer(learning_rate,
0.0).minimize(loss,
global_step=batch)
# Predictions for the minibatch, validation set and test set.
train_prediction = tf.nn.softmax(logits)
# We'll compute them only once in a while by calling their {eval()} method.
train_all_prediction = tf.nn.softmax(model(train_all_data_node))
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
# Create a local session to run this computation.
with tf.Session() as s:
if RESTORE_MODEL:
# Restore variables from disk.
saver.restore(s, FLAGS.train_dir + "/model.ckpt")
print("Model restored.")
else:
# Run all the initializers to prepare the trainable parameters.
tf.global_variables_initializer().run()
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
graph=s.graph)
print('Initialized!')
# Loop through training steps.
print('Total number of iterations = ' +
str(int(num_epochs * train_size / BATCH_SIZE)))
training_indices = range(train_size)
train_start = time.time()
loss_graph_data = []
it_num = 0
for iepoch in range(num_epochs):
# Permute training indices
perm_indices = numpy.random.permutation(training_indices)
for step in range(int(train_size / BATCH_SIZE)):
it_num += 1
offset = (step * BATCH_SIZE) % (train_size - BATCH_SIZE)
batch_indices = perm_indices[offset:(offset + BATCH_SIZE)]
# Compute the offset of the current minibatch in the data.
# Note that we could use better randomization across epochs.
batch_data = train_data[batch_indices, :, :, :]
batch_labels = train_labels[batch_indices]
# This dictionary maps the batch data (as a numpy array) to the
# node in the graph is should be fed to.
feed_dict = {
train_data_node: batch_data,
train_labels_node: batch_labels
}
#if step % RECORDING_STEP == 0:
#
# summary_str, _, l, lr, predictions = s.run(
# [summary_op, optimizer, loss, learning_rate, train_prediction],
# feed_dict=feed_dict)
# #summary_str = s.run(summary_op, feed_dict=feed_dict)
# summary_writer.add_summary(summary_str, step)
# summary_writer.flush()
#
# # print_predictions(predictions, batch_labels)
#
# print ('Epoch %.2f' % (float(step) * BATCH_SIZE / train_size))
# print ('Minibatch loss: %.3f, learning rate: %.6f' % (l, lr))
# print ('Minibatch error: %.1f%%' % error_rate(predictions,
# batch_labels))
#
# sys.stdout.flush()
#else:
# Run the graph and fetch some of the nodes.
_, l, lr, predictions = s.run([
optimizer, loss_pure, learning_rate, train_prediction
],
feed_dict=feed_dict)
loss_graph_data.append([time.time() - train_start, l])
print(
"Iter %d of %d. Loss: %f" %
(it_num, int(num_epochs * train_size / BATCH_SIZE), l))
# Save the variables to disk.
#save_path = saver.save(s, FLAGS.train_dir + "/model.ckpt")
#print("Model saved in file: %s, " % (save_path))
print("Training took %.2d:%.2d:%.2d" %
readable_time(time.time() - train_start))
numpy.save("baseline_time_loss_data.npy", loss_graph_data)
print("Running prediction on training set")
prediction_training_dir = "predictions_training/"
if not os.path.isdir(prediction_training_dir):
os.mkdir(prediction_training_dir)
for i in range(1, TRAINING_SIZE + 1):
pimg = get_prediction_with_groundtruth(train_data_filename, i)
Image.fromarray(pimg).save(prediction_training_dir +
"prediction_" + str(i) + ".png")
oimg = get_prediction_with_overlay(train_data_filename, i)
oimg.save(prediction_training_dir + "overlay_" + str(i) + ".png")
score = model.fc8
# List of trainable variables of the layers we want to train
var_list = [
v for v in tf.trainable_variables() if v.name.split('/')[0] in train_layers
]
# Op for calculating the loss
with tf.name_scope("cross_ent"):
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=score, labels=y))
# Train op
with tf.name_scope("train"):
# Get gradients of all trainable variables
gradients = tf.gradients(loss, var_list)
gradients = list(zip(gradients, var_list))
# Create optimizer and apply gradient descent to the trainable variables
# optimizer = tf.train.GradientDescentOptimizer(learning_rate)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.apply_gradients(grads_and_vars=gradients)
# Add gradients to summary
for gradient, var in gradients:
tf.summary.histogram(var.name + '/gradient', gradient)
# Add the variables we train to the summary
for var in var_list:
tf.summary.histogram(var.name, var)
def __init__(self,
vocabulary_size,
batch_size,
embedding_matrix,
x_length=None,
is_training=True):
self.X_length = x_length
self.keep_prob = config.keep_prob
#self.batch_size=tf.Variable(0,dtype=tf.int32,trainable=False)
self.batch_size = batch_size
num_step = config.MAX_SEQUENCE_LENGTH
self.input_data = tf.placeholder(tf.int64, [None, num_step],
name="input_data")
self.target = tf.placeholder(tf.int64, [None, config.class_num],
name="label")
#self.mask_x = tf.placeholder(tf.float64,[num_step,None])
class_num = config.class_num
hidden_neural_size = config.hidden_neural_size
vocabulary_size = vocabulary_size
embed_dim = config.EMBEDDING_DIM
hidden_layer_num = config.hidden_layer_num
#self.new_batch_size = tf.placeholder(tf.int32,shape=[],name="new_batch_size")
#self._batch_size_update = tf.assign(self.batch_size,self.new_batch_size)
#build LSTM network
lstm_cell = tf.contrib.rnn.BasicLSTMCell(hidden_neural_size,
forget_bias=0.0,
state_is_tuple=True)
if self.keep_prob < 1:
lstm_cell = tf.contrib.rnn.DropoutWrapper(
lstm_cell, output_keep_prob=self.keep_prob)
cell = tf.contrib.rnn.MultiRNNCell([lstm_cell] * hidden_layer_num,
state_is_tuple=True)
"""
#双向LSTM
cell = tf.contrib.rnn.static_bidirectional_rnn([lstm_cell]*hidden_layer_num,
state_is_tuple=True)
#动态LSTM
cell = tf.nn.dynamic_rnn(
cell = lstm_cell,
dtype = tf.float64,
sequence_length = self.X_length
)
"""
self._initial_state = cell.zero_state(tf.shape(self.input_data)[0],
dtype=tf.float64)
#构建网络
#embedding layer
with tf.name_scope("embedding_layer"):
#embedding = tf.get_variable("embedding",[vocabulary_size,embed_dim],dtype=tf.float64)
self.embedding = tf.Variable(
tf.convert_to_tensor(embedding_matrix),
name="embedding_matrix",
trainable=False,
dtype=tf.float64,
expected_shape=[vocabulary_size, embed_dim])
inputs = tf.nn.embedding_lookup(self.embedding, self.input_data)
if self.keep_prob < 1:
inputs = tf.nn.dropout(inputs, self.keep_prob)
#out_put=[]
state = self._initial_state
with tf.variable_scope("LSTM_layer"):
for time_step in range(num_step):
if time_step > 0: tf.get_variable_scope().reuse_variables()
(cell_output, state) = cell(inputs[:, time_step, :], state)
#out_put.append(cell_output)
out_put = cell_output
#out_put=out_put*self.mask_x[:,:,None]
#with tf.name_scope("mean_pooling_layer"):
# out_put=tf.reduce_sum(out_put,0)/(tf.reduce_sum(self.mask_x,0)[:,None])
with tf.name_scope("Softmax_layer_and_output"):
softmax_w = tf.get_variable("softmax_w",
[hidden_neural_size, class_num],
dtype=tf.float64)
softmax_b = tf.get_variable("softmax_b", [class_num],
dtype=tf.float64)
self.logits = tf.nn.sigmoid(
tf.matmul(out_put, softmax_w) + softmax_b)
with tf.name_scope("loss"):
self.loss = tf.nn.softmax_cross_entropy_with_logits(
logits=self.logits, labels=self.target)
self.cost = tf.reduce_mean(self.loss)
with tf.name_scope("accuracy"):
self.prediction = tf.argmax(self.logits, 1)
correct_prediction = tf.equal(self.prediction,
tf.argmax(self.target, 1))
self.correct_num = tf.reduce_sum(
tf.cast(correct_prediction, tf.float64))
self.accuracy = tf.reduce_mean(tf.cast(correct_prediction,
tf.float64),
name="accuracy")
#add summary
loss_summary = tf.summary.scalar("loss", self.cost)
#add summary
accuracy_summary = tf.summary.scalar("accuracy_summary", self.accuracy)
if not is_training:
return
self.globle_step = tf.Variable(0, name="globle_step", trainable=False)
self.lr = tf.Variable(0.0, trainable=False)
tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, tvars),
config.max_grad_norm)
# Keep track of gradient values and sparsity (optional)
grad_summaries = []
for g, v in zip(grads, tvars):
if g is not None:
grad_hist_summary = tf.summary.histogram(
"{}/grad/hist".format(v.name), g)
sparsity_summary = tf.summary.scalar(
"{}/grad/sparsity".format(v.name), tf.nn.zero_fraction(g))
grad_summaries.append(grad_hist_summary)
grad_summaries.append(sparsity_summary)
self.grad_summaries_merged = tf.summary.merge(grad_summaries)
self.summary = tf.summary.merge(
[loss_summary, accuracy_summary, self.grad_summaries_merged])
#optimizer = tf.train.GradientDescentOptimizer(self.loss)
optimizer = tf.train.AdamOptimizer(learning_rate=config.learning_rate)
# optimizer = tf.train.GradientDescentOptimizer(0.5)
#optimizer.apply_gradients(zip(grads, tvars))
self.train_op = optimizer.apply_gradients(zip(grads, tvars))
def __init__(self, M, L, A, labels_train, labels_test, labels_val, testing_set_mask, training_set_mask,validation_set_mask,
n_conv_feat=32, dropout=0.98,
learning_rate=0.01, l2_regu=0.00001, nb_layers=5, idx_gpu = '/gpu:1'):
"""
Neural network architecture. Output classification result for each row of M.
Inputs:
M: initial matrix with all the known values,
A : adjacency matrices, respectively for the age, sex and age and sex graphs,
L: laplacian matrices, respectively for the age, sex and age and sex graphs,
labels_train, labels_test, labels_val: labels for each set for every subject,
training_set_mask, testing_set_mask, validation_set_mask: indexes of subjects that respectively belong to the training, testing and validation sets,
n_conv_feat: number of weights to use for the GCNN layer. Default value = 36,
l2_regu: coefficient to use in front of the l2 regularization term. Default value = 1,
dropout: dropout rate on the GCN output. Default = 0.5,
learning_rate: learning rate. Default value = 0.001,
nb_layers: number of GCNN layers. Default value: 5
"""
self.n_conv_feat = n_conv_feat
with tf.Graph().as_default() as g:
tf.logging.set_verbosity(tf.logging.ERROR)
self.graph = g
tf.set_random_seed(0)
with tf.device(idx_gpu):
#definition of constant matrices
self.A=tf.constant(A, dtype=tf.float32)
self.M = tf.constant(M, dtype=tf.float32)
self.labels_train=tf.constant(labels_train, dtype=tf.float32)
self.labels_test=tf.constant(labels_test, dtype=tf.float32)
self.labels_val=tf.constant(labels_val, dtype=tf.float32)
self.testing_mask=tf.constant(testing_set_mask, dtype=tf.float32)
self.training_mask=tf.constant(training_set_mask, dtype=tf.float32)
self.validation_mask=tf.constant(validation_set_mask, dtype=tf.float32)
##################################definition of the NN variables#####################################
#definition of the weights for extracting the global features
weights=[]
bias=[]
if nb_layers==1:
weights.append(tf.get_variable('weights_W', shape=[M.shape[1], 1], initializer=tf.contrib.layers.xavier_initializer()))
bias.append( tf.Variable(tf.zeros([1,])))
else:
weights.append(tf.get_variable('weights_W', shape=[M.shape[1], self.n_conv_feat], initializer=tf.contrib.layers.xavier_initializer()))
bias.append(tf.Variable(tf.zeros([self.n_conv_feat,])))
for i in range(nb_layers-2):
weights.append(tf.get_variable('weights_%d' %i, shape=[self.n_conv_feat, self.n_conv_feat], initializer=tf.contrib.layers.xavier_initializer()))
bias.append(tf.Variable(tf.zeros([self.n_conv_feat,])))
weights.append(tf.get_variable("weight_final", shape=[self.n_conv_feat, 1], initializer=tf.contrib.layers.xavier_initializer()))
bias.append(tf.Variable(tf.zeros([1,])))
# GCNN architecture TRAINING
if nb_layers==1:
self.final_feat_users = self.mono_conv(self.A, self.M, weights[0], bias[0])
self.final_feat_users = tf.nn.dropout(self.final_feat_users, dropout)
else:
self.final_feat_users = self.mono_conv(self.A, self.M, weights[0], bias[0])
self.final_feat_users = tf.nn.dropout(self.final_feat_users, dropout)
self.final_feat_users = tf.nn.relu(self.final_feat_users)
for i in range(nb_layers-2):
self.final_feat_users = self.mono_conv(self.A, self.final_feat_users, weights[i+1], bias[i+1])
self.final_feat_users = tf.nn.dropout(self.final_feat_users, dropout)
self.final_feat_users = tf.nn.relu(self.final_feat_users)
self.final_feat_users = self.mono_conv(self.A, self.final_feat_users, weights[-1], bias[-1])
self.final_feat_users = tf.nn.dropout(self.final_feat_users, dropout)
self.classification=tf.sigmoid(self.final_feat_users)
#########loss definition
#computation of the accuracy term
self.classification_train = tf.multiply(self.training_mask, self.classification)
self.classification_test= tf.multiply(self.testing_mask, self.classification)
self.classification_val= tf.multiply(self.validation_mask, self.classification)
self.binary_entropy = tf.losses.sigmoid_cross_entropy(multi_class_labels = self.labels_train, logits = self.classification_train)
self.l2=0
for i in range(len(weights)):
self.l2+= tf.nn.l2_loss(weights[i])
#training loss definition
self.loss = self.binary_entropy+ l2_regu* self.l2
# GCNN architecture TESTING
self.binary_entropy_test = tf.losses.sigmoid_cross_entropy(multi_class_labels = self.labels_test, logits = self.classification_test)
self.predictions_error = self.binary_entropy_test
#definition of the solver
self.optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(self.loss)
self.var_grad = tf.gradients(self.loss, tf.trainable_variables())
self.norm_grad = self.frobenius_norm_square(tf.concat([tf.reshape(g, [-1]) for g in self.var_grad], 0))
# Create a session for running Ops on the Graph.
config = tf.ConfigProto(allow_soft_placement = True)
config.gpu_options.allow_growth = True
self.session = tf.Session(config=config)
# Run the Op to initialize the variables.
init = tf.initialize_all_variables()
#print(init)
self.session.run(init)
