def __init__( self, optimizer=None, optimizer_args=None, step_size=0.01, use_maml=True, **kwargs): assert optimizer is not None # only for use with MAML TRPO if optimizer is None: if optimizer_args is None: optimizer_args = dict() optimizer = PenaltyLbfgsOptimizer(**optimizer_args) if not use_maml: default_args = dict( batch_size=None, max_epochs=1, ) optimizer = FirstOrderOptimizer(**default_args) self.optimizer = optimizer self.step_size = step_size self.use_maml = use_maml self.kl_constrain_step = -1 # needs to be 0 or -1 (original pol params, or new pol params) super(MAMLNPO, self).__init__(**kwargs)
def __init__(self, optimizer=None, optimizer_args=None, step_size=0.01, **kwargs): if optimizer is None: if optimizer_args is None: optimizer_args = dict() optimizer = PenaltyLbfgsOptimizer(**optimizer_args) self.optimizer = optimizer self.step_size = step_size super(ModelNPO, self).__init__(**kwargs)
def __init__(self, optimizer=None, optimizer_args=None, step_size=0.01, entropy_weight=0.0, **kwargs): if optimizer is None: if optimizer_args is None: optimizer_args = dict() optimizer = PenaltyLbfgsOptimizer(**optimizer_args) self.optimizer = optimizer self.step_size = step_size self.pol_ent_wt = entropy_weight super(NPO, self).__init__(**kwargs)
def __init__(self, optimizer=None, optimizer_args=None, step_size=0.01, sample_backups=0, kl_sample_backups=0, **kwargs): if optimizer is None: if optimizer_args is None: optimizer_args = dict() optimizer = PenaltyLbfgsOptimizer(**optimizer_args) self.optimizer = optimizer self.step_size = step_size self.sample_backups = sample_backups self.kl_sample_backups = kl_sample_backups super(NPO, self).__init__(**kwargs)
def __init__(self, env, policy, baseline, optimizer=None, optimizer_args=None, step_size=0.01, transfer=True, record_rewards=True, rewards=None, **kwargs): if optimizer is None: if optimizer_args is None: optimizer_args = dict() optimizer = PenaltyLbfgsOptimizer(name='PenaltyLbfgsOptimizer') self.optimizer = optimizer self.step_size = step_size self.transfer = transfer self.record_rewards = record_rewards if self.record_rewards: if rewards is None: #create empty dict self.rewards = {} self.rewards['average_discounted_return'] = [] self.rewards['AverageReturn'] = [] self.rewards['StdReturn'] = [] self.rewards['MaxReturn'] = [] self.rewards['MinReturn'] = [] else: self.rewards = rewards super(NPO_t, self).__init__(env=env, policy=policy, baseline=baseline, sampler_cls=QMDPSampler, sampler_args=dict(), **kwargs)
def __init__( self, name, input_shape, output_dim, # observation_space, 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. """ 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", ) 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 # self.observation_space = observation_space 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 self.input_dim = input_shape[0] self.output_dim = output_dim
def __init__( self, name, input_shape, output_dim, mean_network=None, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.tanh, output_nonlinearity=lambda x: x * 0.0 + tf.Variable( initial_value=-1.0, dtype=tf.float32), # output_nonlinearity=tf.identity, 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. """ 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 = create_MLP( name="mean_network", output_dim=1, hidden_sizes=hidden_sizes, hidden_nonlinearity=hidden_nonlinearity, output_nonlinearity=output_nonlinearity, ) forward_mean = lambda x, params, is_train: self.forward_MLP( 'mean_network', all_params=params, input_tensor=x, is_training=is_train)[1] else: raise NotImplementedError('Not supported.') # print("Debug2, mean network is defined here") # mean_network = L.ParamLayer( # incoming=L.InputLayer( # shape=(None,) + input_shape, # name="input_layer"), # num_units=1, # param=tf.constant_initializer(-200.0), # name="mean_network", # trainable=True, # ), # print(mean_network.input_layer) # print("debug4", isinstance(L.InputLayer( # shape=(None,) + input_shape, # name="input_layer"), tuple)) # # l_mean = mean_network # mean_network = MLP( # name="mean_network", # input_shape=input_shape, # output_dim=output_dim, # hidden_sizes=hidden_sizes, # hidden_nonlinearity=hidden_nonlinearity, # output_nonlinearity=output_nonlinearity, # ) # # 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 raise NotImplementedError('Not supported.') 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, # ) self.all_params['std_param'] = make_param_layer( num_units=1, param=tf.constant_initializer(init_std), name="output_std_param", trainable=learn_std, ) forward_std = lambda x, params: forward_param_layer( x, params['std_param']) self.all_param_vals = None 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) ## code added for symbolic prediction, used in constructing the meta-learning objective def normalized_means_var_sym(xs, params): inputs = OrderedDict({mean_network.input_layer: xs}) inputs.update(params) return L.get_output(layer_or_layers=l_mean, inputs=inputs) # normalized_means_var_sym = lambda xs, params: L.get_output(layer_or_layers=l_mean, inputs=OrderedDict({mean_network.input_layer:xs}.) #mean_network.input_layer: (xs-x_mean_var)/x_std_var, # normalized_log_stds_var_sym = L.get_output(l_log_std, {mean_network.input_layer: normalized_xs_var}) means_var_sym = lambda xs, params: normalized_means_var_sym( xs=xs, params=params) * y_std_var + y_mean_var # log_stds_var = normalized_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)) loss = tf.nn.l2_loss(normalized_ys_var - normalized_means_var ) + tf.nn.l2_loss(normalized_log_stds_var) 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 self._f_predict_sym = means_var_sym self.loss_sym = loss 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_experts_opt(self): ############################### # # Variable Definitions # ############################### all_task_dist_info_vars = [] all_obs_vars = [] for i, policy in enumerate(self.local_policies): task_obs_var = self.env_partitions[ i].observation_space.new_tensor_variable('obs%d' % i, extra_dims=1) task_dist_info_vars = [] for j, other_policy in enumerate(self.local_policies): state_info_vars = dict() # Not handling recurrent policies dist_info_vars = other_policy.dist_info_sym( task_obs_var, state_info_vars) task_dist_info_vars.append(dist_info_vars) all_obs_vars.append(task_obs_var) all_task_dist_info_vars.append(task_dist_info_vars) obs_var = self.env.observation_space.new_tensor_variable('obs', extra_dims=1) action_var = self.env.action_space.new_tensor_variable('action', extra_dims=1) advantage_var = tensor_utils.new_tensor('advantage', ndim=1, dtype=tf.float32) old_dist_info_vars = { k: tf.placeholder(tf.float32, shape=[None] + list(shape), name='old_%s' % k) for k, shape in self.policy.distribution.dist_info_specs } old_dist_info_vars_list = [ old_dist_info_vars[k] for k in self.policy.distribution.dist_info_keys ] central_obs_vars = [elem[1] for elem in self.central_policy_dist_infos] input_list = [ obs_var, action_var, advantage_var ] + old_dist_info_vars_list + all_obs_vars + central_obs_vars ############################### # # Local Policy Optimization # ############################### self.optimizers = [] self.metrics = [] for n, policy in enumerate(self.local_policies): state_info_vars = dict() dist_info_vars = policy.dist_info_sym(obs_var, state_info_vars) dist = policy.distribution kl = dist.kl_sym(old_dist_info_vars, dist_info_vars) lr = dist.likelihood_ratio_sym(action_var, old_dist_info_vars, dist_info_vars) surr_loss = -tf.reduce_mean(lr * advantage_var) if self.constrain_together: additional_loss = Metrics.kl_on_others( n, dist, all_task_dist_info_vars) elif self.constrain_against_central: additional_loss = Metrics.kl_on_central( dist, dist_info_vars, self.central_policy_dist_infos[n][0]) else: additional_loss = tf.constant(0.0) local_loss = surr_loss + self.penalty * additional_loss kl_metric = tensor_utils.compile_function(inputs=input_list, outputs=additional_loss, log_name="KLPenalty%d" % n) self.metrics.append(kl_metric) mean_kl_constraint = tf.reduce_mean(kl) optimizer = PenaltyLbfgsOptimizer(name='expertOptimizer_' + str(n)) optimizer.update_opt( loss=local_loss, target=policy, leq_constraint=(mean_kl_constraint, self.step_size), inputs=input_list, constraint_name="mean_kl_%d" % n, ) self.optimizers.append(optimizer) return dict()