def test_inference_deepGP():
gp1 = GPRegression(
X, None,
RBF(input_dim=3,
variance=torch.tensor(3.),
lengthscale=torch.tensor(2.)))
Z, _ = gp1.model()
gp2 = VariationalSparseGP(Z, y2D, Matern32(input_dim=3), Z.clone(),
Gaussian(torch.tensor(1e-6)))
class DeepGP(torch.nn.Module):
def __init__(self, gp1, gp2):
super(DeepGP, self).__init__()
self.gp1 = gp1
self.gp2 = gp2
def model(self):
Z, _ = self.gp1.model()
self.gp2.set_data(Z, y2D)
self.gp2.model()
def guide(self):
self.gp1.guide()
self.gp2.guide()
deepgp = DeepGP(gp1, gp2)
train(deepgp, num_steps=1)
def __init__(self,
input_dim,
feature_dim=None,
mean_fn=None,
embed_fn=None):
super(DMEGP, self).__init__()
# store params
self.input_dim = input_dim
self.feature_dim = feature_dim
# define mean function and embedding function
self.mean_fn = mean_fn
self.embed_fn = embed_fn
# define kernel function
if embed_fn == None:
feature_dim = input_dim
kernel = RBF(feature_dim, lengthscale=torch.ones(feature_dim))
else:
kernel = RBF(feature_dim, lengthscale=torch.ones(feature_dim))
kernel = Warping(kernel, iwarping_fn=self.embed_fn)
if mean_fn != None:
self.mean_fn = Warping_mean(self.mean_fn, self.embed_fn)
# define gaussian process regression model
self.gp_model = GPRegression(
X=torch.ones(1, feature_dim), # dummy
y=None,
kernel=kernel,
mean_function=self.mean_fn)
def test_inference_deepGP():
gp1 = GPRegression(X, None, kernel, name="GPR1")
Z, _ = gp1.model()
gp2 = VariationalSparseGP(Z, y2D, Matern32(input_dim=3), Z.clone(),
likelihood, name="GPR2")
def model():
Z, _ = gp1.model()
gp2.set_data(Z, y2D)
gp2.model()
def guide():
gp1.guide()
gp2.guide()
svi = SVI(model, guide, optim.Adam({}), Trace_ELBO())
svi.step()
def __init__(self, X_curr, u_curr, X_next, option='GP', inducing_size=100, name='GP_DYNAMICS'):
"""
:param X_curr: 2 dim tensor array, state at the current time stamp, H by n
:param u_curr: 2 dim tensor array, control signal at the current time stamp, H by m
:param X_next: 2 dim tensor array, state at the next time stamp, H by n
:param option: use full GP or sparse GP
:param inducing_size: the number of inducing points if using sparse GP
:param name:
"""
super(GP_DYNAMICS).__init__(name)
if option not in ['SSGP', 'GP']:
raise ValueError('undefined regression option for gp model!')
assert(X_curr.dim() == 2 and u_curr.dim() == 2
and X_next.dim() == 2), "all data inputs can only have 2 dimensions! X_curr: {}, u_curr: {}, X_next: {}".format(X_curr.dim(), u_curr.dim(), X_next.dim())
assert(X_curr.size()[1] == u_curr.size()[1] and u_curr.size()[1] == X_next.size()[1]), "all data inputs need to have the same length! X_curr: {}, " \
"u_curr: {}, X_next: {}".format(X_curr.size(), u_curr.size(), X_next.size())
self.X_hat = torch.cat((X_curr, u_curr))
self.dX = X_next - X_curr
self.GP_dyn = []
if option == 'SSGP':
for i in range(self.dX.size()[1]):
kernel = RBF(input_dim=self.X_hat.size()[1], lengthscale=torch.ones(self.X_hat.size()[1]) * 10., variance=torch.tensor(5.0),name="GPs_dim" + str(i) + "_RBF")
range_lis = range(0, self.X_hat.size()[0])
random.shuffle(range_lis)
Xu = self.X_hat[range_lis[0:inducing_size], :]
# need to set the name for different model, otherwise pyro will clear the parameter storage
ssgpmodel = SparseGPRegression(self.X_hat, self.dX[:, i], kernel, Xu, name="SSGPs_model_dim" + str(i), jitter=1e-5)
self.GP_dyn.append(ssgpmodel)
else:
for i in range(self.dX.size()[1]):
kernel = RBF(input_dim=self.X_hat.size()[1], lengthscale=torch.ones(self.X_hat.size()[1]) * 10., variance=torch.tensor(5.0), name="GPs_dim" + str(i) + "_RBF")
gpmodel = GPRegression(self.X_hat, self.dX[:, i], kernel, name="GPs_model_dim" + str(i), jitter=1e-5)
self.GP_dyn.append(gpmodel)
self.option = option
print("for the dynamics model, input dim {} and output dim {}".format(self.X_hat.size()[1], self.dX.size()[1]))
self.Kff_inv = torch.zeros((self.dX.size()[1], self.X_hat.size()[0], self.X_hat.size()[0]))
self.K_var = torch.zeros(self.dX.size()[1], 1)
self.Beta = torch.zeros((self.dX.size()[1], self.X_hat.size()[0]))
self.lengthscale = torch.zeros((self.dX.size()[1], self.X_hat.size()[1]))
self.noise = torch.zeros((self.dX.size()[1], 1))
if self.option == 'SSGP':
self.Xu = torch.zeros((self.dX.size()[1], inducing_size))
def test_inference_deepGP():
gp1 = GPRegression(X, None, kernel, name="GPR1")
Z, _ = gp1.model()
gp2 = VariationalSparseGP(Z,
y2D,
Matern32(input_dim=3),
Z.clone(),
likelihood,
name="GPR2")
def model():
Z, _ = gp1.model()
gp2.set_data(Z, y2D)
gp2.model()
def guide():
gp1.guide()
gp2.guide()
svi = SVI(model, guide, optim.Adam({}), Trace_ELBO())
svi.step()
def define_new_GP(self):
# define kernel function
if self.embed_fn == None:
feature_dim = self.input_dim
kernel = RBF(feature_dim, lengthscale=torch.ones(feature_dim))
else:
feature_dim = self.feature_dim
embed_fn = copy.deepcopy(self.embed_fn)
kernel = RBF(feature_dim, lengthscale=torch.ones(feature_dim))
kernel = Warping(kernel, iwarping_fn=embed_fn)
if self.mean_fn != None:
mean_fn = copy.deepcopy(self.mean_fn)
# define gaussian process regression model
gp_model = GPRegression(
X=torch.ones(1, feature_dim), # dummy
y=None,
kernel=kernel,
mean_function=mean_fn)
return gp_model
def test_mean_function_GPR():
X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()
gpmodule = GPRegression(X, y, kernel, mean_function=mean_fn)
train(gpmodule)
_post_test_mean_function(gpmodule, Xnew, ynew)
def __init__(self, X_s, y_s, X_o, y_o, option='GP', inducing_size=100, name='GP_ADF_RTSS'):
"""
:param X_s: training inputs for the state transition model N by D tensor
:param y_s: training outputs for the state transition model N by E tensor
:param X_o: training inputs for the observation model N by E tensor
:param y_o: training outputs for the observation model N by F tensor
:param state_dim: dimension for the state, D
:param observation_dim: dimension for the output, E
:param transition_kernel: kernel function for the
:param observation_kernel:
:param options:
"""
super(GP_ADF_RTSS, self).__init__(name)
if option not in ['SSGP', 'GP']:
raise ValueError('undefined regression option for gp model!')
assert(X_s.dim() == 2 and y_s.dim() == 2
and X_o.dim() == 2 and y_o.dim() == 2), "all data inputs can only have 2 dimensions"
# # use RBF kernel for state transition model and observation model
# self.state_transition_kernel = RBF(input_dim=state_dim, lengthscale=torch.ones(state_dim) * 0.1)
# self.observation_kernel = RBF(input_dim=observation_dim, lengthscale=torch.ones(observation_dim) * 0.1)
self.X_s = X_s
self.y_s = y_s
self.X_o = X_o
self.y_o = y_o
# print(X_s.dtype)
# print(y_s.dtype)
# print(X_o.dtype)
# print(y_o.dtype)
# choose the model type and initialize based on the option
self.state_transition_model_list = []
self.observation_model_list = []
if option == 'SSGP':
for i in range(self.y_s.size()[1]):
kernel = RBF(input_dim=self.X_s.size()[1], lengthscale=torch.ones(self.X_s.size()[1]) * 10., variance=torch.tensor(5.0),name="GPs_dim" + str(i) + "_RBF")
range_lis = range(0, X_s.size()[0])
random.shuffle(range_lis)
Xu = X_s[range_lis[0:inducing_size], :]
# need to set the name for different model, otherwise pyro will clear the parameter storage
ssgpmodel = SparseGPRegression(X_s, y_s[:, i], kernel, Xu, name="SSGPs_model_dim" + str(i), jitter=1e-5)
self.state_transition_model_list.append(ssgpmodel)
for i in range(self.y_o.size()[1]):
kernel = RBF(input_dim=self.X_o.size()[1], lengthscale=torch.ones(self.X_o.size()[1]) * 10, variance=torch.tensor(5.0), name="GPo_dim" + str(i) + "_RBF")
range_lis = range(0, y_o.size()[0])
random.shuffle(range_lis)
Xu = X_o[range_lis[0:inducing_size], :]
ssgpmodel = SparseGPRegression(X_o, y_o[:, i], kernel, Xu, name="SSGPo_model_dim" + str(i), noise=torch.tensor(2.))
self.state_transition_model_list.append(ssgpmodel)
else:
for i in range(self.y_s.size()[1]):
kernel = RBF(input_dim=self.X_s.size()[1], lengthscale=torch.ones(self.X_s.size()[1]) * 10., variance=torch.tensor(5.0), name="GPs_dim" + str(i) + "_RBF")
gpmodel = GPRegression(X_s, y_s[:, i], kernel, name="GPs_model_dim" + str(i), jitter=1e-5)
self.state_transition_model_list.append(gpmodel)
for i in range(self.y_o.size()[1]):
kernel = RBF(input_dim=self.X_o.size()[1], lengthscale=torch.ones(self.X_o.size()[1]) * 10., variance=torch.tensor(5.0), name="GPo_dim" + str(i) + "_RBF")
gpmodel = GPRegression(X_o, y_o[:, i], kernel, name="GPo_model_dim"+ str(i), noise=torch.tensor(2.))
self.observation_model_list.append(gpmodel)
self.option = option
#
# if model_file:
# self.load_model(model_file)
self.mu_s_curr = torch.zeros(y_s.size()[1])
self.sigma_s_curr = torch.eye(y_s.size()[1])
self.mu_o_curr = torch.zeros(y_o.size()[1])
self.sigma_o_curr = torch.eye(y_s.size()[1])
self.mu_hat_s_curr = torch.zeros(y_s.size()[1])
self.sigma_hat_s_curr = torch.eye(y_s.size()[1])
self.mu_hat_s_prev = torch.zeros(y_s.size()[1])
self.sigma_hat_s_prev = torch.eye(y_s.size()[1])
# For backwards smoothing
self.mu_hat_s_curr_lis = []
self.sigma_hat_s_curr_lis = []
self.mu_s_curr_lis = []
self.sigma_s_curr_lis = []
self.sigma_Xpf_Xcd_lis = []
self.Kff_s_inv = torch.zeros((y_s.size()[1], X_s.size()[0], X_s.size()[0]))
self.Kff_o_inv = torch.zeros((y_o.size()[1], X_o.size()[0], X_o.size()[0]))
self.K_s_var = torch.zeros(y_s.size()[1], 1)
self.K_o_var = torch.zeros(y_o.size()[1], 1)
self.Beta_s = torch.zeros((y_s.size()[1], X_s.size()[0]))
self.Beta_o = torch.zeros((y_o.size()[1], X_o.size()[0]))
self.lengthscale_s = torch.zeros((y_s.size()[1], X_s.size()[1]))
self.lengthscale_o = torch.zeros((y_o.size()[1], X_o.size()[1]))
self.noise_s = torch.zeros((y_s.size()[1], 1))
self.noise_o = torch.zeros((y_o.size()[1], 1))
if self.option == 'SSGP':
self.Xu_s = torch.zeros((y_s.size()[1], inducing_size))
self.Xu_o = torch.zeros((y_o.size()[1], inducing_size))
self.noise_s = torch.zeros((y_s.size()[1], inducing_size))
self.noise_o = torch.zeros((y_o.size()[1], inducing_size))
print("for state transition model, input dim {} and output dim {}".format(X_s.size()[1], y_s.size()[1]))
print("for observation model, input dim {} and output dim {}".format(X_o.size()[1], y_o.size()[1]))
class DMEGP(nn.Module):
"""
This class represents core model in DMEGP for regression.
"""
def __init__(self,
input_dim,
feature_dim=None,
mean_fn=None,
embed_fn=None):
super(DMEGP, self).__init__()
# store params
self.input_dim = input_dim
self.feature_dim = feature_dim
# define mean function and embedding function
self.mean_fn = mean_fn
self.embed_fn = embed_fn
# define kernel function
if embed_fn == None:
feature_dim = input_dim
kernel = RBF(feature_dim, lengthscale=torch.ones(feature_dim))
else:
kernel = RBF(feature_dim, lengthscale=torch.ones(feature_dim))
kernel = Warping(kernel, iwarping_fn=self.embed_fn)
if mean_fn != None:
self.mean_fn = Warping_mean(self.mean_fn, self.embed_fn)
# define gaussian process regression model
self.gp_model = GPRegression(
X=torch.ones(1, feature_dim), # dummy
y=None,
kernel=kernel,
mean_function=self.mean_fn)
def forward(self, X_sup, Y_sup, X_que, loss_fn, lr, n_adapt):
"""
Return p(Y_que|X_sup, Y_sup, X_que).
"""
gp_clone = self.define_new_GP()
params_clone = copy.deepcopy(self.gp_model.state_dict())
gp_clone.load_state_dict(params_clone)
gp_clone.set_data(X_sup, Y_sup)
optimizer = torch.optim.Adam(get_kernel_params(gp_clone), lr=lr)
for _ in range(n_adapt):
optimizer.zero_grad()
loss = loss_fn(gp_clone.model, gp_clone.guide)
loss.backward()
optimizer.step()
y_loc, y_var = gp_clone(X_que, noiseless=False)
return y_loc, y_var, loss
def forward_mean(self, X_que):
"""
Return \mu(X_que) that is predictions of global mean function.
"""
mean_preds = self.gp_model.mean_fn(X_que)
mean_preds = torch.transpose(mean_preds, -1, -2)
return mean_preds
def step(self, X_sup, Y_sup, mean_optim, gp_optim, loss_fn, lr, n_adapt):
"""
Optimize gp 1 step with single time series data.
Following new optimization step.
1. adaptation
2. alternating w and theta
"""
self.gp_model.set_data(X_sup, Y_sup)
mean_optim.zero_grad()
loss = loss_fn(self.gp_model.model, self.gp_model.guide)
loss.backward()
mean_optim.step()
gp_optim.zero_grad()
loss = loss_fn(self.gp_model.model, self.gp_model.guide)
loss.backward()
gp_optim.step()
return loss
def define_new_GP(self):
# define kernel function
if self.embed_fn == None:
feature_dim = self.input_dim
kernel = RBF(feature_dim, lengthscale=torch.ones(feature_dim))
else:
feature_dim = self.feature_dim
embed_fn = copy.deepcopy(self.embed_fn)
kernel = RBF(feature_dim, lengthscale=torch.ones(feature_dim))
kernel = Warping(kernel, iwarping_fn=embed_fn)
if self.mean_fn != None:
mean_fn = copy.deepcopy(self.mean_fn)
# define gaussian process regression model
gp_model = GPRegression(
X=torch.ones(1, feature_dim), # dummy
y=None,
kernel=kernel,
mean_function=mean_fn)
return gp_model
def test_mean_function_GPR():
X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()
model = GPRegression(X, y, kernel, mean_function=mean_fn)
model.optimize(optim.Adam({"lr": 0.01}))
_post_test_mean_function(model, Xnew, ynew)
def test_mean_function_GPR():
X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()
model = GPRegression(X, y, kernel, mean_function=mean_fn)
model.optimize(optim.Adam({"lr": 0.01}))
_post_test_mean_function(model, Xnew, ynew)