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)