def test_TotalVariationLoss(input_image):
loss = paper.TotalVariationLoss()
actual = loss(input_image)
desired = F.total_variation_loss(input_image, reduction="sum")
assert actual == ptu.approx(desired)
def test_approx():
rel = 1e-6
abs = 0.0
approx_value = ptu.approx(torch.tensor(1.0), rel=rel, abs=abs)
assert 1.0 + 0.9 * rel == approx_value
assert approx_value == 1.0 + 0.9 * rel
def test_MRFLoss(subtests, multi_layer_encoder_with_layer, target_image,
input_image):
multi_layer_encoder, layer = multi_layer_encoder_with_layer
encoder = multi_layer_encoder.extract_encoder(layer)
target_enc = encoder(target_image)
input_enc = encoder(input_image)
patch_size = 3
stride = 1
configs = ((True, 1.0 / 2.0), (False, 1.0))
for (
impl_params,
score_correction_factor,
) in configs:
with subtests.test(impl_params=impl_params):
loss = paper.MRFLoss(encoder,
patch_size,
impl_params=impl_params,
stride=stride)
loss.set_target_image(target_image)
actual = loss(input_image)
extract_patches2d = (paper.extract_normalized_patches2d if
impl_params else pystiche.extract_patches2d)
target_repr = extract_patches2d(target_enc, patch_size, stride)
input_repr = extract_patches2d(input_enc, patch_size, stride)
score = F.mrf_loss(input_repr,
target_repr,
reduction="sum",
batched_input=True)
desired = score * score_correction_factor
assert actual == ptu.approx(desired)
def test_value_range_loss_zero():
torch.manual_seed(0)
input = torch.rand(1, 3, 128, 128)
actual = F.value_range_loss(input)
desired = 0.0
assert desired == ptu.approx(actual)
def test_MultiLayerEncodingLoss(subtests, multi_layer_encoder_with_layer,
target_image, input_image):
multi_layer_encoder, layer = multi_layer_encoder_with_layer
encoder = multi_layer_encoder.extract_encoder(layer)
target_repr = pystiche.gram_matrix(encoder(target_image), normalize=True)
input_repr = pystiche.gram_matrix(encoder(input_image), normalize=True)
configs = ((True, 1.0), (False, 1.0 / 4.0))
for impl_params, score_correction_factor in configs:
with subtests.test(impl_params=impl_params):
loss = paper.MultiLayerEncodingLoss(
multi_layer_encoder,
(layer, ),
lambda encoder, layer_weight: pystiche.loss.GramLoss(
encoder, score_weight=layer_weight),
impl_params=impl_params,
)
loss.set_target_image(target_image)
actual = loss(input_image)
score = mse_loss(
input_repr,
target_repr,
)
desired = score * score_correction_factor
assert actual == ptu.approx(desired)
def test_op_weights_str(self):
class TestOperator(ops.Operator):
def process_input_image(self, image):
pass
def get_op(name, score_weight):
return TestOperator(score_weight=score_weight)
names = [str(idx) for idx in range(3)]
op_weights_config = ("sum", "mean")
desireds = (float(len(names)), 1.0)
for op_weights, desired in zip(op_weights_config, desireds):
same_operator_container = ops.SameOperatorContainer(
names, get_op, op_weights=op_weights
)
actual = sum(
[getattr(same_operator_container, name).score_weight for name in names]
)
assert actual == ptu.approx(desired)
with pytest.raises(ValueError):
ops.SameOperatorContainer(
names, get_op, op_weights="invalid",
)
def test_nonnegsqrt():
vals = (-1.0, 0.0, 1.0, 2.0)
desireds = (0.0, 0.0, 1.0, sqrt(2.0))
for val, desired in zip(vals, desireds):
x = torch.tensor(val, requires_grad=True)
y = pystiche.nonnegsqrt(x)
assert y == ptu.approx(desired)
def test_main(self):
vals = (-1.0, 0.0, 1.0, 2.0)
desireds = (0.0, 0.0, 1.0, sqrt(2.0))
for val, desired in zip(vals, desireds):
x = torch.tensor(val)
y = pystiche.nonnegsqrt(x)
assert y == ptu.approx(desired)
def test_nonnegsqrt_grad():
vals = (-1.0, 0.0, 1.0, 2.0)
desireds = (0.0, 0.0, 1.0 / 2.0, 1.0 / (2.0 * sqrt(2.0)))
for val, desired in zip(vals, desireds):
x = torch.tensor(val, requires_grad=True)
y = pystiche.nonnegsqrt(x)
y.backward()
assert x.grad == ptu.approx(desired)
def test_get_input_image_tensor_style():
starting_point = "style"
image = torch.tensor(0.0)
actual = misc.get_input_image(starting_point, style_image=image)
desired = image
assert actual == ptu.approx(desired)
with pytest.raises(RuntimeError):
misc.get_input_image(starting_point, content_image=image)
def test_mul(self):
losses = (2.0, 3.0)
factor = 4.0
loss_dict = pystiche.LossDict([(f"loss{idx}", torch.tensor(val))
for idx, val in enumerate(losses)])
loss_dict = loss_dict * factor
for idx, loss in enumerate(losses):
actual = float(loss_dict[f"loss{idx}"])
desired = loss * factor
assert actual == ptu.approx(desired)
def test_total_variation_loss():
def get_checkerboard(size):
return ((torch.arange(size**2).view(size, size) +
torch.arange(size).view(size, 1)) % 2).bool()
size = 128
checkerboard = get_checkerboard(size)
input = checkerboard.float().view(1, 1, size, size).repeat(1, 3, 1, 1)
actual = F.total_variation_loss(input)
desired = 2.0
assert desired == ptu.approx(actual)
def test_TotalVariationLoss(subtests, input_image):
configs = ((True, 1.0 / 2.0), (False, 1.0))
for impl_params, score_correction_factor in configs:
with subtests.test(impl_params=impl_params):
loss = paper.TotalVariationLoss(impl_params=impl_params, )
actual = loss(input_image)
score = F.total_variation_loss(input_image,
exponent=loss.exponent,
reduction="sum")
desired = score * score_correction_factor
assert actual == ptu.approx(desired)
def test_optimizer(subtests, input_image):
params = input_image
optimizer = paper.optimizer(params)
assert isinstance(optimizer, optim.LBFGS)
assert len(optimizer.param_groups) == 1
param_group = optimizer.param_groups[0]
with subtests.test(msg="optimization params"):
assert len(param_group["params"]) == 1
assert param_group["params"][0] is params
with subtests.test(msg="optimizer properties"):
assert param_group["lr"] == ptu.approx(1.0)
assert param_group["max_iter"] == 1
def test_optimizer(subtests, input_image):
transformer = nn.Conv2d(3, 3, 1)
params = tuple(transformer.parameters())
optimizer = paper.optimizer(transformer)
assert isinstance(optimizer, optim.Adam)
assert len(optimizer.param_groups) == 1
param_group = optimizer.param_groups[0]
with subtests.test(msg="optimization params"):
assert len(param_group["params"]) == len(params)
for actual, desired in zip(param_group["params"], params):
assert actual is desired
with subtests.test(msg="optimizer properties"):
assert param_group["lr"] == ptu.approx(1e-3)
def test_DelayedExponentialLR():
transformer = nn.Conv2d(3, 3, 1)
gamma = 0.1
delay = 2
num_steps = 5
optimizer = paper.optimizer(transformer)
lr_scheduler = paper.DelayedExponentialLR(optimizer, gamma, delay)
param_group = optimizer.param_groups[0]
base_lr = param_group["lr"]
for i in range(num_steps):
if i >= delay:
base_lr *= gamma
param_group = optimizer.param_groups[0]
assert param_group["lr"] == ptu.approx(base_lr)
optimizer.step()
lr_scheduler.step()
def test_op_weights_seq(self):
class TestOperator(ops.Operator):
def process_input_image(self, image):
pass
def get_op(name, score_weight):
return TestOperator(score_weight=score_weight)
names, op_weights = zip(*[(str(idx), float(idx) + 1.0) for idx in range(3)])
same_operator_container = ops.SameOperatorContainer(
names, get_op, op_weights=op_weights
)
for name, score_weight in zip(names, op_weights):
actual = getattr(same_operator_container, name).score_weight
desired = score_weight
assert actual == ptu.approx(desired)
def test_FeatureReconstructionLoss(subtests, multi_layer_encoder_with_layer,
target_image, input_image):
multi_layer_encoder, layer = multi_layer_encoder_with_layer
encoder = multi_layer_encoder.extract_encoder(layer)
target_enc = encoder(target_image)
input_enc = encoder(input_image)
configs = ((True, "mean"), (False, "sum"))
for impl_params, loss_reduction in configs:
with subtests.test(impl_params=impl_params):
loss = paper.FeatureReconstructionLoss(
encoder,
impl_params=impl_params,
)
loss.set_target_image(target_image)
actual = loss(input_image)
desired = mse_loss(input_enc, target_enc, reduction=loss_reduction)
assert actual == ptu.approx(desired)
def test_main(self, subtests, multi_layer_encoder_with_layer, target_image,
input_image):
multi_layer_encoder, layer = multi_layer_encoder_with_layer
encoder = multi_layer_encoder.extract_encoder(layer)
target_enc = encoder(target_image)
input_enc = encoder(input_image)
configs = ((True, "mean", 1.0), (False, "sum", 1.0 / 2.0))
for impl_params, loss_reduction, score_correction_factor in configs:
with subtests.test(impl_params=impl_params):
loss = paper.FeatureReconstructionLoss(encoder,
impl_params=impl_params)
loss.set_target_image(target_image)
actual = loss(input_image)
score = mse_loss(input_enc,
target_enc,
reduction=loss_reduction)
desired = score * score_correction_factor
assert actual == ptu.approx(desired)
def test_GramLoss(subtests, multi_layer_encoder_with_layer, target_image,
input_image):
multi_layer_encoder, layer = multi_layer_encoder_with_layer
encoder = multi_layer_encoder.extract_encoder(layer)
configs = ((True, True), (False, False))
for (impl_params, normalize_by_num_channels) in configs:
with subtests.test(impl_params=impl_params):
target_repr = pystiche.gram_matrix(encoder(target_image),
normalize=True)
input_repr = pystiche.gram_matrix(encoder(input_image),
normalize=True)
intern_target_repr = (target_repr / target_repr.size()[-1] if
normalize_by_num_channels else target_repr)
intern_input_repr = (input_repr / input_repr.size()[-1]
if normalize_by_num_channels else input_repr)
loss = paper.GramLoss(encoder, impl_params=impl_params)
loss.set_target_image(target_image)
actual = loss(input_image)
desired = mse_loss(intern_input_repr, intern_target_repr)
assert actual == ptu.approx(desired, rel=1e-3)
def test_ulyanov_et_al_2016_optimizer(subtests, impl_params, instance_norm):
transformer = nn.Conv2d(3, 3, 1)
params = tuple(transformer.parameters())
hyper_parameters = paper.hyper_parameters(
impl_params=impl_params, instance_norm=instance_norm).optimizer
optimizer = paper.optimizer(transformer,
impl_params=impl_params,
instance_norm=instance_norm)
assert isinstance(optimizer, optim.Adam)
assert len(optimizer.param_groups) == 1
param_group = optimizer.param_groups[0]
with subtests.test(msg="optimization params"):
assert len(param_group["params"]) == len(params)
for actual, desired in zip(param_group["params"], params):
assert actual is desired
with subtests.test(msg="optimizer properties"):
assert param_group["lr"] == ptu.approx(hyper_parameters.lr)
def test_GramLoss(subtests, multi_layer_encoder_with_layer, target_image,
input_image):
multi_layer_encoder, layer = multi_layer_encoder_with_layer
encoder = multi_layer_encoder.extract_encoder(layer)
target_repr = pystiche.gram_matrix(encoder(target_image), normalize=True)
input_repr = pystiche.gram_matrix(encoder(input_image), normalize=True)
configs = ((True, target_repr.size()[1]), (False, 1.0))
for impl_params, extra_num_channels_normalization in configs:
with subtests.test(impl_params=impl_params):
loss = paper.GramLoss(
encoder,
impl_params=impl_params,
)
loss.set_target_image(target_image)
actual = loss(input_image)
score = mse_loss(
input_repr,
target_repr,
)
desired = score / extra_num_channels_normalization**2
assert actual == ptu.approx(desired, rel=1e-3)
def test_ResidualBlock(double_module):
input = torch.tensor(1.0)
model = utils.ResidualBlock(double_module)
assert model(input) == ptu.approx(3.0)
def test_ResidualBlock_shortcut(double_module):
input = torch.tensor(1.0)
model = utils.ResidualBlock(double_module,
shortcut=utils.ResidualBlock(double_module))
assert model(input) == ptu.approx(5.0)
