def __init__(self, name, hparams):
        self.name = name
        self.hparams = hparams
        self.verbose = getattr(hparams, 'verbose', True)

        self.t = 0
        self.data_h = contextual_dataset.ContextualDataset(hparams.context_dim,
                                                           hparams.num_actions,
                                                           intercept=False)

        if self.verbose:
            print('Initializing model {}.'.format(self.name))
        self.gnp = generalized_neural_process.Regressor(
            input_dim=hparams.context_dim,
            output_dim=hparams.num_actions,
            x_encoder_net_sizes=hparams.x_encoder_net_sizes,
            x_y_encoder_net_sizes=hparams.x_y_encoder_net_sizes,
            global_latent_net_sizes=hparams.global_latent_net_sizes,
            local_latent_net_sizes=hparams.local_latent_net_sizes,
            decoder_net_sizes=hparams.decoder_net_sizes,
            heteroskedastic_net_sizes=hparams.heteroskedastic_net_sizes,
            att_type=hparams.att_type,
            att_heads=hparams.att_heads,
            model_type=hparams.model_type,
            activation=hparams.activation,
            output_activation=hparams.output_activation,
            data_uncertainty=hparams.data_uncertainty,
            beta=hparams.beta,
            temperature=hparams.temperature,
            model_path=hparams.model_path)
Пример #2
0
    def __init__(self, name, hparams, optimizer='RMS'):
        self.name = name
        self.hparams = hparams
        self.verbose = getattr(hparams, 'verbose', True)

        self.update_freq_lr = hparams.training_freq
        self.update_freq_nn = hparams.training_freq_network

        self.t = 0
        self.num_epochs = hparams.training_epochs
        self.data_h = contextual_dataset.ContextualDataset(hparams.context_dim,
                                                           hparams.num_actions,
                                                           intercept=False)

        self.gradient_updates = tf.Variable(0, trainable=False)
        if self.hparams.activate_decay:
            self.lr = tf.train.inverse_time_decay(self.hparams.initial_lr,
                                                  self.gradient_updates, 1,
                                                  self.hparams.lr_decay_rate)
        else:
            self.lr = tf.Variable(self.hparams.initial_lr, trainable=False)
        optimizer = tf.train.RMSPropOptimizer(self.lr)
        self._optimizer_config = {
            'optimizer': optimizer,
            'max_grad_norm': hparams.max_grad_norm
        }

        if self.verbose:
            print('Initializing model {}.'.format(self.name))
        self.snp = regressor.Regressor(
            input_dim=hparams.context_dim + hparams.num_actions,
            output_dim=1,
            x_encoder_sizes=hparams.x_encoder_sizes,
            x_y_encoder_sizes=hparams.x_y_encoder_sizes,
            global_latent_net_sizes=hparams.global_latent_net_sizes,
            local_latent_net_sizes=hparams.local_latent_net_sizes,
            heteroskedastic_net_sizes=hparams.heteroskedastic_net_sizes,
            att_type=hparams.att_type,
            att_heads=hparams.att_heads,
            uncertainty_type=hparams.uncertainty_type,
            mean_att_type=hparams.mean_att_type,
            scale_att_type_1=hparams.scale_att_type_1,
            scale_att_type_2=hparams.scale_att_type_2,
            activation=hparams.activation,
            output_activation=hparams.output_activation,
            data_uncertainty=hparams.data_uncertainty,
            local_variational=hparams.local_variational,
            model_path=hparams.model_path)

        self._step = tf.function(utils.mse_step.python_function)  # pytype: disable=module-attr

        self._one_hot_vectors = tf.one_hot(indices=np.arange(
            hparams.num_actions),
                                           depth=hparams.num_actions)
Пример #3
0
  def __init__(self,
               name,
               hparams):
    self.name = name
    self.hparams = hparams
    self.verbose = getattr(hparams, 'verbose', True)
    self._is_anp = getattr(hparams, 'is_anp', False)
    if self._is_anp:
      input_dim = hparams.context_dim
      output_dim = hparams.num_actions
    else:
      input_dim = hparams.context_dim + hparams.num_actions
      output_dim = 1

    self.t = 0
    self.data_h = contextual_dataset.ContextualDataset(
        hparams.context_dim, hparams.num_actions, intercept=False)

    if self.verbose:
      print('Initializing model {}.'.format(self.name))
    self.snp = regressor.Regressor(
        input_dim=input_dim,
        output_dim=output_dim,
        x_encoder_sizes=hparams.x_encoder_sizes,
        x_y_encoder_sizes=hparams.x_y_encoder_sizes,
        global_latent_net_sizes=hparams.global_latent_net_sizes,
        local_latent_net_sizes=hparams.local_latent_net_sizes,
        heteroskedastic_net_sizes=hparams.heteroskedastic_net_sizes,
        att_type=hparams.att_type,
        att_heads=hparams.att_heads,
        uncertainty_type=hparams.uncertainty_type,
        mean_att_type=hparams.mean_att_type,
        scale_att_type_1=hparams.scale_att_type_1,
        scale_att_type_2=hparams.scale_att_type_2,
        activation=hparams.activation,
        output_activation=hparams.output_activation,
        data_uncertainty=hparams.data_uncertainty,
        local_variational=hparams.local_variational,
        model_path=hparams.model_path)

    self._one_hot_vectors = tf.one_hot(
        indices=np.arange(hparams.num_actions),
        depth=hparams.num_actions)