def test_abstract_base_input_transform(self):
with self.assertRaises(TypeError):
InputTransform()
X = torch.zeros([1])
X_tf = torch.ones([1])
# test transform_on_train and transform_on_eval
ipt = NotSoAbstractInputTransform(transform_on_train=True,
transform_on_eval=True)
self.assertTrue(torch.equal(ipt(X), X_tf))
ipt.eval()
self.assertTrue(torch.equal(ipt(X), X_tf))
ipt = NotSoAbstractInputTransform(transform_on_train=True,
transform_on_eval=False)
self.assertTrue(torch.equal(ipt(X), X_tf))
ipt.eval()
self.assertTrue(torch.equal(ipt(X), X))
ipt = NotSoAbstractInputTransform(transform_on_train=False,
transform_on_eval=True)
self.assertTrue(torch.equal(ipt(X), X))
ipt.eval()
self.assertTrue(torch.equal(ipt(X), X_tf))
ipt = NotSoAbstractInputTransform(transform_on_train=False,
transform_on_eval=False)
self.assertTrue(torch.equal(ipt(X), X))
ipt.eval()
self.assertTrue(torch.equal(ipt(X), X))
# test equals
ipt2 = NotSoAbstractInputTransform(transform_on_train=False,
transform_on_eval=False)
self.assertTrue(ipt.equals(ipt2))
ipt3 = NotSoAbstractInputTransform(transform_on_train=True,
transform_on_eval=False)
self.assertFalse(ipt.equals(ipt3))
with self.assertRaises(NotImplementedError):
ipt.untransform(None)
# test preprocess_transform
ipt4 = NotSoAbstractInputTransform(
transform_on_train=True,
transform_on_eval=False,
)
self.assertTrue(torch.equal(ipt4.preprocess_transform(X), X_tf))
ipt4.transform_on_train = False
self.assertTrue(torch.equal(ipt4.preprocess_transform(X), X))
# test transform_on_fantasize
ipt5 = NotSoAbstractInputTransform(transform_on_train=True,
transform_on_eval=True,
transform_on_fantasize=True)
ipt5.eval()
self.assertTrue(torch.equal(ipt5(X), X_tf))
with fantasize():
self.assertTrue(torch.equal(ipt5(X), X_tf))
ipt5.transform_on_fantasize = False
self.assertTrue(torch.equal(ipt5(X), X_tf))
with fantasize():
self.assertTrue(torch.equal(ipt5(X), X))
def test_fantasize(self):
self.assertFalse(fantasize.on())
self.assertTrue(fantasize.off())
with fantasize():
self.assertTrue(fantasize.on())
self.assertFalse(fantasize.off())
with fantasize(False):
self.assertFalse(fantasize.on())
self.assertTrue(fantasize.off())
def test_fantasize_flag(self):
train_X = torch.rand(5, 1)
train_Y = torch.sin(train_X)
model = SimpleGPyTorchModel(train_X, train_Y)
model.eval()
test_X = torch.ones(1, 1)
model(test_X)
self.assertFalse(model.last_fantasize_flag)
model.posterior(test_X)
self.assertFalse(model.last_fantasize_flag)
model.fantasize(test_X, SobolQMCNormalSampler(2))
self.assertTrue(model.last_fantasize_flag)
model.last_fantasize_flag = False
with fantasize():
model.posterior(test_X)
self.assertTrue(model.last_fantasize_flag)
def test_append_features(self):
with self.assertRaises(ValueError):
AppendFeatures(torch.ones(1))
with self.assertRaises(ValueError):
AppendFeatures(torch.ones(3, 4, 2))
for dtype in (torch.float, torch.double):
feature_set = (torch.linspace(0, 1,
6).view(3, 2).to(device=self.device,
dtype=dtype))
transform = AppendFeatures(feature_set=feature_set)
X = torch.rand(4, 5, 3, device=self.device, dtype=dtype)
# in train - no transform
transform.train()
transformed_X = transform(X)
self.assertTrue(torch.equal(X, transformed_X))
# in eval - yes transform
transform.eval()
transformed_X = transform(X)
self.assertFalse(torch.equal(X, transformed_X))
self.assertEqual(transformed_X.shape, torch.Size([4, 15, 5]))
self.assertTrue(
torch.equal(transformed_X[..., :3],
X.repeat_interleave(3, dim=-2)))
self.assertTrue(
torch.equal(transformed_X[..., 3:],
feature_set.repeat(4, 5, 1)))
# in fantasize - no transform
with fantasize():
transformed_X = transform(X)
self.assertTrue(torch.equal(X, transformed_X))
# Make sure .to calls work.
transform.to(device=torch.device("cpu"), dtype=torch.half)
self.assertEqual(transform.feature_set.device.type, "cpu")
self.assertEqual(transform.feature_set.dtype, torch.half)
def test_input_perturbation(self):
with self.assertRaisesRegex(ValueError, "-dim tensor!"):
InputPerturbation(torch.ones(1))
with self.assertRaisesRegex(ValueError, "-dim tensor!"):
InputPerturbation(torch.ones(3, 2, 1))
with self.assertRaisesRegex(ValueError, "the same number of columns"):
InputPerturbation(torch.ones(2, 1), bounds=torch.ones(2, 4))
for dtype in (torch.float, torch.double):
perturbation_set = torch.tensor(
[[0.5, -0.3], [0.2, 0.4], [-0.7, 0.1]],
device=self.device,
dtype=dtype)
transform = InputPerturbation(perturbation_set=perturbation_set)
X = torch.tensor(
[[[0.5, 0.5], [0.9, 0.7]], [[0.3, 0.2], [0.1, 0.4]]],
device=self.device,
dtype=dtype,
)
expected = torch.tensor(
[
[
[1.0, 0.2],
[0.7, 0.9],
[-0.2, 0.6],
[1.4, 0.4],
[1.1, 1.1],
[0.2, 0.8],
],
[
[0.8, -0.1],
[0.5, 0.6],
[-0.4, 0.3],
[0.6, 0.1],
[0.3, 0.8],
[-0.6, 0.5],
],
],
device=self.device,
dtype=dtype,
)
# in train - no transform
transformed = transform(X)
self.assertTrue(torch.equal(transformed, X))
# in eval - transform
transform.eval()
transformed = transform(X)
self.assertTrue(torch.allclose(transformed, expected))
# in fantasize - no transform
with fantasize():
transformed = transform(X)
self.assertTrue(torch.equal(transformed, X))
# with bounds
bounds = torch.tensor([[0.0, 0.2], [1.2, 0.9]],
device=self.device,
dtype=dtype)
transform = InputPerturbation(perturbation_set=perturbation_set,
bounds=bounds)
transform.eval()
expected = torch.tensor(
[
[
[1.0, 0.2],
[0.7, 0.9],
[0.0, 0.6],
[1.2, 0.4],
[1.1, 0.9],
[0.2, 0.8],
],
[
[0.8, 0.2],
[0.5, 0.6],
[0.0, 0.3],
[0.6, 0.2],
[0.3, 0.8],
[0.0, 0.5],
],
],
device=self.device,
dtype=dtype,
)
transformed = transform(X)
self.assertTrue(torch.allclose(transformed, expected))
# Make sure .to calls work.
transform.to(device=torch.device("cpu"), dtype=torch.half)
self.assertEqual(transform.perturbation_set.device.type, "cpu")
self.assertEqual(transform.perturbation_set.dtype, torch.half)
self.assertEqual(transform.bounds.device.type, "cpu")
self.assertEqual(transform.bounds.dtype, torch.half)
# multiplicative
perturbation_set = torch.tensor(
[[0.5, 1.5], [1.0, 2.0]],
device=self.device,
dtype=dtype,
)
transform = InputPerturbation(perturbation_set=perturbation_set,
multiplicative=True)
transform.eval()
transformed = transform(X)
expected = torch.tensor(
[
[[0.25, 0.75], [0.5, 1.0], [0.45, 1.05], [0.9, 1.4]],
[[0.15, 0.3], [0.3, 0.4], [0.05, 0.6], [0.1, 0.8]],
],
device=self.device,
dtype=dtype,
)
self.assertTrue(torch.allclose(transformed, expected))
def test_filter_features(self):
with self.assertRaises(ValueError):
FilterFeatures(torch.tensor([[1, 2]], dtype=torch.long))
with self.assertRaises(ValueError):
FilterFeatures(torch.tensor([1.0, 2.0]))
with self.assertRaises(ValueError):
FilterFeatures(torch.tensor([-1, 0, 1], dtype=torch.long))
with self.assertRaises(ValueError):
FilterFeatures(torch.tensor([0, 1, 1], dtype=torch.long))
for dtype in (torch.float, torch.double):
feature_indices = torch.tensor([0, 2, 3, 5],
dtype=torch.long,
device=self.device)
transform = FilterFeatures(feature_indices=feature_indices)
X = torch.rand(4, 5, 6, device=self.device, dtype=dtype)
# in train - yes transform
transform.train()
transformed_X = transform(X)
self.assertFalse(torch.equal(X, transformed_X))
self.assertEqual(transformed_X.shape, torch.Size([4, 5, 4]))
self.assertTrue(torch.equal(transformed_X, X[...,
feature_indices]))
# in eval - yes transform
transform.eval()
transformed_X = transform(X)
self.assertFalse(torch.equal(X, transformed_X))
self.assertEqual(transformed_X.shape, torch.Size([4, 5, 4]))
self.assertTrue(torch.equal(transformed_X, X[...,
feature_indices]))
# in fantasize - yes transform
with fantasize():
transformed_X = transform(X)
self.assertFalse(torch.equal(X, transformed_X))
self.assertEqual(transformed_X.shape, torch.Size([4, 5, 4]))
self.assertTrue(
torch.equal(transformed_X, X[..., feature_indices]))
# Make sure .to calls work.
transform.to(device=torch.device("cpu"))
self.assertEqual(transform.feature_indices.device.type, "cpu")
# test equals
transform2 = FilterFeatures(feature_indices=feature_indices)
self.assertTrue(transform.equals(transform2))
# test different indices
feature_indices2 = torch.tensor([0, 2, 3, 6],
dtype=torch.long,
device=self.device)
transform2 = FilterFeatures(feature_indices=feature_indices2)
self.assertFalse(transform.equals(transform2))
# test different length
feature_indices2 = torch.tensor([2, 3, 5],
dtype=torch.long,
device=self.device)
transform2 = FilterFeatures(feature_indices=feature_indices2)
self.assertFalse(transform.equals(transform2))
# test different transform_on_train
transform2 = FilterFeatures(feature_indices=feature_indices,
transform_on_train=False)
self.assertFalse(transform.equals(transform2))
# test different transform_on_eval
transform2 = FilterFeatures(feature_indices=feature_indices,
transform_on_eval=False)
self.assertFalse(transform.equals(transform2))
# test different transform_on_fantasize
transform2 = FilterFeatures(feature_indices=feature_indices,
transform_on_fantasize=False)
self.assertFalse(transform.equals(transform2))