def __init__(self, input_dim, output_dim, active_dims=None): Kernel.__init__(self, active_dims) self.input_dim = input_dim self.output_dim = output_dim noise = np.random.random((output_dim)) self.noise = gpflow.Parameter(noise, transform=gpflow.utilities.positive(), name="noise")
def __init__(self, base_kern, branchPtTensor, b, fDebug=False): ''' branchPtTensor is tensor of branch points of size F X F X B where F the number of functions and B the number of branching points ''' Kernel.__init__(self, input_dim=base_kern.input_dim + 1) self.kern = base_kern self.fm = branchPtTensor self.fDebug = fDebug assert isinstance(b, np.ndarray) assert self.fm.shape[0] == self.fm.shape[1] assert self.fm.shape[2] > 0 self.Bv = DataHolder(b)
def Kuf_kernel_GPinducingvariables(inducing_variable: InducingVariables, kernel: Kernel, X: tf.Tensor): GP_IV = inducing_variable.GP_IV Kuf = kernel.K(GP_IV, X) return Kuf
def __init__(self, input_dim, variance=1.0, frequency=np.array([1.0, 1.0]), lengthscale=1.0, correlation=0.0, max_freq=1.0, active_dims=None): assert (input_dim == 1 ) # the derivations are valid only for one dimensional input Kernel.__init__(self, input_dim=input_dim, active_dims=active_dims) self.variance = Param(variance, transforms.positive) self.frequency = Param(frequency, transforms.Logistic(0.0, max_freq)) self.lengthscale = Param(lengthscale, transforms.positive) correlation = np.clip(correlation, 1e-4, 1 - 1e-4) # clip for numerical reasons self.correlation = Param(correlation, transforms.Logistic())
def Kuu_kernel_GPinducingvariables(inducing_variable: InducingVariables, kernel: Kernel, jitter=0.0): GP_IV = inducing_variable.GP_IV Kuu = kernel.K(GP_IV) Kuu += jitter * tf.eye(tf.shape(Kuu)[0], dtype=Kuu.dtype) return Kuu
def __init__(self, base_kern, len_seqs, len_windows, num_features, normalized=True): Kernel.__init__(self, len_seqs * num_features) self.len_seqs = len_seqs self.len_windows = len_windows self.base_kern = base_kern self.num_features = num_features self.normalized = normalized self.variance = Parameter(1.0, transform=transforms.positive, dtype=settings.float_type) if self.base_kern.input_dim != len_windows * num_features: raise ValueError( "Base_kern input dimensions must be consistent with window length." )
def _conditional_train( Xnew: tf.Tensor, inducing_variable: InducingVariables, kernel: Kernel, f: tf.Tensor, *, full_cov=False, full_output_cov=False, q_sqrt=None, white=False, ): """ Single-output GP conditional. The covariance matrices used to calculate the conditional have the following shape: - Kuu: [M, M] - Kuf: [M, N] - Kff: [N, N] Further reference ----------------- - See `gpflow.conditionals._conditional` (below) for a detailed explanation of conditional in the single-output case. - See the multiouput notebook for more information about the multiouput framework. Parameters ---------- :param Xnew: data matrix, size [N, D]. :param f: data matrix, [M, R] :param full_cov: return the covariance between the datapoints :param full_output_cov: return the covariance between the outputs. NOTE: as we are using a single-output kernel with repetitions these covariances will be zero. :param q_sqrt: matrix of standard-deviations or Cholesky matrices, size [M, R] or [R, M, M]. :param white: boolean of whether to use the whitened representation :return: - mean: [N, R] - variance: [N, R], [R, N, N], [N, R, R] or [N, R, N, R] Please see `gpflow.conditional._expand_independent_outputs` for more information about the shape of the variance, depending on `full_cov` and `full_output_cov`. """ Kmm = Kuu(inducing_variable, kernel, jitter=default_jitter()) # [M, M] Kmn = Kuf(inducing_variable, kernel, Xnew) # [M, N] Knn = kernel.diag_tr() #uses optimzied function to calculate the covariances fmean, fvar = base_conditional( Kmn, Kmm, Knn, f, full_cov=full_cov, q_sqrt=q_sqrt, white=white ) # [N, R], [R, N, N] or [N, R] return fmean, expand_independent_outputs(fvar, full_cov, full_output_cov)
def __init__(self, base_kern): Kernel.__init__(self, input_dim=base_kern.input_dim + 1) self.kern = base_kern
def __init__(self, input_dim, output_dim, active_dims=None, name=None): Kernel.__init__(self, active_dims, name) self.input_dim = input_dim self.output_dim = output_dim
def independent_multisample_sample_conditional(Xnew: tf.Tensor, feat: InducingPoints, kern: Kernel, f: tf.Tensor, *, full_cov=False, full_output_cov=False, q_sqrt=None, white=False): """ Multisample, single-output GP conditional. NB if full_cov=False is required, this functionality can be achieved by reshaping Xnew to SN x D nd using conditional. The purpose of this function is to compute full covariances in batch over S samples. The covariance matrices used to calculate the conditional have the following shape: - Kuu: M x M - Kuf: S x M x N - Kff: S x N or S x N x N ---------- :param Xnew: data matrix, size S x N x D. :param f: data matrix, M x R :param full_cov: return the covariance between the datapoints :param full_output_cov: return the covariance between the outputs. Must be False :param q_sqrt: matrix of standard-deviations or Cholesky matrices, size M x R or R x M x M. :param white: boolean of whether to use the whitened representation :return: - mean: S x N x R - variance: S x N x R, S x R x N x N """ if full_output_cov: raise NotImplementedError Kmm = Kuu(feat, kern, jitter=settings.numerics.jitter_level) # M x M S, N, D = tf.shape(Xnew)[0], tf.shape(Xnew)[1], tf.shape(Xnew)[2] M = tf.shape(Kmm)[0] Kmn_M_SN = Kuf(feat, kern, tf.reshape(Xnew, [S * N, D])) # M x SN Knn = kern.K(Xnew) if full_cov else kern.Kdiag(Xnew) # S x N or S x N x N num_func = tf.shape(f)[1] # (=R) Lm = tf.cholesky(Kmm) # M x M # Compute the projection matrix A A_M_SN = tf.matrix_triangular_solve(Lm, Kmn_M_SN, lower=True) A = tf.transpose(tf.reshape(A_M_SN, [M, S, N]), [1, 0, 2]) # S x M x N # compute the covariance due to the conditioning if full_cov: fvar = Knn - tf.matmul(A, A, transpose_a=True) # S x N x N fvar = tf.tile(fvar[:, None, :, :], [1, num_func, 1, 1]) # S x R x N x N else: fvar = Knn - tf.reduce_sum(tf.square(A), -2) # S x N fvar = tf.tile(fvar[:, None, :], [1, num_func, 1]) # S x R x N # another backsubstitution in the unwhitened case if not white: A_M_SN = tf.matrix_triangular_solve(tf.transpose(Lm), A_M_SN, lower=False) A = tf.transpose(tf.reshape(A_M_SN, [M, S, N]), [1, 0, 2]) # S x M x N # construct the conditional mean fmean = tf.matmul(A, tf.tile(f[None, :, :], [S, 1, 1]), transpose_a=True) # S x N x R # fmean = tf.einsum('snm,nr->smr', A, f) # S x N x R if q_sqrt is not None: if q_sqrt.get_shape().ndims == 2: LTA = A[:, None, :, :] * tf.transpose(q_sqrt)[None, :, :, None] # S x R x M x N elif q_sqrt.get_shape().ndims == 3: # L = tf.tile(tf.matrix_band_part(q_sqrt, -1, 0)[None, :, :, :], [S, 1, 1, 1]) # S x R x M x M # A_tiled = tf.tile(tf.expand_dims(A, 1), tf.stack([1, num_func, 1, 1])) # S x R x M x N # LTA = tf.matmul(L, A_tiled, transpose_a=True) # S x R x M x N LTA = tf.einsum('rMm,sMn->srmn', tf.matrix_band_part(q_sqrt, -1, 0), A) else: # pragma: no cover raise ValueError("Bad dimension for q_sqrt: %s" % str(q_sqrt.get_shape().ndims)) if full_cov: fvar = fvar + tf.matmul(LTA, LTA, transpose_a=True) # S x R x N x N else: fvar = fvar + tf.reduce_sum(tf.square(LTA), 2) # S x R x N if not full_cov: z = tf.random_normal(tf.shape(fmean), dtype=settings.float_type) fvar = tf.matrix_transpose(fvar) # S x N x R sample = fmean + z * fvar**0.5 else: fmean_SRN1 = tf.transpose(fmean, [0, 2, 1])[:, :, :, None] z = tf.random_normal(tf.shape(fmean_SRN1), dtype=settings.float_type) sample_SRN1 = fmean + tf.matmul(tf.cholesky(fvar), z) sample = tf.transpose(sample_SRN1[:, :, :, 0], [0, 2, 1]) return sample, fmean, fvar # fmean is S x N x R, fvar is S x R x N x N or S x N x R