def __init__(
self,
train_X: Tensor,
train_Y: Tensor,
train_iteration_fidelity: bool = True,
train_data_fidelity: bool = True,
likelihood: Optional[Likelihood] = None,
) -> None:
train_X, train_Y, _ = self._set_dimensions(train_X=train_X,
train_Y=train_Y)
num_fidelity = train_iteration_fidelity + train_data_fidelity
ard_num_dims = train_X.shape[-1] - num_fidelity
active_dimsX = list(range(train_X.shape[-1] - num_fidelity))
rbf_kernel = RBFKernel(
ard_num_dims=ard_num_dims,
batch_shape=self._aug_batch_shape,
lengthscale_prior=GammaPrior(3.0, 6.0),
active_dims=active_dimsX,
)
exp_kernel = ExpDecayKernel(
batch_shape=self._aug_batch_shape,
lengthscale_prior=GammaPrior(3.0, 6.0),
offset_prior=GammaPrior(3.0, 6.0),
power_prior=GammaPrior(3.0, 6.0),
)
ds_kernel = DownsamplingKernel(
batch_shape=self._aug_batch_shape,
offset_prior=GammaPrior(3.0, 6.0),
power_prior=GammaPrior(3.0, 6.0),
)
if train_iteration_fidelity and train_data_fidelity:
active_dimsS1 = [train_X.shape[-1] - 1]
active_dimsS2 = [train_X.shape[-1] - 2]
exp_kernel.active_dims = torch.tensor(active_dimsS1)
ds_kernel.active_dims = torch.tensor(active_dimsS2)
kernel = rbf_kernel * exp_kernel * ds_kernel
elif train_iteration_fidelity or train_data_fidelity:
active_dimsS = [train_X.shape[-1] - 1]
if train_iteration_fidelity:
exp_kernel.active_dims = torch.tensor(active_dimsS)
kernel = rbf_kernel * exp_kernel
else:
ds_kernel.active_dims = torch.tensor(active_dimsS)
kernel = rbf_kernel * ds_kernel
else:
raise UnsupportedError(
"You should have at least one fidelity parameter.")
covar_module = ScaleKernel(
kernel,
batch_shape=self._aug_batch_shape,
outputscale_prior=GammaPrior(2.0, 0.15),
)
super().__init__(train_X=train_X,
train_Y=train_Y,
covar_module=covar_module)
self.to(train_X)
def test_subset_computes_active_downsampling_function_batch(self):
a = torch.tensor([[0.1, 0.2, 0.2], [0.3, 0.4, 0.2],
[0.5, 0.5, 0.5]]).view(3, 3, 1)
a_p = torch.tensor([[0.1, 0.2, 0.2], [0.3, 0.4, 0.2],
[0.5, 0.5, 0.5]]).view(3, 3, 1)
a = torch.cat((a, a_p), 2)
b = torch.tensor([[0.5, 0.6, 0.1], [0.7, 0.8, 0.2],
[0.6, 0.6, 0.5]]).view(3, 3, 1)
power = 1
offset = 1
kernel = DownsamplingKernel(batch_shape=torch.Size([3]),
active_dims=[0])
kernel.initialize(power=power, offset=offset)
kernel.eval()
res = kernel(a, b).evaluate()
actual = torch.zeros(3, 3, 3)
diff = torch.tensor([[0.45, 0.36, 0.81], [0.4, 0.32, 0.72],
[0.4, 0.32, 0.72]])
actual[0, :, :] = offset + diff.pow(1 + power)
diff = torch.tensor([[0.21, 0.14, 0.56], [0.18, 0.12, 0.48],
[0.24, 0.16, 0.64]])
actual[1, :, :] = offset + diff.pow(1 + power)
diff = torch.tensor([[0.2, 0.2, 0.25], [0.2, 0.2, 0.25],
[0.2, 0.2, 0.25]])
actual[2, :, :] = offset + diff.pow(1 + power)
self.assertLess(torch.norm(res - actual), 1e-5)
def test_computes_downsampling_function(self):
a = torch.tensor([0.1, 0.2]).view(2, 1)
b = torch.tensor([0.2, 0.4]).view(2, 1)
power = 1
offset = 1
kernel = DownsamplingKernel()
kernel.initialize(power=power, offset=offset)
kernel.eval()
diff = torch.tensor([[0.72, 0.54], [0.64, 0.48]])
actual = offset + diff.pow(1 + power)
res = kernel(a, b).evaluate()
self.assertLess(torch.norm(res - actual), 1e-5)
def test_diag_calculation(self):
a = torch.tensor([0.1, 0.2]).view(2, 1)
b = torch.tensor([0.2, 0.4]).view(2, 1)
power = 1
offset = 1
kernel = DownsamplingKernel()
kernel.initialize(power=power, offset=offset)
kernel.eval()
diff = torch.tensor([[0.72, 0.54], [0.64, 0.48]])
actual = offset + diff.pow(1 + power)
res = kernel(a, b, diag=True)
self.assertLess(torch.norm(res - torch.diag(actual)), 1e-5)
def test_computes_downsampling_function_batch(self):
a = torch.tensor([[0.1, 0.2], [0.3, 0.4], [0.5, 0.5]]).view(3, 2, 1)
b = torch.tensor([[0.5, 0.6], [0.7, 0.8], [0.6, 0.6]]).view(3, 2, 1)
power = 1
offset = 1
kernel = DownsamplingKernel(batch_shape=torch.Size([3]))
kernel.initialize(power=power, offset=offset)
kernel.eval()
res = kernel(a, b).evaluate()
actual = torch.zeros(3, 2, 2)
diff = torch.tensor([[0.45, 0.36], [0.4, 0.32]])
actual[0, :, :] = offset + diff.pow(1 + power)
diff = torch.tensor([[0.21, 0.14], [0.18, 0.12]])
actual[1, :, :] = offset + diff.pow(1 + power)
diff = torch.tensor([[0.2, 0.2], [0.2, 0.2]])
actual[2, :, :] = offset + diff.pow(1 + power)
self.assertLess(torch.norm(res - actual), 1e-5)
def test_last_dim_is_batch(self):
a = (torch.tensor([[0.1, 0.2], [0.3, 0.4],
[0.5, 0.5]]).view(3, 2).transpose(-1, -2))
b = (torch.tensor([[0.5, 0.6], [0.7, 0.8],
[0.6, 0.6]]).view(3, 2).transpose(-1, -2))
power = 1
offset = 1
kernel = DownsamplingKernel()
kernel.initialize(power=power, offset=offset)
kernel.eval()
res = kernel(a, b, last_dim_is_batch=True).evaluate()
actual = torch.zeros(3, 2, 2)
diff = torch.tensor([[0.45, 0.36], [0.4, 0.32]])
actual[0, :, :] = offset + diff.pow(1 + power)
diff = torch.tensor([[0.21, 0.14], [0.18, 0.12]])
actual[1, :, :] = offset + diff.pow(1 + power)
diff = torch.tensor([[0.2, 0.2], [0.2, 0.2]])
actual[2, :, :] = offset + diff.pow(1 + power)
self.assertLess(torch.norm(res - actual), 1e-5)
def test_initialize_offset_prior(self):
kernel = DownsamplingKernel()
kernel.offset_prior = NormalPrior(1, 1)
self.assertTrue(isinstance(kernel.offset_prior, NormalPrior))
kernel2 = DownsamplingKernel(offset_prior=GammaPrior(1, 1))
self.assertTrue(isinstance(kernel2.offset_prior, GammaPrior))
def test_initialize_power_batch(self):
kernel = DownsamplingKernel(batch_shape=torch.Size([2]))
power_init = torch.tensor([1.0, 2.0])
kernel.initialize(power=power_init)
actual_value = power_init.view_as(kernel.power)
self.assertLess(torch.norm(kernel.power - actual_value), 1e-5)
def create_kernel_no_ard(self, **kwargs):
return DownsamplingKernel(**kwargs)
def test_initialize_power(self):
kernel = DownsamplingKernel()
kernel.initialize(power=1)
actual_value = torch.tensor(1.0).view_as(kernel.power)
self.assertLess(torch.norm(kernel.power - actual_value), 1e-5)
def test_initialize_offset_batch(self):
kernel = DownsamplingKernel(batch_shape=torch.Size([2]))
off_init = torch.tensor([1.0, 2.0])
kernel.initialize(offset=off_init)
actual_value = off_init.view_as(kernel.offset)
self.assertLess(torch.norm(kernel.offset - actual_value), 1e-5)
def test_initialize_offset(self):
kernel = DownsamplingKernel()
kernel.initialize(offset=1)
actual_value = torch.tensor(1.0).view_as(kernel.offset)
self.assertLess(torch.norm(kernel.offset - actual_value), 1e-5)
