def __init__(self, encoding_type=DEFAULT_ENCODING, u1_init=1.0, u3_init=0.0, **kwargs): super(FabolasKernelFunction, self).__init__(dimension=1, **kwargs) self.encoding_u12 = create_encoding( encoding_type, u1_init, COVARIANCE_SCALE_LOWER_BOUND, COVARIANCE_SCALE_UPPER_BOUND, 1, None) # This is not really needed, but param_encoding_pairs needs an encoding # for each parameter self.encoding_u3 = IdentityScalarEncoding(init_val=u3_init) with self.name_scope(): self.u1_internal = register_parameter( self.params, 'u1', self.encoding_u12) self.u2_internal = register_parameter( self.params, 'u2', self.encoding_u12) self.u3_internal = register_parameter( self.params, 'u3', self.encoding_u3)
def __init__(self, input_range, encoding_type=DEFAULT_ENCODING, **kwargs): super(OneDimensionalWarping, self).__init__(**kwargs) self.input_range = input_range self.encoding = create_encoding( encoding_type, INITIAL_WARPING, WARPING_LOWER_BOUND, WARPING_UPPER_BOUND, 2, LogNormal(0.0, 0.75)) with self.name_scope(): self.warping_internal = register_parameter( self.params, 'warping', self.encoding, shape=(2,))
def __init__(self, initial_mean_value = INITIAL_MEAN_VALUE, **kwargs): super(ScalarMeanFunction, self).__init__(**kwargs) # Even though we do not apply specific transformation to the mean value # we use an encoding to handle in a consistent way the box constraints # of Gluon parameters (like bandwidths or residual noise variance) self.encoding = IdentityScalarEncoding( init_val=initial_mean_value, regularizer=Normal(0.0, 1.0)) with self.name_scope(): self.mean_value_internal = register_parameter( self.params, 'mean_value', self.encoding)
def __init__( self, kernel: KernelFunction, mean: MeanFunction = None, initial_noise_variance=None, encoding_type=None, **kwargs): super(MarginalLikelihood, self).__init__(**kwargs) if mean is None: mean = ScalarMeanFunction() if initial_noise_variance is None: initial_noise_variance = INITIAL_NOISE_VARIANCE if encoding_type is None: encoding_type=DEFAULT_ENCODING self.encoding = create_encoding( encoding_type, initial_noise_variance, NOISE_VARIANCE_LOWER_BOUND, NOISE_VARIANCE_UPPER_BOUND, 1, Gamma(mean=0.1, alpha=0.1)) self.mean = mean self.kernel = kernel with self.name_scope(): self.noise_variance_internal = register_parameter( self.params, 'noise_variance', self.encoding)
def __init__(self, dimension, ARD=False, encoding_type=DEFAULT_ENCODING, **kwargs): super(Matern52, self).__init__(dimension, **kwargs) self.encoding = create_encoding(encoding_type, INITIAL_COVARIANCE_SCALE, COVARIANCE_SCALE_LOWER_BOUND, COVARIANCE_SCALE_UPPER_BOUND, 1, LogNormal(0.0, 1.0)) self.ARD = ARD self.squared_distance = SquaredDistance(dimension=dimension, ARD=ARD, encoding_type=encoding_type) with self.name_scope(): self.covariance_scale_internal = register_parameter( self.params, 'covariance_scale', self.encoding)
def __init__(self, dimension, ARD=False, encoding_type=DEFAULT_ENCODING, **kwargs): super(SquaredDistance, self).__init__(**kwargs) self.ARD = ARD inverse_bandwidths_dimension = 1 if not ARD else dimension self.encoding = create_encoding( encoding_type, INITIAL_INVERSE_BANDWIDTHS, INVERSE_BANDWIDTHS_LOWER_BOUND, INVERSE_BANDWIDTHS_UPPER_BOUND, inverse_bandwidths_dimension, Uniform(INVERSE_BANDWIDTHS_LOWER_BOUND, INVERSE_BANDWIDTHS_UPPER_BOUND)) with self.name_scope(): self.inverse_bandwidths_internal = register_parameter( self.params, 'inverse_bandwidths', self.encoding, shape=(inverse_bandwidths_dimension, ))
def __init__(self, kernel_x: KernelFunction, mean_x: MeanFunction, encoding_type=DEFAULT_ENCODING, alpha_init=1.0, mean_lam_init=0.5, gamma_init=0.5, delta_fixed_value=None, delta_init=0.5, max_metric_value=1.0, **kwargs): """ :param kernel_x: Kernel k_x(x, x') over configs :param mean_x: Mean function mu_x(x) over configs :param encoding_type: Encoding used for alpha, mean_lam, gamma (positive values) :param alpha_init: Initial value alpha :param mean_lam_init: Initial value mean_lam :param gamma_init: Initial value gamma :param delta_fixed_value: If not None, delta is fixed to this value, and does not become a free parameter :param delta_init: Initial value delta (if delta_fixed_value is None) :param max_metric_value: Maximum value which metric can attend. This is used as upper bound on gamma """ super(ExponentialDecayResourcesKernelFunction, self).__init__(dimension=kernel_x.dimension + 1, **kwargs) self.kernel_x = kernel_x self.mean_x = mean_x # alpha, mean_lam are parameters of a Gamma distribution, where alpha is # a scale parameter, and # E[lambda] = mean_lam, Var[lambda] = mean_lam ** 2 / alpha alpha_lower, alpha_upper = 1e-6, 250.0 alpha_init = self._wrap_initvals(alpha_init, alpha_lower, alpha_upper) self.encoding_alpha = create_encoding(encoding_type, alpha_init, alpha_lower, alpha_upper, 1, None) mean_lam_lower, mean_lam_upper = 1e-4, 50.0 mean_lam_init = self._wrap_initvals(mean_lam_init, mean_lam_lower, mean_lam_upper) self.encoding_mean_lam = create_encoding(encoding_type, mean_lam_init, mean_lam_lower, mean_lam_upper, 1, None) # If f(x, 0) is the metric value at r -> 0, f(x) at r -> infty, # then f(x, 0) = gamma (for delta = 1), or f(x, 0) = gamma + f(x) for # delta = 0. gamma should not be largest than the maximum metric # value. gamma_lower = max_metric_value * 0.0001 gamma_upper = max_metric_value gamma_init = self._wrap_initvals(gamma_init, gamma_lower, gamma_upper) self.encoding_gamma = create_encoding(encoding_type, gamma_init, gamma_lower, gamma_upper, 1, None) if delta_fixed_value is None: delta_init = self._wrap_initvals(delta_init, 0.0, 1.0) self.encoding_delta = IdentityScalarEncoding(constr_lower=0.0, constr_upper=1.0, init_val=delta_init) else: assert 0.0 <= delta_fixed_value <= 1.0, \ "delta_fixed_value = {}, must lie in [0, 1]".format( delta_fixed_value) self.encoding_delta = None self.delta_fixed_value = delta_fixed_value with self.name_scope(): self.alpha_internal = register_parameter(self.params, "alpha", self.encoding_alpha) self.mean_lam_internal = register_parameter( self.params, "mean_lam", self.encoding_mean_lam) self.gamma_internal = register_parameter(self.params, "gamma", self.encoding_gamma) if delta_fixed_value is None: self.delta_internal = register_parameter( self.params, "delta", self.encoding_delta)