def latent_functions_prior(Q,
lenghtscale=None,
variance=None,
input_dim=None,
ARD=False,
inv_l=False):
if lenghtscale is None:
lenghtscale = np.random.rand(Q)
else:
lenghtscale = lenghtscale
if variance is None:
variance = np.random.rand(Q)
else:
variance = variance
kern_list = []
for q in range(Q):
kern_q = kern.RBF(input_dim=input_dim,
lengthscale=lenghtscale[q],
variance=variance[q],
name='rbf',
ARD=ARD,
inv_l=inv_l) #+ kern.White(input_dim)# \
kern_q.name = 'kern_q' + str(q)
kern_list.append(kern_q)
return kern_list
def __init__(self, X, Y, Z):
BlackBox.__init__(self, X, Y)
#Z = 2.0 * np.random.rand(int(np.sqrt(X.shape[0])), X.shape[1])
K = kern.RBF(X.shape[1], 1.0, 1.0 * np.ones(X.shape[1]), ARD=True)
self.m = models.SparseGPRegression(X, Y, Z=Z,
kernel=K) # Z is "inducing inputs"
self.m.optimize('bfgs', max_iters=200)
def __init__(self,
X,
Y,
kernel=None,
Y_metadata=None,
changepoint=0,
changepointDim=0):
Ny = Y.shape[0]
if Y_metadata is None:
Y_metadata = { #'output_index':np.arange(Ny)[:,None],
'side':
np.array([
0 if x < changepoint else 1 for x in X[:, changepointDim]
])[:, None]
}
else:
assert Y_metadata['output_index'].shape[0] == Ny
if kernel is None:
kernel = kern.RBF(X.shape[1])
#Likelihood
#likelihoods_list = [likelihoods.Gaussian(name="Gaussian_noise_%s" %j) for j in range(Ny)]
# noise_terms = np.unique(Y_metadata['output_index'].flatten())
# likelihoods_list = [likelihoods.Gaussian(name="Gaussian_noise_%s" %j) for j in noise_terms]
side1Noise = likelihoods.Gaussian(name="Gaussian_noise_side1")
side2Noise = likelihoods.Gaussian(name="Gaussian_noise_side2")
#likelihoods_list = [side1Noise if x < changepoint else side2Noise for x in X[:,changepointDim]]
likelihood = MixedNoise_twoSide(side1Noise, side2Noise)
super(GPHeteroscedasticRegression_twoSided,
self).__init__(X, Y, kernel, likelihood, Y_metadata=Y_metadata)
def __init__(self,
X,
Y,
kernel=None,
Y_metadata=None,
normalizer=None,
noise_var=1.,
mean_function=None,
A=None):
if kernel is None:
kernel = kern.RBF(X.shape[1])
likelihood = likelihoods.Gaussian(variance=noise_var)
super(GPRegression_Group, self).__init__(X,
Y,
kernel,
likelihood,
name='GP regression group',
Y_metadata=Y_metadata,
normalizer=normalizer,
mean_function=mean_function)
self.inference_method = ExactGaussianInferenceGroup()
self.A = A
def __init__(self,
X,
Y,
kernel=None,
warping_function=None,
warping_terms=3):
if kernel is None:
kernel = kern.RBF(X.shape[1])
if warping_function == None:
self.warping_function = TanhWarpingFunction_d(warping_terms)
self.warping_params = (
np.random.randn(self.warping_function.n_terms * 3 + 1, ) * 1)
else:
self.warping_function = warping_function
self.scale_data = False
if self.scale_data:
Y = self._scale_data(Y)
self.has_uncertain_inputs = False
self.Y_untransformed = Y.copy()
self.predict_in_warped_space = False
likelihood = likelihoods.Gaussian()
GP.__init__(self,
X,
self.transform_data(),
likelihood=likelihood,
kernel=kernel)
self.link_parameter(self.warping_function)
def __init__(self,
X,
Y,
kernel=None,
warping_function=None,
warping_terms=3,
normalizer=False):
if kernel is None:
kernel = kern.RBF(X.shape[1])
if warping_function == None:
self.warping_function = TanhFunction(warping_terms)
self.warping_params = (
np.random.randn(self.warping_function.n_terms * 3 + 1) * 1)
else:
self.warping_function = warping_function
likelihood = likelihoods.Gaussian()
super(WarpedGP, self).__init__(X,
Y.copy(),
likelihood=likelihood,
kernel=kernel,
normalizer=normalizer)
self.Y_normalized = self.Y_normalized.copy()
self.Y_untransformed = self.Y_normalized.copy()
self.predict_in_warped_space = True
self.link_parameter(self.warping_function)
def test_missing_data(self):
from GPy import kern
from GPy.models.bayesian_gplvm_minibatch import BayesianGPLVMMiniBatch
from GPy.examples.dimensionality_reduction import _simulate_matern
D1, D2, D3, N, num_inducing, Q = 13, 5, 8, 400, 3, 4
_, _, Ylist = _simulate_matern(D1, D2, D3, N, num_inducing, False)
Y = Ylist[0]
inan = np.random.binomial(1, .9, size=Y.shape).astype(
bool) # 80% missing data
Ymissing = Y.copy()
Ymissing[inan] = np.nan
k = kern.Linear(Q, ARD=True) + kern.White(Q,
np.exp(-2)) # + kern.bias(Q)
m = BayesianGPLVMMiniBatch(Ymissing,
Q,
init="random",
num_inducing=num_inducing,
kernel=k,
missing_data=True)
assert (m.checkgrad())
k = kern.RBF(Q, ARD=True) + kern.White(Q, np.exp(-2)) # + kern.bias(Q)
m = BayesianGPLVMMiniBatch(Ymissing,
Q,
init="random",
num_inducing=num_inducing,
kernel=k,
missing_data=True)
assert (m.checkgrad())
def __init__(self,
X_list,
Y_list,
kernel=None,
likelihoods_list=None,
mean_function=None,
name='GPCR',
W_rank=1,
kernel_name='coreg'):
# Input and Output
X, Y, self.output_index = util.multioutput.build_XY(X_list, Y_list)
Ny = len(Y_list)
# Kernel
if kernel is None:
kernel = kern.RBF(X.shape[1] - 1)
kernel = util.multioutput.ICM(input_dim=X.shape[1] - 1,
num_outputs=Ny,
kernel=kernel,
W_rank=1,
name=kernel_name)
# Likelihood
likelihood = util.multioutput.build_likelihood(Y_list,
self.output_index,
likelihoods_list)
super(GPCoregionalizedWithMeanRegression,
self).__init__(X,
Y,
kernel,
likelihood,
mean_function,
Y_metadata={'output_index': self.output_index})
def test_missing_data(self):
from GPy import kern
from GPy.models.bayesian_gplvm_minibatch import BayesianGPLVMMiniBatch
from GPy.examples.dimensionality_reduction import _simulate_matern
D1, D2, D3, N, num_inducing, Q = 13, 5, 8, 400, 3, 4
_, _, Ylist = _simulate_matern(D1, D2, D3, N, num_inducing, False)
Y = Ylist[0]
inan = np.random.binomial(1, .9, size=Y.shape).astype(bool) # 80% missing data
Ymissing = Y.copy()
Ymissing[inan] = np.nan
k = kern.Linear(Q, ARD=True) + kern.White(Q, np.exp(-2)) # + kern.bias(Q)
m = BayesianGPLVMMiniBatch(Ymissing, Q, init="random", num_inducing=num_inducing,
kernel=k, missing_data=True)
assert(m.checkgrad())
mul, varl = m.predict(m.X)
k = kern.RBF(Q, ARD=True) + kern.White(Q, np.exp(-2)) # + kern.bias(Q)
m2 = BayesianGPLVMMiniBatch(Ymissing, Q, init="random", num_inducing=num_inducing,
kernel=k, missing_data=True)
assert(m.checkgrad())
m2.kern.rbf.lengthscale[:] = 1e6
m2.X[:] = m.X.param_array
m2.likelihood[:] = m.likelihood[:]
m2.kern.white[:] = m.kern.white[:]
mu, var = m.predict(m.X)
np.testing.assert_allclose(mul, mu)
np.testing.assert_allclose(varl, var)
q50 = m.predict_quantiles(m.X, (50,))
np.testing.assert_allclose(mul, q50[0])
def standard_models(X):
"""
Return kernels for model selection
"""
from GPy import kern
return [
['Mat+Lin', kern.Matern32(X.shape[1]) + kern.Linear(X.shape[1], variances=.01) + kern.Bias(X.shape[1])],
['Exp+Lin', kern.Exponential(X.shape[1]) + kern.Linear(X.shape[1], variances=.01) + kern.Bias(X.shape[1])],
['RBF+Lin', kern.RBF(X.shape[1]) + kern.Linear(X.shape[1], variances=.01) + kern.Bias(X.shape[1])],
['Lin', kern.Linear(X.shape[1], variances=.01) + kern.Bias(X.shape[1])],
]
def main():
sample_info = pd.read_csv('MOB_sample_info.csv', index_col=0)
df = pd.read_csv('data/Rep11_MOB_0.csv', index_col=0)
df = df.loc[sample_info.index]
df = df.T[df.sum(0) >= 3].T # Filter practically unobserved genes
dfm = NaiveDE.stabilize(df.T).T
res = NaiveDE.regress_out(sample_info, dfm.T, 'np.log(total_counts)').T
X = sample_info[['x', 'y']].values
times = pd.DataFrame(columns=['N', 'time'])
Ns = [50, 100, 200, 300, 500, 750, 1000, 2000]
j = 0
for N in Ns:
for i in range(5):
Y = res.sample(N, axis=1).values.T
t0 = time()
m = GPclust.MOHGP(X=X,
Y=Y,
kernF=kern.RBF(2) + kern.Bias(2),
kernY=kern.RBF(1) + kern.White(1),
K=5,
prior_Z='DP')
m.hyperparam_opt_args['messages'] = False
m.optimize(step_length=0.1, verbose=False, maxiter=2000)
times.loc[j] = [N, time() - t0]
print(times.loc[j])
j += 1
times.to_csv('AEH_times.csv')
def fit_gaussian_process(self):
"""
Fits a Gaussian process on the Collection while saving the GP and the kernel
"""
# RBF = radial basis function / squared exponential by default
self.gp_kernel = kern.RBF(input_dim=self.GP_INPUT_DIM,
variance=self.GP_VARIANCE,
lengthscale=self.GP_LENGTH_SCALE)
x, y = self.collection.obs_times, self.collection.obs_seqs_norm
self.fit_gp, self.gp_kernel = Metrics._fit_gaussian_process(
x, y, self.gp_kernel, self.NUM_OPTIMIZE_RESTARTS)
def _fit_gaussian_process(x,
y,
kernel=kern.RBF(1, 1., 10.),
num_restarts: int = 7):
"""
Fits a Gaussian process
"""
x, y = Metrics._prepare_inputs_for_fitting_gp(x, y)
gp = models.GPRegression(x, y, kernel)
gp.optimize_restarts(num_restarts=num_restarts, messages=False)
return gp, kernel
def optimize(self,
views,
latent_dims=7,
messages=True,
max_iters=8e3,
save_model=False):
if (self.kernel):
if (self.kernel == 'rbf'):
print("Chosen kernel: RBF")
print("Chosen lengthscale: " + self.lengthscale)
k = kern.RBF(latent_dims,
ARD=True,
lengthscale=self.lengthscale) + kern.White(
latent_dims,
variance=1e-4) + GPy.kern.Bias(latent_dims)
elif (self.kernel == 'linear'):
print("Chosen kernel: Linear")
k = kern.Linear(latent_dims, ARD=True) + kern.White(
latent_dims, variance=1e-4) + GPy.kern.Bias(latent_dims)
else:
print("No kernel or chosen - using RBF with lengthscale 10...")
k = kern.RBF(latent_dims, ARD=True, lengthscale=10) + kern.White(
latent_dims, variance=1e-4) + GPy.kern.Bias(latent_dims)
print("Number of inducing inputs: " + str(self.num_inducing))
m = MRD(views,
input_dim=latent_dims,
num_inducing=self.num_inducing,
kernel=k,
normalizer=False)
print("Optimizing Model...")
m.optimize(messages=True, max_iters=8e3)
if (save_model):
pickle.dump(m, open(save_model, "wb"), protocol=2)
self.model = m
def gen_s_curve(rng, emissions):
"""Generate synthetic data from datasets generating process.
"""
N = 500
J = 100
D = 2
# Generate latent manifold.
# -------------------------
X, t = make_s_curve(N, random_state=rng)
X = np.delete(X, obj=1, axis=1)
X = X / np.std(X, axis=0)
inds = t.argsort()
X = X[inds]
t = t[inds]
# Generate kernel `K` and latent GP-distributed maps `F`.
# -------------------------------------------------------
K = kern.RBF(input_dim=D, lengthscale=1).K(X)
F = rng.multivariate_normal(np.zeros(N), K, size=J).T
# Generate emissions using `F` and/or `K`.
# ----------------------------------------
if emissions == 'bernoulli':
P = logistic(F)
Y = rng.binomial(1, P).astype(np.double)
return Dataset('s-curve', False, Y, X, F, K, None, t)
if emissions == 'gaussian':
Y = F + np.random.normal(0, scale=0.5, size=F.shape)
return Dataset('s-curve', False, Y, X, F, K, None, t)
elif emissions == 'multinomial':
C = 100
pi = np.exp(F - logsumexp(F, axis=1)[:, None])
Y = np.zeros(pi.shape)
for n in range(N):
Y[n] = rng.multinomial(C, pi[n])
return Dataset('s-curve', False, Y, X, F, K, None, t)
elif emissions == 'negbinom':
P = logistic(F)
R = np.arange(1, J + 1, dtype=float)
Y = rng.negative_binomial(R, 1 - P)
return Dataset('s-curve', False, Y, X, F, K, R, t)
else:
assert (emissions == 'poisson')
theta = np.exp(F)
Y = rng.poisson(theta)
return Dataset('s-curve', False, Y, X, F, K, None, t)
def latent_functions_prior(Q, lenghtscale=None, variance=None, input_dim=None):
if lenghtscale is None:
lenghtscale = np.random.rand(Q)
else:
lenghtscale = lenghtscale
if variance is None:
variance = np.random.rand(Q)
else:
variance = variance
kern_list = []
for q in range(Q):
####### RBF GP prior #######
kern_q = kern.RBF(input_dim=input_dim, lengthscale=lenghtscale[q], variance=variance[q], name='rbf')# \
kern_q.name = 'kern_q'+str(q)
kern_list.append(kern_q)
return kern_list
def __init__( # pylint:disable=too-many-arguments
self,
X_list,
Y_list,
kernel=None,
normalizer=None,
likelihoods_list=None,
name="GPCR",
W_rank=1,
kernel_name="coreg",
):
# Input and Output
(
X, # pylint:disable=invalid-name
Y, # pylint:disable=invalid-name
self.output_index,
) = util.multioutput.build_XY(X_list, Y_list)
Ny = len(Y_list) # pylint:disable=invalid-name
# Kernel
if kernel is None:
kernel = kern.RBF(X.shape[1] - 1)
kernel = util.multioutput.ICM(
input_dim=X.shape[1] - 1,
num_outputs=Ny,
kernel=kernel,
W_rank=W_rank,
name=kernel_name,
)
# Likelihood
likelihood = util.multioutput.build_likelihood(Y_list,
self.output_index,
likelihoods_list)
super(GPCoregionalizedRegression, self).__init__( # pylint:disable=super-with-arguments
X,
Y,
kernel,
likelihood,
Y_metadata={"output_index": self.output_index},
normalizer=normalizer,
)
def __init__(self,
X_list,
Y_list,
W,
kernel=None,
likelihoods_list=None,
name='GPCR',
W_rank=1,
kernel_name='coreg'):
#Input and Output
X, Y, self.output_index = util.multioutput.build_XY(X_list, Y_list)
Ny = len(Y_list)
self.opt_trajectory = []
self.PEHE_trajectory = []
self.MSE_trajectory = []
self.treatment_assign = W
self.logdetK = 0
#Kernel
if kernel is None:
kernel = kern.RBF(X.shape[1] - 1)
kernel = util.multioutput.ICM(input_dim=X.shape[1] - 1,
num_outputs=Ny,
kernel=kernel,
W_rank=1,
name=kernel_name)
#Likelihood
likelihood = util.multioutput.build_likelihood(Y_list,
self.output_index,
likelihoods_list)
super(CMGP,
self).__init__(X,
Y,
kernel,
likelihood,
inference_method=RiskEmpiricalBayes(),
Y_metadata={'output_index': self.output_index})
self.X = Param("input", X)
def __init__(self,
X,
Y,
kernel=None,
Y_metadata=None,
noise_mult=1.,
known_variances=1.0):
if kernel is None:
kernel = kern.RBF(X.shape[1])
assert known_variances.shape == Y.shape
#Likelihood
likelihood = ScaledHeteroscedasticGaussian(
Y_metadata=Y_metadata,
noise_mult=noise_mult,
known_variances=known_variances)
super(ScaledHeteroscedasticRegression,
self).__init__(X, Y, kernel, likelihood, Y_metadata=Y_metadata)
def __init__(self, Y, dim_down, dim_up, likelihood, MLP_dims=None, X=None, X_variance=None, init='rand', Z=None, num_inducing=10, kernel=None, inference_method=None, uncertain_inputs=True,mpi_comm=None, mpi_root=0, back_constraint=True, name='mrd-view'):
self.uncertain_inputs = uncertain_inputs
self.layer_lower = None
self.scale = 1.
if back_constraint:
from .mlp import MLP
from copy import deepcopy
self.encoder = MLP([dim_down, int((dim_down+dim_up)*2./3.), int((dim_down+dim_up)/3.), dim_up] if MLP_dims is None else [dim_down]+deepcopy(MLP_dims)+[dim_up])
X = self.encoder.predict(Y.mean.values if isinstance(Y, VariationalPosterior) else Y)
X_variance = 0.0001*np.ones(X.shape)
self.back_constraint = True
else:
self.back_constraint = False
if Z is None:
Z = np.random.rand(num_inducing, dim_up)*2-1. #np.random.permutation(X.copy())[:num_inducing]
assert Z.shape[1] == X.shape[1]
if likelihood is None: likelihood = likelihoods.Gaussian(variance=Y.var()*0.01)
if uncertain_inputs: X = NormalPosterior(X, X_variance)
if kernel is None: kernel = kern.RBF(dim_up, ARD = True)
# The command below will also give the field self.X to the view.
super(MRDView, self).__init__(X, Y, Z, kernel, likelihood, inference_method=inference_method, mpi_comm=mpi_comm, mpi_root=mpi_root, name=name)
if back_constraint: self.link_parameter(self.encoder)
if self.uncertain_inputs and self.back_constraint:
from GPy import Param
from GPy.core.parameterization.transformations import Logexp
self.X_var_common = Param('X_var',X_variance[0].copy(),Logexp())
self.link_parameters(self.X_var_common)
# There's some redundancy in the self.Xv and self.X. Currently we use self.X for the likelihood part and all calculations part,
# self.Xv is only used for the self.Xv.gradient part.
# This is redundant but it's there in case we want to do the product of experts MRD model.
self.Xv = self.X
def __init__(self, layer_lower, dim_down, dim_up, likelihood, X=None, X_variance=None, init='PCA', Z=None, num_inducing=10, kernel=None, inference_method=None, uncertain_inputs=True,mpi_comm=None, mpi_root=0, back_constraint=True, encoder=None, auto_update=True, name='layer'):
self.uncertain_inputs = uncertain_inputs
self.layer_lower = layer_lower
Y = self.Y if self.layer_lower is None else self.layer_lower.X
self.back_constraint = back_constraint
from deepgp.util.util import initialize_latent
if X is None: X, _ = initialize_latent(init, Y.shape[0], dim_up, Y.mean.values if isinstance(Y, VariationalPosterior) else Y)
if X_variance is None: X_variance = 0.01*np.ones(X.shape) + 0.01*np.random.rand(*X.shape)
if Z is None:
if self.back_constraint: Z = np.random.rand(num_inducing, dim_up)*2-1.
else:
if num_inducing<=X.shape[0]:
Z = X[np.random.permutation(X.shape[0])[:num_inducing]].copy()
else:
Z_more = np.random.rand(num_inducing-X.shape[0],X.shape[1])*(X.max(0)-X.min(0))+X.min(0)
Z = np.vstack([X.copy(),Z_more])
assert Z.shape[1] == X.shape[1]
if mpi_comm is not None:
from ..util.parallel import broadcastArrays
broadcastArrays([Z], mpi_comm, mpi_root)
if uncertain_inputs: X = NormalPosterior(X, X_variance)
if kernel is None: kernel = kern.RBF(dim_up, ARD = True)
assert kernel.input_dim==X.shape[1], "The dimensionality of input has to be equal to the input dimensionality of kernel!"
self.Kuu_sigma = Param('Kuu_var', np.zeros(num_inducing)+1e-3, Logexp())
super(Layer, self).__init__(X, Y, Z, kernel, likelihood, inference_method=inference_method, mpi_comm=mpi_comm, mpi_root=mpi_root, auto_update=auto_update, name=name)
self.link_parameter(self.Kuu_sigma)
if back_constraint: self.encoder = encoder
if self.uncertain_inputs and not self.back_constraint:
self.link_parameter(self.X)
def main(args):
(training_file, label_file, test_file, test_label, unlabel, n_dim,
output) = args
X = load_feat(training_file)
y = load_label(label_file)
X = np.asarray(X)
y = np.asarray(y)
U = load_feat(unlabel)
U = np.asarray(U[:10000])
new_dim = int(n_dim)
k = kern.RBF(new_dim, ARD=True)
#m = GPy.models.GPRegression(X, y)
print 'reduction model'
#m_red = BayesianGPLVMMiniBatch(X, new_dim, init="random", num_inducing=50,
# kernel=k, missing_data=True)
m_U = GPy.models.SparseGPLVM(U, new_dim, kernel=k, num_inducing=50)
#m_red.Ytrue = U
print 'reduction optimize'
m_U.optimize(optimizer='bfgs', max_iters=50)
u_params = m_U.parameters
m_O = GPy.models.SparseGPLVM(X, new_dim, kernel=k, num_inducing=50)
m_O.parameters = u_params
m_O.update_model()
X = m_O.X.values
#print dir(m_O.X)
#print m_O.X.values
print 'gp model'
m = GPy.models.SparseGPRegression(X, y, num_inducing=50)
print 'gp optimize'
m.optimize(optimizer='bfgs', max_iters=50)
test_X = load_feat(test_file)
test_X = np.asarray(test_X)
test_y = load_label(test_label)
test_y = np.asarray(test_y)
#test_latent = m_red.predict(test_X)[0]
#print test_latent.shape
#sys.exit(1)
#m_redTest = BayesianGPLVMMiniBatch(test_X, new_dim, init="random", num_inducing=50,
# kernel=k, missing_data=True)
m_test = GPy.models.SparseGPLVM(test_X, new_dim, num_inducing=50)
m_test.parameters = u_params
m_test.update_model()
test_latent = m_test.X.values
#print test_latent.shape
#sys.exit(1)
pred = m.predict(test_latent)[0]
#TODO test_X to latent space!!!
mae = mean_absolute_error(test_y, pred)
mse = mean_squared_error(test_y, pred)
print 'MAE: ', mae
print 'RMSE: ', sqrt(mse)
print 'pearson:', sp.stats.pearsonr(test_y, pred)[0]
print 'true: ', mquantiles(test_y, prob=[0.1, 0.9])
print 'pred: ', mquantiles(pred, prob=[0.1, 0.9])
print 'resid: ', np.mean(test_y - pred)
print 'r-sqr: ', sp.stats.linregress(test_y[:, 0], pred[:, 0])[2]**2
#with open(output, 'w') as output:
# for p in pred:
# print >>output, p[0]
return
def __init__(self,
layer_upper,
Xs,
X_win=0,
Us=None,
U_win=1,
Z=None,
num_inducing=10,
kernel=None,
inference_method=None,
likelihood=None,
noise_var=1.,
inducing_init='kmeans',
back_cstr=False,
MLP_dims=None,
name='layer'):
self.layer_upper = layer_upper
self.nSeq = len(Xs)
self.X_win = X_win # if X_win==0, it is not autoregressive.
self.X_dim = Xs[0].shape[1]
self.Xs_flat = Xs
self.X_observed = False if isinstance(Xs[0],
VariationalPosterior) else True
self.withControl = Us is not None
self.U_win = U_win
self.U_dim = Us[0].shape[1] if self.withControl else None
self.Us_flat = Us
if self.withControl:
assert len(Xs) == len(
Us
), "The number of signals should be equal to the number controls!"
if not self.X_observed and back_cstr:
self._init_encoder(MLP_dims)
self.back_cstr = True
else:
self.back_cstr = False
self._init_XY()
if Z is None:
if not back_cstr and inducing_init == 'kmeans':
from sklearn.cluster import KMeans
m = KMeans(n_clusters=num_inducing, n_init=1000, max_iter=100)
m.fit(self.X.mean.values.copy())
Z = m.cluster_centers_.copy()
else:
Z = np.random.randn(num_inducing, self.X.shape[1])
assert Z.shape[1] == self.X.shape[1]
if kernel is None: kernel = kern.RBF(self.X.shape[1], ARD=True)
if inference_method is None: inference_method = VarDTC()
if likelihood is None:
likelihood = likelihoods.Gaussian(variance=noise_var)
self.normalPrior, self.normalEntropy = NormalPrior(), NormalEntropy()
super(Layer, self).__init__(self.X,
self.Y,
Z,
kernel,
likelihood,
inference_method=inference_method,
name=name)
if not self.X_observed:
if back_cstr:
assert self.X_win > 0
self.link_parameters(*(self.init_Xs + self.Xs_var +
[self.encoder]))
else:
self.link_parameters(*self.Xs_flat)
("GP anisotropic RBF", ["All"], gp.GaussianProcessRegressor(kernel=gp.kernels.RBF(length_scale=np.array([1]*n_feats)))),
("GP ARD", ["All"], gp.GaussianProcessRegressor(kernel=ard_kernel(sigma=1.2, length_scale=np.array([1]*n_feats)))),
("GP isotropic matern nu=0.5", None, gp.GaussianProcessRegressor(kernel=gp.kernels.Matern(nu=0.5))),
("GP isotropic matern nu=1.5", None, gp.GaussianProcessRegressor(kernel=gp.kernels.Matern(nu=1.5))),
("GP isotropic matern nu=2.5", None, gp.GaussianProcessRegressor(kernel=gp.kernels.Matern(nu=2.5))),
# bad performance
("GP dot product", ["CFS", "CIFE", "All"], gp.GaussianProcessRegressor(kernel=gp.kernels.DotProduct())),
# 3-th leading minor not positive definite
# ("GP exp sine squared", gp.GaussianProcessRegressor(kernel=gp.kernels.ExpSineSquared())),
("GP rational quadratic", None, gp.GaussianProcessRegressor(kernel=gp.kernels.RationalQuadratic())),
("GP white kernel", None, gp.GaussianProcessRegressor(kernel=gp.kernels.WhiteKernel())),
("GP abs_exp", None, gp.GaussianProcess(corr='absolute_exponential')),
("GP squared_exp", ["All"], gp.GaussianProcess(corr='squared_exponential')),
("GP cubic", None, gp.GaussianProcess(corr='cubic')),
("GP linear", None, gp.GaussianProcess(corr='linear')),
("GP RBF ARD", ["All"], RBF_ARD_WRAPPER(kern.RBF(input_dim=n_feats, variance=1., lengthscale=np.array([1]*n_feats), ARD=True)))]
models_rmse = []
for name, featSelectionMode, model in classifiers:
modes = featSelectionMode
if featSelectionMode==None:
modes = featSelectionFns.keys()
rmses = []
for eaMode in modes:
bitVec = bitVecs[eaMode]
model.fit(X_train[:,bitVec], y_train[:])
rmse_train = sqrt(mean_squared_error(y_train, model.predict(X_train[:,bitVec])))
rmse_predict = sqrt(mean_squared_error(y_dev, model.predict(X_dev[:,bitVec])))
rmses.append([name + '('+eaMode+')', rmse_train, rmse_predict])
print(name + '('+eaMode+')')
1.0, (1e-3, 1e3)) + sk_kern.WhiteKernel()
clf = GPR(kernel=kernel,
alpha=1e-10,
optimizer="fmin_l_bfgs_b",
n_restarts_optimizer=20,
normalize_y=True)
clf.fit(x_train.reshape(-1, 1), y_train)
pred_mean, pred_var = clf.predict(x_test, return_std=True)
plot_result(x_test=x_test, mean=pred_mean[:, 0], std=pred_var)
plt.title("Scikit-learn")
plt.legend()
plt.savefig("sklern_predict.png", dpi=150)
plt.close("all")
#Gpy
kern = gp_kern.RBF(input_dim=1) + gp_kern.Bias(
input_dim=1) + gp_kern.PeriodicExponential(input_dim=1)
gpy_model = GPy.models.GPRegression(X=x_train.reshape(-1, 1),
Y=y_train,
kernel=kern,
normalizer=None)
gpy_model.optimize()
pred_mean, pred_var = gpy_model.predict(x_test.reshape(-1, 1), )
pred_std = pred_var**0.5
plot_result(x_test, mean=pred_mean[:, 0], std=pred_std[:, 0])
plt.legend()
plt.title("GPy")
plt.savefig("GPy_predict.png", dpi=150)
plt.close("all")
def SE(): return _Gk.RBF(1) def PER(): return _Pk.PureStdPeriodicKernel(1)
