Resolves non-gradient bug of SSIM Loss (#5686)

Fixes #5668 .

### Description
The SSIM loss wasn't feeding into autograd - it wasn't allowing gradient
to be calculated. Now they can be calculated.
As per my previous PR (#5550), the loss function is now calculated using
the SSIMMetric (and not the other way around). The SSIMMetric in
inheriting from class `IterationMetric` that runs `.detach()` on all
inputs before running `._compute_tensor()`.

https://github.com/Project-MONAI/MONAI/blob/0737a33d62ce1e18023712a000828235b7758536/monai/metrics/metric.py#L70
I'm now calling the `SSIMMetric()._compute_tensor()` explicitly,
removing the step where it detaches from the current graph.

**To Reproduce**
```
import torch
from monai.losses.ssim_loss import SSIMLoss

x = torch.ones([1,1,10,10])/2
y = torch.ones([1,1,10,10])/2
y.requires_grad_(True)
data_range = x.max().unsqueeze(0)
loss = SSIMLoss(spatial_dims=2)(x,y,data_range)
print(loss.requires_grad)
```

**Expected behavior**
`loss.requires_grad` will now be True.


### Types of changes
- [x] Non-breaking change (fix or new feature that would not break
existing functionality).

Signed-off-by: PedroFerreiradaCosta <pedro.hpf.costa@gmail.com>

Author: PedroFerreiradaCosta

monai/losses/ssim_loss.py

@@ -81,13 +81,15 @@ def forward(self, x: torch.Tensor, y: torch.Tensor, data_range: torch.Tensor) ->
                 print(1-SSIMLoss(spatial_dims=3)(x,y,data_range))
         """
         if x.shape[0] == 1:
-            ssim_value: torch.Tensor = SSIMMetric(data_range, self.win_size, self.k1, self.k2, self.spatial_dims)(x, y)
+            ssim_value: torch.Tensor = SSIMMetric(
+                data_range, self.win_size, self.k1, self.k2, self.spatial_dims
+            )._compute_tensor(x, y)
         elif x.shape[0] > 1:
 
             for i in range(x.shape[0]):
-                ssim_val: torch.Tensor = SSIMMetric(data_range, self.win_size, self.k1, self.k2, self.spatial_dims)(
-                    x[i : i + 1], y[i : i + 1]
-                )
+                ssim_val: torch.Tensor = SSIMMetric(
+                    data_range, self.win_size, self.k1, self.k2, self.spatial_dims
+                )._compute_tensor(x[i : i + 1], y[i : i + 1])
                 if i == 0:
                     ssim_value = ssim_val
                 else:

tests/test_ssim_loss.py

@@ -34,6 +34,14 @@
     TESTS3D.append((x.to(device), y1.to(device), data_range.to(device), torch.tensor(1.0).unsqueeze(0).to(device)))
     TESTS3D.append((x.to(device), y2.to(device), data_range.to(device), torch.tensor(0.0).unsqueeze(0).to(device)))
 
+x = torch.ones([1, 1, 10, 10]) / 2
+y = torch.ones([1, 1, 10, 10]) / 2
+y.requires_grad_(True)
+data_range = x.max().unsqueeze(0)
+TESTS2D_GRAD = []
+for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+    TESTS2D_GRAD.append([x.to(device), y.to(device), data_range.to(device)])
+
 
 class TestSSIMLoss(unittest.TestCase):
     @parameterized.expand(TESTS2D)
@@ -42,6 +50,11 @@ def test2d(self, x, y, drange, res):
         self.assertTrue(isinstance(result, torch.Tensor))
         self.assertTrue(torch.abs(res - result).item() < 0.001)
 
+    @parameterized.expand(TESTS2D_GRAD)
+    def test_grad(self, x, y, drange):
+        result = 1 - SSIMLoss(spatial_dims=2)(x, y, drange)
+        self.assertTrue(result.requires_grad)
+
     @parameterized.expand(TESTS3D)
     def test3d(self, x, y, drange, res):
         result = 1 - SSIMLoss(spatial_dims=3)(x, y, drange)