def __init__(self, num_outputs, num_factors=16, rho_init=INITIAL_NOISE_VARIANCE, encoding_type=DEFAULT_ENCODING, **kwargs): super(Coregionalization, self).__init__(dimension=1, **kwargs) self.encoding_W_flat = IdentityScalarEncoding( dimension=num_outputs * num_factors) self.encoding_rho = create_encoding(encoding_type, rho_init, NOISE_VARIANCE_LOWER_BOUND, NOISE_VARIANCE_UPPER_BOUND, dimension=1) self.num_outputs = num_outputs self.num_factors = num_factors with self.name_scope(): self.W_flat_internal = self.params.get( "W_internal", shape=(num_outputs * num_factors,), init=mx.init.Normal(), # TODO: Use Xavier initialization here dtype=DATA_TYPE) self.rho_internal = self.params.get( "rho_internal", shape=(1,), init=mx.init.Constant(self.encoding_rho.init_val_int), dtype=DATA_TYPE)
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, 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, 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)