class HetmogpWrapeper(BaseEstimator):
def __init__(self, M=20, vem_iters=3):
self.likelihoods_list = [Bernoulli(), Bernoulli()] # Real + Binary
self.likelihood = HetLikelihood(self.likelihoods_list)
self.Y_metadata = self.likelihood.generate_metadata()
self.D = self.likelihood.num_output_functions(self.Y_metadata)
self.M = M
self.vem_iters = vem_iters
pass
def fit(self, X_l, y_l, X_h, y_h):
input_dim = X_h.shape[1]
X = [X_l, X_h]
Y = [y_l.reshape(-1, 1), y_h.reshape(-1, 1)]
Q = 2 # number of latent functions
ls_q = np.array(([.05] * Q))
var_q = np.array(([.5] * Q))
kern_list = util.latent_functions_prior(Q,
lenghtscale=ls_q,
variance=var_q,
input_dim=input_dim)
#Z = np.linspace(0, 1, self.M)
#Z = Z[:, np.newaxis]
Z = np.random.randn(self.M, input_dim)
self.model = SVMOGP(X=X,
Y=Y,
Z=Z,
kern_list=kern_list,
likelihood=self.likelihood,
Y_metadata=self.Y_metadata)
self.model = VEM(self.model,
stochastic=False,
vem_iters=self.vem_iters,
optZ=True,
verbose=False,
verbose_plot=False,
non_chained=False)
def predict_proba(self, X):
htmogp_1_m, htmogp_1_v = self.model._raw_predict_f(
X, output_function_ind=1)
pos_preds = expit(htmogp_1_m)
return np.hstack((1 - pos_preds, pos_preds))
def predict(self, X):
proba = self.predict_proba(X)[:, 1]
return (proba > 0.5).astype(int)
n_iter = int(config.N_iter)
all_NLPD = []
Times_all = []
ELBO_all = []
random.seed(101)
np.random.seed(101)
ELBO = []
NLPD = []
myTimes = []
Y = Ytrain.copy()
X = Xtrain.copy()
J = likelihood.num_output_functions(Y_metadata) # This function indicates how many J latent functions we need
print('J is:',J)
np.random.seed(myseed)
if not convolved:
if ('toy' in dataset):
ls_q = 1 * np.sqrt(Dim) * (np.random.rand(Q) + 0.001) # 10 * np.ones(Q) era 0.01
elif ('zip_conv' in dataset):
ls_q = 0.1 * np.sqrt(Dim) * (np.random.rand(Q) + 0.001)
else:
ls_q = 0.1 * np.sqrt(Dim) * (np.random.rand(Q) + 0.001) # 10 * np.ones(Q) era 0.01
print("Initial lengthscales uq:", ls_q)
else:
if ('toy1c' in dataset):
ls_q = 0.0001 * np.sqrt(Dim) * (np.random.rand(Q) + 0.001) # 10 * np.ones(Q) era 0.01
lenghtscale = 0.1 * np.sqrt(Dim) * (np.random.rand(J) * np.random.rand(J))
length_Tq = 0.1 * np.sqrt(Dim) * (np.random.rand(Q) * np.random.rand(Q))
def load_toy1_conv(N=1000, input_dim=1):
if input_dim == 2:
Nsqrt = int(N**(1.0 / input_dim))
print('input_dim:', input_dim)
# Q = 5 # number of latent functions
# Heterogeneous Likelihood Definition
# likelihoods_list = [Gaussian(sigma=1.0), Bernoulli()] # Real + Binary
likelihoods_list = [Gaussian(sigma=0.1),
Gaussian(sigma=0.1)] # Real + Binary
# likelihoods_list = [Gaussian(sigma=1.0)]
likelihood = HetLikelihood(likelihoods_list)
Y_metadata = likelihood.generate_metadata()
D = likelihoods_list.__len__()
J = likelihood.num_output_functions(Y_metadata)
Q = 1
"""""" """""" """""" """""" """"""
rescale = 10
Dim = input_dim
if input_dim == 2:
xy = rescale * np.linspace(-1.0, 1.0, Nsqrt)
xx = rescale * np.linspace(-1.0, 1.0, Nsqrt)
XX, XY = np.meshgrid(xx, xy)
XX = XX.reshape(Nsqrt**2, 1)
XY = XY.reshape(Nsqrt**2, 1)
Xtoy = np.hstack((XX, XY))
else:
minis = -rescale * np.ones(Dim)
maxis = rescale * np.ones(Dim)
Xtoy = np.linspace(minis[0], maxis[0], N).reshape(1, -1)
for i in range(Dim - 1):
Xaux = np.linspace(minis[i + 1], maxis[i + 1], N)
Xtoy = np.concatenate(
(Xtoy, Xaux[np.random.permutation(N)].reshape(1, -1)), axis=0)
# Z = np.concatenate((Z, Zaux.reshape(1, -1)), axis=0)
Xtoy = 1.0 * Xtoy.T
def latent_functions_prior(Q,
lengthscale=None,
input_dim=None,
name='kern_q'):
#lenghtscale = rescale * np.array([0.5]) # This is the one used for previous experiments
#lenghtscale = rescale * lengthscale
lenghtscale = lengthscale
variance = 1 * np.ones(Q)
kern_list = []
for q in range(Q):
# print("length:",lenghtscale[q])
# print("var:", variance[q])
kern_q = GPy.kern.RBF(input_dim=input_dim,
lengthscale=lenghtscale[q],
variance=variance[q],
name='rbf')
kern_q.name = name + str(q)
kern_list.append(kern_q)
return kern_list
kern_list_uq = latent_functions_prior(Q,
lengthscale=np.array([0.1]),
input_dim=Dim,
name='kern_q')
kern_list_Gdj = latent_functions_prior(J,
lengthscale=np.array([0.3, 0.7]),
input_dim=Dim,
name='kern_G')
kern_aux = GPy.kern.RBF(input_dim=Dim,
lengthscale=1.0,
variance=1.0,
name='rbf_aux',
ARD=False) + GPy.kern.White(input_dim=Dim)
kern_aux.white.variance = 1e-6
# True U and F functions
def experiment_true_u_functions(kern_list, kern_list_Gdj, X):
Q = kern_list.__len__()
# for d,X in enumerate(X_list):
u_latent = np.zeros((X.shape[0], Q))
np.random.seed(104)
for q in range(Q):
u_latent[:, q] = np.random.multivariate_normal(
np.zeros(X.shape[0]), kern_list[q].K(X))
return u_latent
def experiment_true_f_functions(kern_u, kern_G, kern_aux, X, Q, J):
W = W_lincombination(Q, J)
# print(W)
# for j in range(J):
f_j = np.zeros((X.shape[0], J))
for j in range(J):
for q in range(Q):
util.update_conv_Kff(kern_u[q], kern_G[j], kern_aux)
#f_j += (W[q] * true_u[:, q]).T
f_j[:, j] += W[q][j] * np.random.multivariate_normal(
np.zeros(X.shape[0]), kern_aux.K(X))
# true_f.append(f_d)
return f_j
# True Combinations
def W_lincombination(Q, J):
W_list = []
# q=1
for q in range(Q):
# W_list.append(np.array(([[-0.5], [0.1]])))
if q == 0:
# W_list.append(0.3*np.random.randn(J, 1))
W_list.append(np.array([-0.5, 2.1])[:, None])
elif q == 1:
# W_list.append(2.0 * np.random.randn(J, 1))
W_list.append(np.array([
1.4,
0.3,
])[:, None])
else:
# W_list.append(10.0 * np.random.randn(J, 1)+0.1)
W_list.append(np.array([
0.1,
-0.8,
])[:, None])
return W_list
"""""" """""" """""" """""" """""" ""
# True functions values for inputs X
f_index = Y_metadata['function_index'].flatten()
J = f_index.__len__()
trueF = experiment_true_f_functions(kern_list_uq, kern_list_Gdj, kern_aux,
Xtoy, Q, J)
# if input_dim==2:
# #from mpl_toolkits.mplot3d import Axes3D # noqa: F401 unused import
#
# from matplotlib import cm
# from matplotlib.ticker import LinearLocator, FormatStrFormatter
# fig = plt.figure()
# ax = fig.gca(projection='3d')
#
# # Make data.
# # X = np.arange(-5, 5, 0.25)
# # Y = np.arange(-5, 5, 0.25)
# # X, Y = np.meshgrid(X, Y)
# # R = np.sqrt(X ** 2 + Y ** 2)
# # Z = np.sin(R)
#
# # Plot the surface.
# surf = ax.plot_surface(Xtoy[:,0].reshape(Nsqrt,Nsqrt), Xtoy[:,1].reshape(Nsqrt,Nsqrt), trueF[:,2].reshape(Nsqrt,Nsqrt), cmap=cm.coolwarm,linewidth=0, antialiased=False)
#
# # Customize the z axis.
# #ax.set_zlim(-1.01, 1.01)
# ax.zaxis.set_major_locator(LinearLocator(10))
# ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
#
# # Add a color bar which maps values to colors.
# fig.colorbar(surf, shrink=0.5, aspect=5)
#
# plt.show()
#
# else:
# plt.figure(15)
# plt.plot(trueF[:,1])
# plt.figure(16)
# plt.plot(trueU)
d_index = Y_metadata['d_index'].flatten()
F_true = []
# for i,f_latent in enumerate(trueF):
# if
for t in range(D):
_, num_f_task, _ = likelihoods_list[t].get_metadata()
f = np.empty((Xtoy.shape[0], num_f_task))
for j in range(J):
if f_index[j] == t:
f[:, d_index[j], None] = trueF[:, j][:, None]
F_true.append(f)
# Generating training data Y (sampling from heterogeneous likelihood)
Ytrain = likelihood.samples(F=F_true, Y_metadata=Y_metadata)
#Yreg0 = (Ytrain[0] - Ytrain[0].mean(0)) / (Ytrain[0].std(0))
#Yreg1 = (Ytrain[1] - Ytrain[1].mean(0)) / (Ytrain[1].std(0))
#Ytrain = [Yreg0, Yreg1]
Xtrain = []
for d in range(likelihoods_list.__len__()):
Xtrain.append(Xtoy)
return Xtrain, Ytrain