def _draw_gp_function(self, X, lengthscale=10.0, kernel_str="RBF"):
if kernel_str == "RBF":
kernel = RBFKernel()
elif kernel_str == "Mat":
kernel = MaternKernel(nu=0.5)
else:
raise Exception("Invalid kernel string: {}".format(kernel_str))
kernel.lengthscale = lengthscale
with torch.no_grad():
lazy_cov = kernel(X)
mean = torch.zeros(lazy_cov.size(0))
mvn = MultivariateNormal(mean, lazy_cov)
Y = mvn.rsample()[:, None]
return Y
def create_bayesian_quadrature_iso_gauss():
x1 = torch.from_numpy(np.array([[-1, 1], [0, 0], [-2, 0.1]]))
x2 = torch.from_numpy(np.array([[-1, 1], [0, 0], [-2, 0.1], [-3, 3]]))
M1 = x1.size()[0]
M2 = x2.size()[0]
D = x1.size()[1]
prior_mean = torch.from_numpy(np.arange(D))[None, :]
prior_variance = 2.
rbf = RBFKernel()
rbf.lengthscale = 1.
kernel = ScaleKernel(rbf)
kernel.outputscale = 1.
bqkernel = QuadratureRBFGaussPrior(kernel, prior_mean, prior_variance)
return bqkernel, x1, x2, M1, M2, D
def create_rbf(sigma2, lengthscale):
rbf = RBFKernel()
rbf.lengthscale = lengthscale
kernel = ScaleKernel(rbf)
kernel.outputscale = sigma2
return kernel
def tracking_expectation(ratio, dim, n_sample=2000, depth=11):
"""
:param ratio: \sigma^2 / lengthscale^2
:param dim:
:param n_sample:
:param depth:
:return:
"""
sigma2 = 1. # default
lengthscale2 = sigma2 / ratio
kernel = RBFKernel()
kernel.lengthscale = np.sqrt(lengthscale2)
# x contains two data points
x = torch.from_numpy(np.array([0., 1.]).astype('float32')).view(2, 1)
# build model
dgp = DeepGP(kernel, depth=depth, dim=dim)
## compute true expectation via recurrence
Kx = kernel(x).evaluate_kernel()
k12 = Kx.detach().numpy()[0, 1]
EZ_1 = 2 * (1 - k12)
true_EZ = [EZ_1]
temp = EZ_1
for d in range(1, depth - 1):
next_EZ = recur(temp, sigma2, lengthscale2, dim=dim)
true_EZ.append(next_EZ)
temp = next_EZ
# sample and collect
for i in range(n_sample):
dgp(x)
collector = dgp.collector
aggs_depth = []
aggs_diff = []
aggs_empirical = []
# post-process sample
for d in range(depth - 1):
samples = collector[d]
samples = np.stack(samples) # n_sample x 2 x dim
diff = np.diff(samples, axis=1) # n_sample x dim
diff = diff ** 2
diff = diff.squeeze()
# take 1 dimension
selected_dim = 0
diff = diff[:, selected_dim]
aggs_depth.extend([d + 1] * n_sample)
aggs_diff.extend(diff.tolist())
aggs_empirical.extend(["empirical"] * n_sample)
## true expectation
aggs_depth.extend(list(range(1, depth)))
aggs_diff.extend(true_EZ)
aggs_empirical.extend(["ours"] * len(true_EZ))
##
## THIS RESULT FROM DUNLOP. BUT CANNOT PLOT SINCE EZ IS TOO BIG
# aggs_depth.extend(list(range(1, depth)))
# aggs_diff.extend(dunlop_EZ)
# aggs_empirical.extend(["Dunlop 2018"]*len(dunlop_EZ))
d = {"Depth": aggs_depth, "Z": aggs_diff, "empirical": aggs_empirical}
df = pd.DataFrame(data=d)
ax = sns.pointplot(x='Depth', y='Z', hue='empirical', data=df, capsize=0.2, markers=["o", "*", "d"], join=False)
ax.set_ylabel(r'Expectation of $Z_l$', fontdict=font)
ax.set_xlabel(r'Layer $l$', fontdict=font)
leg = ax.legend()
ax.set_title(r"${{\sigma^2}}/{{\ell^2}}={}$, $m={}$".format(ratio, dim), fontdict=font)
name = "r_{}_m_{}".format(ratio, dim)
plt.savefig("../figure/track_expectation/" + name + ".png", bbox_extra_artists=(leg,), bbox_inches='tight', dpi=300)
def __init__(
self,
num_outputs,
initial_lengthscale,
initial_inducing_points,
separate_inducing_points=False,
kernel="RBF",
ard=None,
lengthscale_prior=False,
):
n_inducing_points = initial_inducing_points.shape[0]
if separate_inducing_points:
# Use independent inducing points per output GP
initial_inducing_points = initial_inducing_points.repeat(num_outputs, 1, 1)
if num_outputs > 1:
batch_shape = torch.Size([num_outputs])
else:
batch_shape = torch.Size([])
variational_distribution = CholeskyVariationalDistribution(
n_inducing_points, batch_shape=batch_shape
)
variational_strategy = VariationalStrategy(
self, initial_inducing_points, variational_distribution
)
if num_outputs > 1:
variational_strategy = IndependentMultitaskVariationalStrategy(
variational_strategy, num_tasks=num_outputs
)
super().__init__(variational_strategy)
if lengthscale_prior:
lengthscale_prior = SmoothedBoxPrior(math.exp(-1), math.exp(1), sigma=0.1)
else:
lengthscale_prior = None
kwargs = {
"ard_num_dims": ard,
"batch_shape": batch_shape,
"lengthscale_prior": lengthscale_prior,
}
if kernel == "RBF":
kernel = RBFKernel(**kwargs)
elif kernel == "Matern12":
kernel = MaternKernel(nu=1 / 2, **kwargs)
elif kernel == "Matern32":
kernel = MaternKernel(nu=3 / 2, **kwargs)
elif kernel == "Matern52":
kernel = MaternKernel(nu=5 / 2, **kwargs)
elif kernel == "RQ":
kernel = RQKernel(**kwargs)
else:
raise ValueError("Specified kernel not known.")
kernel.lengthscale = initial_lengthscale * torch.ones_like(kernel.lengthscale)
self.mean_module = ConstantMean(batch_shape=batch_shape)
self.covar_module = ScaleKernel(kernel, batch_shape=batch_shape)
