add tests upsampling

matthieutrs · matthieutrs · commit 338ddb59f1e7 · 2025-07-18T18:58:54.000+02:00
diff --git a/deepinv/physics/blur.py b/deepinv/physics/blur.py
@@ -203,7 +203,33 @@ def update_parameters(self, filter=None, factor=None, **kwargs):
 class Upsampling(Downsampling):
     r"""
     Upsampling operator.
+
+    This operator performs the operation
+
+    .. math::
+        y = h^T * S^T (x)
+
+    where :math:`S^T` is the adjoint of the subsampling operator and :math:`h` is a low-pass filter.
+
+    :param torch.Tensor, str, None filter: Upsampling filter. It can be ``'gaussian'``, ``'bilinear'``, ``'bicubic'``
+        , ``'sinc'`` or a custom ``torch.Tensor`` filter. If ``None``, no filtering is applied.
+    :param tuple[int] img_size: size of the output image
+    :param int factor: upsampling factor
+    :param str padding: options are ``'circular'``, ``'replicate'`` and ``'reflect'``.
+    :param str device: cpu or cuda
     """
+    def __init__(self, img_size, filter=None, factor=2, padding="circular", device="cpu", **kwargs):
+
+        assert padding != "valid", "Padding 'valid' is not supported for Upsampling operator."
+
+        super().__init__(
+            img_size=img_size,
+            filter=filter,
+            factor=factor,
+            padding=padding,
+            device=device,
+            **kwargs,
+        )
 
     def A(self, x, **kwargs):
         return super().A_adjoint(x, **kwargs)
diff --git a/deepinv/tests/test_physics.py b/deepinv/tests/test_physics.py
@@ -45,6 +45,11 @@
     "super_resolution_reflect",
     "super_resolution_replicate",
     "super_resolution_constant",
+    "down_resolution_circular",
+    "down_resolution_reflect",
+    "down_resolution_replicate",
+    "down_resolution_constant",
+    "down_resolution_valid",
     "aliased_super_resolution",
     "fast_singlepixel",
     "fast_singlepixel_cake_cutting",
@@ -375,6 +380,19 @@ def find_operator(name, device, imsize=None, get_physics_param=False, wrapper=No
             dtype=dtype,
         )
         params = ["filter"]
+    elif name.startswith("down_resolution"):
+        img_size = (1, 32, 32) if imsize is None else imsize
+        factor = 2
+        norm = 1.0 / factor**2
+        p = dinv.physics.Upsampling(
+            img_size=(img_size[0], img_size[1]*factor, img_size[2]*factor),
+            factor=factor,
+            padding=padding,
+            device=device,
+            filter="bilinear",
+            dtype=dtype,
+        )
+        params = ["filter"]
     elif name == "complex_compressed_sensing":
         img_size = (1, 8, 8) if imsize is None else imsize
         m = 50
@@ -601,6 +619,54 @@ def test_operators_adjointness(name, device, rng):
 
     assert error2 < 1e-3
 
+def test_upsampling(device, rng):
+    r"""
+    This function tests that the Upsampling and Downsampling operators are effectively adjoint to each other.
+
+    Note that the test does not hold when the padding is not 'valid', as the Upsampling operator
+    does not support 'valid' padding.
+    """
+
+    list_ops = ["down_resolution_circular",
+                 "down_resolution_reflect",
+                 "down_resolution_replicate",
+                 "down_resolution_constant"]
+
+    for kernel in ["bilinear", "bicubic", "sinc", "gaussian"]:
+        for name in list_ops:
+            padding = name.split("_")[-1]  # get padding type from name
+            physics, imsize, _, dtype = find_operator(name, device)
+            physics_adjoint, _, _, dtype = find_operator("super_resolution_"+padding, device, imsize=imsize)
+
+
+            # physics.register_buffer("filter", None)
+            physics.update_parameters(filter=kernel)
+
+            # physics_adjoint.register_buffer("filter", None)
+            physics_adjoint.update_parameters(filter=kernel)
+
+            factor = physics.factor
+
+            x = torch.randn((1, imsize[0], imsize[1], imsize[2]), device=device, dtype=dtype, generator=rng)
+
+            out = physics(x)
+            assert out.shape == (1, imsize[0], imsize[1] * factor, imsize[2] * factor)
+
+            y = physics(x)
+            err1 = (physics.A_adjoint(y) - physics_adjoint(y)).flatten().mean().abs()
+            assert err1 < 1e-6
+
+            imsize_new = (*imsize[:1], imsize[1] * factor, imsize[2] * factor)
+            physics_adjoint, _, _, dtype = find_operator("super_resolution_"+padding, device, imsize=imsize_new)  # we need to redefine the adjoint operator with the new image size
+
+            # physics_adjoint.register_buffer("filter", None)
+            physics_adjoint.update_parameters(filter=kernel)
+
+            x = torch.randn(imsize_new, device=device, dtype=dtype, generator=rng).unsqueeze(0)
+            y = physics_adjoint(x)
+            err2 = (physics.A(y) - physics_adjoint.A_adjoint(y)).flatten().mean().abs()
+            assert err2 < 1e-6
+
 
 @pytest.mark.parametrize("name", OPERATORS)
 @pytest.mark.parametrize("wrapper", WRAPPERS)
