def likelihood_loss(self): if self.output_layer.nonlinearity == tf.nn.softmax: logits = self.output_layer.get_logits_for( L.get_output(self.layers[-2])) loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits, tf.squeeze(self.target_var)) ) elif self.output_layer.nonlinearity == tf.identity: outputs = self.output_layer.get_output_for( L.get_output(self._layers[-2])) loss = tf.reduce_mean( 0.5 * tf.square(outputs - self.target_var), name='like_loss' ) elif self.output_layer.nonlinearity == tf.nn.sigmoid: logits = self.output_layer.get_logits_for( L.get_output(self.layers[-2])) sigmoid_loss = tf.nn.sigmoid_cross_entropy_with_logits( logits, tf.squeeze(self.target_var)) if sigmoid_loss.get_shape().ndims == 2: loss = tf.reduce_mean( tf.reduce_sum(sigmoid_loss, reduction_indices=1) ) else: loss = tf.reduce_mean(sigmoid_loss) return loss
def log_likelihood_sym(self, x_var, y_var): if config.TF_NN_SETTRACE: ipdb.set_trace() normalized_xs_var = (x_var - self.x_mean_var) / self.x_std_var prob = L.get_output(self.l_prob, {self.prob_network.input_layer: normalized_xs_var}) return self._dist.log_likelihood_sym(y_var, dict(prob=prob))
def dist_info_sym(self, x_var): if config.TF_NN_SETTRACE: ipdb.set_trace() normalized_xs_var = (x_var - self.x_mean_var) / self.x_std_var prob = L.get_output(self.l_prob, {self.prob_network.input_layer: normalized_xs_var}) return dict(prob=prob)
def likelihood_loss(self): logits = self.output_layer.get_logits_for( L.get_output(self.layers[-2])) #logits = L.get_output(self.layers[-1]) loss = tf.nn.sigmoid_cross_entropy_with_logits(logits, self.target_var) #ent_B = tfutil.logit_bernoulli_entropy(logits) #self.obj = tf.reduce_sum(loss_B - self.ent_reg_weight * ent_B) return tf.reduce_sum(loss)
def __init__(self, name, output_dim, hidden_sizes, hidden_nonlinearity, output_nonlinearity, hidden_W_init=L.XavierUniformInitializer(), hidden_b_init=tf.zeros_initializer, output_W_init=L.XavierUniformInitializer(), output_b_init=tf.zeros_initializer, batch_size=None, input_var=None, input_layer=None, input_shape=None, batch_normalization=False, weight_normalization=False, ): Serializable.quick_init(self, locals()) self.name = name with tf.variable_scope(name): if input_layer is None: l_in = L.InputLayer( shape=(batch_size,) + input_shape, input_var=input_var, name="input") else: l_in = input_layer self._layers = [l_in] l_hid = l_in if batch_normalization: ls = L.batch_norm(l_hid) l_hid = ls[-1] self._layers += ls for idx, hidden_size in enumerate(hidden_sizes): l_hid = L.DenseLayer( l_hid, num_units=hidden_size, nonlinearity=hidden_nonlinearity, name="hidden_%d" % idx, W=hidden_W_init, b=hidden_b_init, weight_normalization=weight_normalization ) if batch_normalization: ls = L.batch_norm(l_hid) l_hid = ls[-1] self._layers += ls self._layers.append(l_hid) l_out = L.DenseLayer( l_hid, num_units=output_dim, nonlinearity=output_nonlinearity, name="output", W=output_W_init, b=output_b_init, weight_normalization=weight_normalization ) if batch_normalization: ls = L.batch_norm(l_out) l_out = ls[-1] self._layers += ls self._layers.append(l_out) self._l_in = l_in self._l_out = l_out self._l_tar = L.InputLayer( shape=(batch_size,) + (output_dim,), input_var=input_var, name="target") # self._input_var = l_in.input_var self._output = L.get_output(l_out) LayersPowered.__init__(self, l_out)
def compute_score(self, X): """ predict logits ... """ logits = self.output_layer.get_logits_for( L.get_output(self.layers[-2])) #logits = self.output Y_p = self._predict(logits, X) return Y_p
def log_likelihood_sym(self, x_var, y_var): normalized_xs_var = (x_var - self._x_mean_var) / self._x_std_var normalized_means_var, normalized_log_stds_var = \ L.get_output([self._l_mean, self._l_log_std], {self._mean_network.input_layer: normalized_xs_var}) means_var = normalized_means_var * self._y_std_var + self._y_mean_var log_stds_var = normalized_log_stds_var + TT.log(self._y_std_var) return self._dist.log_likelihood_sym(y_var, dict(mean=means_var, log_std=log_stds_var))
def dist_info_sym(self, obs_var, state_info_vars=None): mean_var, std_param_var = L.get_output([self._l_mean, self._l_std_param], obs_var) if self.min_std_param is not None: std_param_var = tf.maximum(std_param_var, self.min_std_param) if self.std_parametrization == 'exp': log_std_var = std_param_var elif self.std_parametrization == 'softplus': log_std_var = tf.log(tf.log(1. + tf.exp(std_param_var))) else: raise NotImplementedError return dict(mean=mean_var, log_std=log_std_var)
def compute_score(self, X): """ predict logits ... """ if config.TF_NN_SETTRACE: ipdb.set_trace() logits = self.output_layer.get_logits_for(L.get_output( self.layers[-2])) #logits = self.output Y_p = self._predict(logits, X) return Y_p
def dist_info_sym(self, obs_var, state_info_vars): n_batches = tf.shape(obs_var)[0] n_steps = tf.shape(obs_var)[1] obs_var = tf.reshape(obs_var, tf.pack([n_batches, n_steps, -1])) if self.state_include_action: prev_action_var = state_info_vars["prev_action"] all_input_var = tf.concat(2, [obs_var, prev_action_var]) else: all_input_var = obs_var if self.feature_network is None: means, log_stds = L.get_output( [self.mean_network.output_layer, self.l_log_std], {self.l_input: all_input_var}) else: flat_input_var = tf.reshape(all_input_var, (-1, self.input_dim)) means, log_stds = L.get_output( [self.mean_network.output_layer, self.l_log_std], { self.l_input: all_input_var, self.feature_network.input_layer: flat_input_var }) return dict(mean=means, log_std=log_stds)
def complexity_loss(self, reg, cmx): """ Compute penalties for model complexity (e.g., l2 regularization, or kl penalties for vae and bnn). """ # loss coming from weight regularization loss = reg * tf.reduce_sum( tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)) # loss coming from data-dependent regularization for layer in self.layers: if layer.penalize_complexity: z_mu, z_sig = layer.get_dparams_for( L.get_output(layer.input_layer)) d_loss = layer.bayesreg.activ_kl(z_mu, z_sig) loss += cmx * d_loss return reg * loss
def __init__( self, name, env_spec, hidden_dim=32, feature_network=None, state_include_action=True, hidden_nonlinearity=tf.tanh, gru_layer_cls=L.GRULayer, learn_std=True, init_std=1.0, output_nonlinearity=None, ): """ :param env_spec: A spec for the env. :param hidden_dim: dimension of hidden layer :param hidden_nonlinearity: nonlinearity used for each hidden layer :return: """ with tf.variable_scope(name): Serializable.quick_init(self, locals()) super(GaussianGRUPolicy, self).__init__(env_spec) obs_dim = env_spec.observation_space.flat_dim action_dim = env_spec.action_space.flat_dim if state_include_action: input_dim = obs_dim + action_dim else: input_dim = obs_dim l_input = L.InputLayer(shape=(None, None, input_dim), name="input") if feature_network is None: feature_dim = input_dim l_flat_feature = None l_feature = l_input else: feature_dim = feature_network.output_layer.output_shape[-1] l_flat_feature = feature_network.output_layer l_feature = L.OpLayer( l_flat_feature, extras=[l_input], name="reshape_feature", op=lambda flat_feature, input: tf.reshape( flat_feature, tf.pack([ tf.shape(input)[0], tf.shape(input)[1], feature_dim ])), shape_op=lambda _, input_shape: (input_shape[0], input_shape[1], feature_dim)) mean_network = GRUNetwork(input_shape=(feature_dim, ), input_layer=l_feature, output_dim=action_dim, hidden_dim=hidden_dim, hidden_nonlinearity=hidden_nonlinearity, output_nonlinearity=output_nonlinearity, gru_layer_cls=gru_layer_cls, name="mean_network") l_log_std = L.ParamLayer( mean_network.input_layer, num_units=action_dim, param=tf.constant_initializer(np.log(init_std)), name="output_log_std", trainable=learn_std, ) l_step_log_std = L.ParamLayer( mean_network.step_input_layer, num_units=action_dim, param=l_log_std.param, name="step_output_log_std", trainable=learn_std, ) self.mean_network = mean_network self.feature_network = feature_network self.l_input = l_input self.state_include_action = state_include_action flat_input_var = tf.placeholder(dtype=tf.float32, shape=(None, input_dim), name="flat_input") if feature_network is None: feature_var = flat_input_var else: feature_var = L.get_output( l_flat_feature, {feature_network.input_layer: flat_input_var}) self.f_step_mean_std = tensor_utils.compile_function( [ flat_input_var, #mean_network.step_prev_hidden_layer.input_var, mean_network.step_prev_state_layer.input_var ], L.get_output([ mean_network.step_output_layer, l_step_log_std, mean_network.step_hidden_layer, ], {mean_network.step_input_layer: feature_var})) self.l_log_std = l_log_std self.input_dim = input_dim self.action_dim = action_dim self.hidden_dim = hidden_dim self.prev_actions = None self.prev_hiddens = None self.dist = RecurrentDiagonalGaussian(action_dim) out_layers = [mean_network.output_layer, l_log_std, l_step_log_std] if feature_network is not None: out_layers.append(feature_network.output_layer) LayersPowered.__init__(self, out_layers)
def dist_info_sym(self, x_var): normalized_xs_var = (x_var - self.x_mean_var) / self.x_std_var prob = L.get_output(self.l_prob, {self.prob_network.input_layer: normalized_xs_var}) return dict(prob=prob)
def log_likelihood_sym(self, x_var, y_var): normalized_xs_var = (x_var - self.x_mean_var) / self.x_std_var prob = L.get_output(self.l_prob, {self.prob_network.input_layer: normalized_xs_var}) return self._dist.log_likelihood_sym(y_var, dict(prob=prob))
def __init__( self, name, input_shape, output_dim, prob_network=None, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.tanh, optimizer=None, tr_optimizer=None, use_trust_region=True, step_size=0.01, normalize_inputs=True, no_initial_trust_region=True, ): """ :param input_shape: Shape of the input data. :param output_dim: Dimension of output. :param hidden_sizes: Number of hidden units of each layer of the mean network. :param hidden_nonlinearity: Non-linearity used for each layer of the mean network. :param optimizer: Optimizer for minimizing the negative log-likelihood. :param use_trust_region: Whether to use trust region constraint. :param step_size: KL divergence constraint for each iteration """ Serializable.quick_init(self, locals()) with tf.variable_scope(name): if optimizer is None: optimizer = LbfgsOptimizer(name="optimizer") if tr_optimizer is None: tr_optimizer = ConjugateGradientOptimizer() self.output_dim = output_dim self.optimizer = optimizer self.tr_optimizer = tr_optimizer if prob_network is None: prob_network = MLP(input_shape=input_shape, output_dim=output_dim, hidden_sizes=hidden_sizes, hidden_nonlinearity=hidden_nonlinearity, output_nonlinearity=tf.nn.softmax, name="prob_network") l_prob = prob_network.output_layer LayersPowered.__init__(self, [l_prob]) xs_var = prob_network.input_layer.input_var ys_var = tf.placeholder(dtype=tf.float32, shape=[None, output_dim], name="ys") old_prob_var = tf.placeholder(dtype=tf.float32, shape=[None, output_dim], name="old_prob") x_mean_var = tf.get_variable(name="x_mean", shape=(1, ) + input_shape, initializer=tf.constant_initializer( 0., dtype=tf.float32)) x_std_var = tf.get_variable(name="x_std", shape=(1, ) + input_shape, initializer=tf.constant_initializer( 1., dtype=tf.float32)) normalized_xs_var = (xs_var - x_mean_var) / x_std_var prob_var = L.get_output( l_prob, {prob_network.input_layer: normalized_xs_var}) old_info_vars = dict(prob=old_prob_var) info_vars = dict(prob=prob_var) dist = self._dist = Categorical(output_dim) mean_kl = tf.reduce_mean(dist.kl_sym(old_info_vars, info_vars)) loss = -tf.reduce_mean(dist.log_likelihood_sym(ys_var, info_vars)) predicted = tensor_utils.to_onehot_sym( tf.argmax(prob_var, dimension=1), output_dim) self.prob_network = prob_network self.f_predict = tensor_utils.compile_function([xs_var], predicted) self.f_prob = tensor_utils.compile_function([xs_var], prob_var) self.l_prob = l_prob self.optimizer.update_opt(loss=loss, target=self, network_outputs=[prob_var], inputs=[xs_var, ys_var]) self.tr_optimizer.update_opt(loss=loss, target=self, network_outputs=[prob_var], inputs=[xs_var, ys_var, old_prob_var], leq_constraint=(mean_kl, step_size)) self.use_trust_region = use_trust_region self.name = name self.normalize_inputs = normalize_inputs self.x_mean_var = x_mean_var self.x_std_var = x_std_var self.first_optimized = not no_initial_trust_region
def __init__(self, name, input_shape, output_dim, mean_network=None, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.tanh, optimizer=None, use_trust_region=True, step_size=0.01, learn_std=True, init_std=1.0, adaptive_std=False, std_share_network=False, std_hidden_sizes=(32, 32), std_nonlinearity=None, normalize_inputs=True, normalize_outputs=True, subsample_factor=1.0): """ :param input_shape: Shape of the input data. :param output_dim: Dimension of output. :param hidden_sizes: Number of hidden units of each layer of the mean network. :param hidden_nonlinearity: Non-linearity used for each layer of the mean network. :param optimizer: Optimizer for minimizing the negative log-likelihood. :param use_trust_region: Whether to use trust region constraint. :param step_size: KL divergence constraint for each iteration :param learn_std: Whether to learn the standard deviations. Only effective if adaptive_std is False. If adaptive_std is True, this parameter is ignored, and the weights for the std network are always learned. :param adaptive_std: Whether to make the std a function of the states. :param std_share_network: Whether to use the same network as the mean. :param std_hidden_sizes: Number of hidden units of each layer of the std network. Only used if `std_share_network` is False. It defaults to the same architecture as the mean. :param std_nonlinearity: Non-linearity used for each layer of the std network. Only used if `std_share_network` is False. It defaults to the same non-linearity as the mean. """ if config.TF_NN_SETTRACE: ipdb.set_trace() Serializable.quick_init(self, locals()) with tf.variable_scope(name): if optimizer is None: if use_trust_region: optimizer = PenaltyLbfgsOptimizer("optimizer") else: optimizer = LbfgsOptimizer("optimizer") self._optimizer = optimizer self._subsample_factor = subsample_factor if mean_network is None: mean_network = MLP( name="mean_network", input_shape=input_shape, output_dim=output_dim, hidden_sizes=hidden_sizes, hidden_nonlinearity=hidden_nonlinearity, output_nonlinearity=None, ) l_mean = mean_network.output_layer if adaptive_std: l_log_std = MLP( name="log_std_network", input_shape=input_shape, input_var=mean_network.input_layer.input_var, output_dim=output_dim, hidden_sizes=std_hidden_sizes, hidden_nonlinearity=std_nonlinearity, output_nonlinearity=None, ).output_layer else: l_log_std = L.ParamLayer( mean_network.input_layer, num_units=output_dim, param=tf.constant_initializer(np.log(init_std)), name="output_log_std", trainable=learn_std, ) LayersPowered.__init__(self, [l_mean, l_log_std]) xs_var = mean_network.input_layer.input_var ys_var = tf.placeholder(dtype=tf.float32, name="ys", shape=(None, output_dim)) old_means_var = tf.placeholder(dtype=tf.float32, name="ys", shape=(None, output_dim)) old_log_stds_var = tf.placeholder(dtype=tf.float32, name="old_log_stds", shape=(None, output_dim)) x_mean_var = tf.Variable( np.zeros((1, ) + input_shape, dtype=np.float32), name="x_mean", ) x_std_var = tf.Variable( np.ones((1, ) + input_shape, dtype=np.float32), name="x_std", ) y_mean_var = tf.Variable( np.zeros((1, output_dim), dtype=np.float32), name="y_mean", ) y_std_var = tf.Variable( np.ones((1, output_dim), dtype=np.float32), name="y_std", ) normalized_xs_var = (xs_var - x_mean_var) / x_std_var normalized_ys_var = (ys_var - y_mean_var) / y_std_var normalized_means_var = L.get_output( l_mean, {mean_network.input_layer: normalized_xs_var}) normalized_log_stds_var = L.get_output( l_log_std, {mean_network.input_layer: normalized_xs_var}) means_var = normalized_means_var * y_std_var + y_mean_var log_stds_var = normalized_log_stds_var + tf.log(y_std_var) normalized_old_means_var = (old_means_var - y_mean_var) / y_std_var normalized_old_log_stds_var = old_log_stds_var - tf.log(y_std_var) dist = self._dist = DiagonalGaussian(output_dim) normalized_dist_info_vars = dict(mean=normalized_means_var, log_std=normalized_log_stds_var) mean_kl = tf.reduce_mean( dist.kl_sym( dict(mean=normalized_old_means_var, log_std=normalized_old_log_stds_var), normalized_dist_info_vars, )) loss = - \ tf.reduce_mean(dist.log_likelihood_sym( normalized_ys_var, normalized_dist_info_vars)) self._f_predict = tensor_utils.compile_function([xs_var], means_var) self._f_pdists = tensor_utils.compile_function( [xs_var], [means_var, log_stds_var]) self._l_mean = l_mean self._l_log_std = l_log_std optimizer_args = dict( loss=loss, target=self, network_outputs=[ normalized_means_var, normalized_log_stds_var ], ) if use_trust_region: optimizer_args["leq_constraint"] = (mean_kl, step_size) optimizer_args["inputs"] = [ xs_var, ys_var, old_means_var, old_log_stds_var ] else: optimizer_args["inputs"] = [xs_var, ys_var] self._optimizer.update_opt(**optimizer_args) self._use_trust_region = use_trust_region self._name = name self._normalize_inputs = normalize_inputs self._normalize_outputs = normalize_outputs self._mean_network = mean_network self._x_mean_var = x_mean_var self._x_std_var = x_std_var self._y_mean_var = y_mean_var self._y_std_var = y_std_var
def __init__( self, input_shape, output_dim, name, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.relu, optimizer=None, tr_optimizer=None, use_trust_region=True, step_size=0.01, normalize_inputs=True, no_initial_trust_region=True, ): """ :param input_shape: Shape of the input data. :param output_dim: Dimension of output. :param hidden_sizes: Number of hidden units of each layer of the mean network. :param hidden_nonlinearity: Non-linearity used for each layer of the mean network. :param optimizer: Optimizer for minimizing the negative log-likelihood. :param use_trust_region: Whether to use trust region constraint. :param step_size: KL divergence constraint for each iteration """ if config.TF_NN_SETTRACE: ipdb.set_trace() Serializable.quick_init(self, locals()) with tf.variable_scope(name): if optimizer is None: optimizer = LbfgsOptimizer(name="optimizer") if tr_optimizer is None: tr_optimizer = ConjugateGradientOptimizer() self.output_dim = output_dim self.optimizer = optimizer self.tr_optimizer = tr_optimizer p_network = MLP( input_shape=input_shape, output_dim=output_dim, hidden_sizes=hidden_sizes, hidden_nonlinearity=hidden_nonlinearity, output_nonlinearity=tf.nn.sigmoid, name="p_network" ) l_p = p_network.output_layer LayersPowered.__init__(self, [l_p]) xs_var = p_network.input_layer.input_var ys_var = tf.placeholder( dtype=tf.float32, shape=(None, output_dim), name="ys") old_p_var = tf.placeholder( dtype=tf.float32, shape=(None, output_dim), name="old_p") x_mean_var = tf.get_variable( name="x_mean", initializer=tf.zeros_initializer, shape=(1,) + input_shape) x_std_var = tf.get_variable( name="x_std", initializer=tf.ones_initializer, shape=(1,) + input_shape) normalized_xs_var = (xs_var - x_mean_var) / x_std_var p_var = L.get_output( l_p, {p_network.input_layer: normalized_xs_var}) old_info_vars = dict(p=old_p_var) info_vars = dict(p=p_var) dist = self._dist = Bernoulli(output_dim) mean_kl = tf.reduce_mean(dist.kl_sym(old_info_vars, info_vars)) loss = - tf.reduce_mean(dist.log_likelihood_sym(ys_var, info_vars)) predicted = p_var >= 0.5 self.f_predict = tensor_utils.compile_function([xs_var], predicted) self.f_p = tensor_utils.compile_function([xs_var], p_var) self.l_p = l_p self.optimizer.update_opt(loss=loss, target=self, network_outputs=[ p_var], inputs=[xs_var, ys_var]) self.tr_optimizer.update_opt(loss=loss, target=self, network_outputs=[p_var], inputs=[xs_var, ys_var, old_p_var], leq_constraint=(mean_kl, step_size) ) self.use_trust_region = use_trust_region self.name = name self.normalize_inputs = normalize_inputs self.x_mean_var = x_mean_var self.x_std_var = x_std_var self.first_optimized = not no_initial_trust_region
def __init__( self, name, input_shape, output_dim, network=None, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.tanh, output_nonlinearity=None, optimizer=None, normalize_inputs=True, ): """ :param input_shape: Shape of the input data. :param output_dim: Dimension of output. :param hidden_sizes: Number of hidden units of each layer of the mean network. :param hidden_nonlinearity: Non-linearity used for each layer of the mean network. :param optimizer: Optimizer for minimizing the negative log-likelihood. """ if config.TF_NN_SETTRACE: ipdb.set_trace() Serializable.quick_init(self, locals()) with tf.variable_scope(name): if optimizer is None: optimizer = LbfgsOptimizer(name="optimizer") self.output_dim = output_dim self.optimizer = optimizer if network is None: network = MLP( input_shape=input_shape, output_dim=output_dim, hidden_sizes=hidden_sizes, hidden_nonlinearity=hidden_nonlinearity, output_nonlinearity=output_nonlinearity, name="network" ) l_out = network.output_layer LayersPowered.__init__(self, [l_out]) xs_var = network.input_layer.input_var ys_var = tf.placeholder(dtype=tf.float32, shape=[ None, output_dim], name="ys") x_mean_var = tf.get_variable( name="x_mean", shape=(1,) + input_shape, initializer=tf.constant_initializer(0., dtype=tf.float32) ) x_std_var = tf.get_variable( name="x_std", shape=(1,) + input_shape, initializer=tf.constant_initializer(1., dtype=tf.float32) ) normalized_xs_var = (xs_var - x_mean_var) / x_std_var fit_ys_var = L.get_output( l_out, {network.input_layer: normalized_xs_var}) loss = - tf.reduce_mean(tf.square(fit_ys_var - ys_var)) self.f_predict = tensor_utils.compile_function( [xs_var], fit_ys_var) optimizer_args = dict( loss=loss, target=self, network_outputs=[fit_ys_var], ) optimizer_args["inputs"] = [xs_var, ys_var] self.optimizer.update_opt(**optimizer_args) self.name = name self.l_out = l_out self.normalize_inputs = normalize_inputs self.x_mean_var = x_mean_var self.x_std_var = x_std_var
def predict_sym(self, xs): if config.TF_NN_SETTRACE: ipdb.set_trace() return L.get_output(self.l_out, xs)
def predict_sym(self, xs): return L.get_output(self.l_out, xs)
def __init__( self, name, input_shape, output_dim, hidden_sizes, hidden_nonlinearity, output_nonlinearity, z_dim, z_idx, z_hidden_sizes, merge="mul", hidden_W_init=L.XavierUniformInitializer(), hidden_b_init=tf.zeros_initializer, output_W_init=L.XavierUniformInitializer(), output_b_init=tf.zeros_initializer, batch_size=None, input_var=None, input_layer=None, batch_normalization=False, weight_normalization=False, ): Serializable.quick_init(self, locals()) self.name = name total_dim = np.prod(input_shape) with tf.variable_scope(name): if input_layer is None: l_in = L.InputLayer(shape=(batch_size, ) + input_shape, input_var=input_var, name="input") else: l_in = input_layer self._layers = [l_in] # slice off features / observation l_feat = L.SliceLayer(l_in, indices=slice(0, total_dim - z_dim), name="l_feat") # slice off z "style" variable l_z = L.SliceLayer(l_in, indices=slice(total_dim - z_dim, total_dim), name="l_z") l_pre = feedforward(l_feat, hidden_sizes[:z_idx], hidden_nonlinearity, linear_output=True) with tf.variable_scope("z"): # if merging mul, ensure dimensionalities match. if merge == "mul": _head = [total_dim] + hidden_sizes _head = [_head[z_idx]] elif merge == "concat": _head = [] l_z = feedforward(l_z, z_hidden_sizes + _head, hidden_nonlinearity, linear_output=True) # merge latent code with features if merge == "mul": l_merge = L.ElemwiseMulLayer([l_pre, l_z]) elif merge == "concat": l_merge = L.ConcatLayer([l_pre, l_z], axis=1) else: raise NotImplementedError if z_idx > 0: l_merge = L.NonlinearityLayer(l_merge, hidden_nonlinearity) l_hid = feedforward(l_merge, hidden_sizes[z_idx:], hidden_nonlinearity, start_idx=z_idx) l_out = L.DenseLayer(l_hid, num_units=output_dim, nonlinearity=output_nonlinearity, name="output", W=output_W_init, b=output_b_init, weight_normalization=weight_normalization) #if batch_normalization: # ls = L.batch_norm(l_out) # l_out = ls[-1] # self._layers += ls self._layers.append(l_out) self._l_in = l_in self._l_out = l_out self._l_tar = L.InputLayer(shape=(batch_size, ) + (output_dim, ), input_var=input_var, name="target") # self._input_var = l_in.input_var self._output = L.get_output(l_out) LayersPowered.__init__(self, l_out)
def __init__(self, name, input_shape, output_dim, z_dim, pre_hidden_sizes, post_hidden_sizes, hidden_nonlinearity, output_nonlinearity, hidden_W_init=L.XavierUniformInitializer(), hidden_b_init=tf.zeros_initializer, output_W_init=L.XavierUniformInitializer(), output_b_init=tf.zeros_initializer, batch_size=None, input_var=None, input_layer=None, weight_normalization=False): Serializable.quick_init(self, locals()) self.name = name with tf.variable_scope(name): if input_layer is None: l_in = L.InputLayer(shape=(batch_size, ) + input_shape, input_var=input_var, name="input") else: l_in = input_layer self._layers = [l_in] # construct graph l_hid = feedforward(l_in, pre_hidden_sizes, hidden_nonlinearity, hidden_W_init=hidden_W_init, hidden_b_init=hidden_b_init, weight_normalization=weight_normalization, start_idx=0) l_lat = L.LatentLayer(l_hid, z_dim) l_hid = feedforward(l_lat, post_hidden_sizes, hidden_nonlinearity, hidden_W_init=hidden_W_init, hidden_b_init=hidden_b_init, weight_normalization=weight_normalization, start_idx=len(pre_hidden_sizes)) # create output layer l_out = L.DenseLayer(l_hid, num_units=output_dim, nonlinearity=output_nonlinearity, name="output", W=output_W_init, b=output_b_init, weight_normalization=weight_normalization) self._layers.append(l_out) self._l_lat = l_lat self._z_dim = z_dim self._l_in = l_in self._l_out = l_out self._l_tar = L.InputLayer(shape=(batch_size, ) + (output_dim, ), input_var=input_var, name="target") # complexity loss for variational posterior z_mu, z_sig = self._l_lat.get_dparams_for( L.get_output(self._l_lat.input_layer)) self.kl_cost = kl_from_prior(z_mu, z_sig, self._z_dim) # self._input_var = l_in.input_var self._output = L.get_output(l_out) LayersPowered.__init__(self, l_out)