diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 0a239208..a12755bd 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -112,4 +112,4 @@
       </option>
     </inspection_tool>
   </profile>
-</component>
\ No newline at end of file
+</component>
diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml
index 105ce2da..cc5462da 100644
--- a/.idea/inspectionProfiles/profiles_settings.xml
+++ b/.idea/inspectionProfiles/profiles_settings.xml
@@ -3,4 +3,4 @@
     <option name="USE_PROJECT_PROFILE" value="false" />
     <version value="1.0" />
   </settings>
-</component>
\ No newline at end of file
+</component>
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 2f73a560..d147a199 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (mridc)" project-jdk-type="Python SDK" />
-</project>
\ No newline at end of file
+</project>
diff --git a/.idea/modules.xml b/.idea/modules.xml
index 4345a5a3..12daff60 100644
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@@ -5,4 +5,4 @@
       <module fileurl="file://$PROJECT_DIR$/.idea/mridc.iml" filepath="$PROJECT_DIR$/.idea/mridc.iml" />
     </modules>
   </component>
-</project>
\ No newline at end of file
+</project>
diff --git a/.idea/mridc.iml b/.idea/mridc.iml
index 6b1d5bb0..d12b011c 100644
--- a/.idea/mridc.iml
+++ b/.idea/mridc.iml
@@ -12,4 +12,4 @@
   <component name="TestRunnerService">
     <option name="PROJECT_TEST_RUNNER" value="py.test" />
   </component>
-</module>
\ No newline at end of file
+</module>
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
index 35eb1ddf..dcb6b8c4 100644
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -3,4 +3,4 @@
   <component name="VcsDirectoryMappings">
     <mapping directory="" vcs="Git" />
   </component>
-</project>
\ No newline at end of file
+</project>
diff --git a/mridc/collections/common/parts/fft.py b/mridc/collections/common/parts/fft.py
index 20ea05fa..21d67409 100644
--- a/mridc/collections/common/parts/fft.py
+++ b/mridc/collections/common/parts/fft.py
@@ -234,7 +234,7 @@ def roll(data: torch.Tensor, shift: List[int], dim: Union[List[int], Sequence[in
     if isinstance(dim, ListConfig):
         dim = list(dim)
 
-    for (s, d) in zip(shift, dim):
+    for s, d in zip(shift, dim):
         data = roll_one_dim(data, s, d)
 
     return data
diff --git a/mridc/collections/common/parts/transforms.py b/mridc/collections/common/parts/transforms.py
index 972d5d2d..137174f9 100644
--- a/mridc/collections/common/parts/transforms.py
+++ b/mridc/collections/common/parts/transforms.py
@@ -1977,9 +1977,7 @@ def __repr__(self) -> str:
     def __str__(self) -> str:
         return self.__repr__()
 
-    def __process_kspace__(
-        self, kspace: np.ndarray, mask: Union[np.ndarray, None], attrs: Dict, fname: str
-    ) -> Tuple[
+    def __process_kspace__(self, kspace: np.ndarray, mask: Union[np.ndarray, None], attrs: Dict, fname: str) -> Tuple[
         torch.Tensor,
         Union[List[torch.Tensor], torch.Tensor],
         Union[List[torch.Tensor], torch.Tensor],
diff --git a/mridc/collections/multitask/rs/nn/base.py b/mridc/collections/multitask/rs/nn/base.py
index ae856466..63a04d33 100644
--- a/mridc/collections/multitask/rs/nn/base.py
+++ b/mridc/collections/multitask/rs/nn/base.py
@@ -239,9 +239,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
@@ -249,18 +249,22 @@ def process_reconstruction_loss(  # noqa: W0221
                 prediction = utils.unnormalize(
                     prediction,
                     {
-                        "min": attrs["noise_prediction_min"]
-                        if "noise_prediction_min" in attrs
-                        else attrs[f"noise_prediction_min_{r}"],
-                        "max": attrs["noise_prediction_max"]
-                        if "noise_prediction_max" in attrs
-                        else attrs[f"noise_prediction_max_{r}"],
-                        attrs["noise_prediction_mean"]
-                        if "noise_prediction_mean" in attrs
-                        else "mean": attrs[f"noise_prediction_mean_{r}"],
-                        attrs["noise_prediction_std"]
-                        if "noise_prediction_std" in attrs
-                        else "std": attrs[f"noise_prediction_std_{r}"],
+                        "min": (
+                            attrs["noise_prediction_min"]
+                            if "noise_prediction_min" in attrs
+                            else attrs[f"noise_prediction_min_{r}"]
+                        ),
+                        "max": (
+                            attrs["noise_prediction_max"]
+                            if "noise_prediction_max" in attrs
+                            else attrs[f"noise_prediction_max_{r}"]
+                        ),
+                        attrs["noise_prediction_mean"] if "noise_prediction_mean" in attrs else "mean": attrs[
+                            f"noise_prediction_mean_{r}"
+                        ],
+                        attrs["noise_prediction_std"] if "noise_prediction_std" in attrs else "std": attrs[
+                            f"noise_prediction_std_{r}"
+                        ],
                     },
                     self.normalization_type,
                 )
@@ -280,9 +284,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
diff --git a/mridc/collections/multitask/rs/nn/mtlrs.py b/mridc/collections/multitask/rs/nn/mtlrs.py
index 81c44ecc..f164afd6 100644
--- a/mridc/collections/multitask/rs/nn/mtlrs.py
+++ b/mridc/collections/multitask/rs/nn/mtlrs.py
@@ -231,9 +231,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
@@ -241,18 +241,22 @@ def process_reconstruction_loss(  # noqa: W0221
                 prediction = utils.unnormalize(
                     prediction,
                     {
-                        "min": attrs["noise_prediction_min"]
-                        if "noise_prediction_min" in attrs
-                        else attrs[f"noise_prediction_min_{r}"],
-                        "max": attrs["noise_prediction_max"]
-                        if "noise_prediction_max" in attrs
-                        else attrs[f"noise_prediction_max_{r}"],
-                        attrs["noise_prediction_mean"]
-                        if "noise_prediction_mean" in attrs
-                        else "mean": attrs[f"noise_prediction_mean_{r}"],
-                        attrs["noise_prediction_std"]
-                        if "noise_prediction_std" in attrs
-                        else "std": attrs[f"noise_prediction_std_{r}"],
+                        "min": (
+                            attrs["noise_prediction_min"]
+                            if "noise_prediction_min" in attrs
+                            else attrs[f"noise_prediction_min_{r}"]
+                        ),
+                        "max": (
+                            attrs["noise_prediction_max"]
+                            if "noise_prediction_max" in attrs
+                            else attrs[f"noise_prediction_max_{r}"]
+                        ),
+                        attrs["noise_prediction_mean"] if "noise_prediction_mean" in attrs else "mean": attrs[
+                            f"noise_prediction_mean_{r}"
+                        ],
+                        attrs["noise_prediction_std"] if "noise_prediction_std" in attrs else "std": attrs[
+                            f"noise_prediction_std_{r}"
+                        ],
                     },
                     self.normalization_type,
                 )
@@ -272,9 +276,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
diff --git a/mridc/collections/multitask/rs/parts/transforms.py b/mridc/collections/multitask/rs/parts/transforms.py
index 4e6b5a65..728efa9c 100644
--- a/mridc/collections/multitask/rs/parts/transforms.py
+++ b/mridc/collections/multitask/rs/parts/transforms.py
@@ -411,9 +411,7 @@ def __repr__(self) -> str:
     def __str__(self) -> str:
         return self.__repr__()
 
-    def __process_kspace__(
-        self, kspace: np.ndarray, mask: Union[np.ndarray, None], attrs: Dict, fname: str
-    ) -> Tuple[
+    def __process_kspace__(self, kspace: np.ndarray, mask: Union[np.ndarray, None], attrs: Dict, fname: str) -> Tuple[
         torch.Tensor,
         Union[List[torch.Tensor], torch.Tensor],
         Union[List[torch.Tensor], torch.Tensor],
diff --git a/mridc/collections/quantitative/models/base.py b/mridc/collections/quantitative/models/base.py
index 24cb9c8e..0fbb4a1c 100644
--- a/mridc/collections/quantitative/models/base.py
+++ b/mridc/collections/quantitative/models/base.py
@@ -346,7 +346,15 @@ def training_step(self, batch: Dict[float, torch.Tensor], batch_idx: int) -> Dic
             acc,
         ) = batch
 
-        (R2star_map_init, S0_map_init, B0_map_init, phi_map_init, y, sampling_mask, r,) = self.process_inputs(
+        (
+            R2star_map_init,
+            S0_map_init,
+            B0_map_init,
+            phi_map_init,
+            y,
+            sampling_mask,
+            r,
+        ) = self.process_inputs(
             R2star_map_init,
             S0_map_init,
             B0_map_init,
@@ -527,7 +535,15 @@ def validation_step(self, batch: Dict[float, torch.Tensor], batch_idx: int) -> D
             acc,
         ) = batch
 
-        (R2star_map_init, S0_map_init, B0_map_init, phi_map_init, y, sampling_mask, r,) = self.process_inputs(
+        (
+            R2star_map_init,
+            S0_map_init,
+            B0_map_init,
+            phi_map_init,
+            y,
+            sampling_mask,
+            r,
+        ) = self.process_inputs(
             R2star_map_init,
             S0_map_init,
             B0_map_init,
@@ -673,12 +689,8 @@ def validation_step(self, batch: Dict[float, torch.Tensor], batch_idx: int) -> D
                         torch.abs(target[:, echo_time, :, :] - recon_pred[:, echo_time, :, :]),  # type: ignore
                     )
 
-            target_qmaps = torch.cat(
-                [R2star_map_target, S0_map_target, B0_map_target, phi_map_target], dim=-1
-            )
-            output_qmaps = torch.cat(
-                [R2star_map_output, S0_map_output, B0_map_output, phi_map_output], dim=-1
-            )
+            target_qmaps = torch.cat([R2star_map_target, S0_map_target, B0_map_target, phi_map_target], dim=-1)
+            output_qmaps = torch.cat([R2star_map_output, S0_map_output, B0_map_output, phi_map_output], dim=-1)
             error_qmaps = torch.abs(target_qmaps - output_qmaps)
 
             self.log_image(f"{key}/qmaps/target", target_qmaps)
@@ -888,7 +900,15 @@ def test_step(self, batch: Dict[float, torch.Tensor], batch_idx: int) -> Tuple[s
             acc,
         ) = batch
 
-        (R2star_map_init, S0_map_init, B0_map_init, phi_map_init, y, sampling_mask, r,) = self.process_inputs(
+        (
+            R2star_map_init,
+            S0_map_init,
+            B0_map_init,
+            phi_map_init,
+            y,
+            sampling_mask,
+            r,
+        ) = self.process_inputs(
             R2star_map_init,
             S0_map_init,
             B0_map_init,
diff --git a/mridc/collections/quantitative/nn/base.py b/mridc/collections/quantitative/nn/base.py
index 11100817..dd3ec59f 100644
--- a/mridc/collections/quantitative/nn/base.py
+++ b/mridc/collections/quantitative/nn/base.py
@@ -275,9 +275,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
@@ -285,18 +285,22 @@ def process_reconstruction_loss(  # noqa: W0221
                 prediction = utils.unnormalize(
                     prediction,
                     {
-                        "min": attrs["noise_prediction_min"]
-                        if "noise_prediction_min" in attrs
-                        else attrs[f"noise_prediction_min_{r}"],
-                        "max": attrs["noise_prediction_max"]
-                        if "noise_prediction_max" in attrs
-                        else attrs[f"noise_prediction_max_{r}"],
-                        attrs["noise_prediction_mean"]
-                        if "noise_prediction_mean" in attrs
-                        else "mean": attrs[f"noise_prediction_mean_{r}"],
-                        attrs["noise_prediction_std"]
-                        if "noise_prediction_std" in attrs
-                        else "std": attrs[f"noise_prediction_std_{r}"],
+                        "min": (
+                            attrs["noise_prediction_min"]
+                            if "noise_prediction_min" in attrs
+                            else attrs[f"noise_prediction_min_{r}"]
+                        ),
+                        "max": (
+                            attrs["noise_prediction_max"]
+                            if "noise_prediction_max" in attrs
+                            else attrs[f"noise_prediction_max_{r}"]
+                        ),
+                        attrs["noise_prediction_mean"] if "noise_prediction_mean" in attrs else "mean": attrs[
+                            f"noise_prediction_mean_{r}"
+                        ],
+                        attrs["noise_prediction_std"] if "noise_prediction_std" in attrs else "std": attrs[
+                            f"noise_prediction_std_{r}"
+                        ],
                     },
                     self.normalization_type,
                 )
@@ -316,9 +320,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
diff --git a/mridc/collections/quantitative/nn/qcirim.py b/mridc/collections/quantitative/nn/qcirim.py
index e96383b8..9eeac611 100644
--- a/mridc/collections/quantitative/nn/qcirim.py
+++ b/mridc/collections/quantitative/nn/qcirim.py
@@ -491,9 +491,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
@@ -501,18 +501,22 @@ def process_reconstruction_loss(  # noqa: W0221
                 prediction = utils.unnormalize(
                     prediction,
                     {
-                        "min": attrs["noise_prediction_min"]
-                        if "noise_prediction_min" in attrs
-                        else attrs[f"noise_prediction_min_{r}"],
-                        "max": attrs["noise_prediction_max"]
-                        if "noise_prediction_max" in attrs
-                        else attrs[f"noise_prediction_max_{r}"],
-                        attrs["noise_prediction_mean"]
-                        if "noise_prediction_mean" in attrs
-                        else "mean": attrs[f"noise_prediction_mean_{r}"],
-                        attrs["noise_prediction_std"]
-                        if "noise_prediction_std" in attrs
-                        else "std": attrs[f"noise_prediction_std_{r}"],
+                        "min": (
+                            attrs["noise_prediction_min"]
+                            if "noise_prediction_min" in attrs
+                            else attrs[f"noise_prediction_min_{r}"]
+                        ),
+                        "max": (
+                            attrs["noise_prediction_max"]
+                            if "noise_prediction_max" in attrs
+                            else attrs[f"noise_prediction_max_{r}"]
+                        ),
+                        attrs["noise_prediction_mean"] if "noise_prediction_mean" in attrs else "mean": attrs[
+                            f"noise_prediction_mean_{r}"
+                        ],
+                        attrs["noise_prediction_std"] if "noise_prediction_std" in attrs else "std": attrs[
+                            f"noise_prediction_std_{r}"
+                        ],
                     },
                     self.normalization_type,
                 )
@@ -532,9 +536,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
diff --git a/mridc/collections/reconstruction/models/didn/didn.py b/mridc/collections/reconstruction/models/didn/didn.py
index 935dc18c..ad473c31 100644
--- a/mridc/collections/reconstruction/models/didn/didn.py
+++ b/mridc/collections/reconstruction/models/didn/didn.py
@@ -37,9 +37,7 @@ def __init__(self, in_channels, out_channels, upscale_factor, kernel_size, paddi
         padding: Padding size. Default: 0.
         """
         super().__init__()
-        self.conv = nn.Conv2d(
-            in_channels, out_channels * upscale_factor**2, kernel_size=kernel_size, padding=padding
-        )
+        self.conv = nn.Conv2d(in_channels, out_channels * upscale_factor**2, kernel_size=kernel_size, padding=padding)
         self.pixelshuffle = nn.PixelShuffle(upscale_factor)
 
     def forward(self, x):
diff --git a/mridc/collections/reconstruction/models/recurrentvarnet/recurrentvarnet.py b/mridc/collections/reconstruction/models/recurrentvarnet/recurrentvarnet.py
index 8c1da7e5..ea221ca5 100644
--- a/mridc/collections/reconstruction/models/recurrentvarnet/recurrentvarnet.py
+++ b/mridc/collections/reconstruction/models/recurrentvarnet/recurrentvarnet.py
@@ -68,7 +68,7 @@ def __init__(
         self.depth = depth
         self.multiscale_depth = multiscale_depth
         tch = in_channels
-        for (curr_channels, curr_dilations) in zip(channels, dilations):
+        for curr_channels, curr_dilations in zip(channels, dilations):
             block = [
                 nn.ReplicationPad2d(curr_dilations),
                 nn.Conv2d(tch, curr_channels, 3, padding=0, dilation=curr_dilations),
diff --git a/mridc/collections/reconstruction/nn/base.py b/mridc/collections/reconstruction/nn/base.py
index 10675904..4036af18 100644
--- a/mridc/collections/reconstruction/nn/base.py
+++ b/mridc/collections/reconstruction/nn/base.py
@@ -155,9 +155,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
@@ -165,18 +165,22 @@ def process_reconstruction_loss(  # noqa: W0221
                 prediction = utils.unnormalize(
                     prediction,
                     {
-                        "min": attrs["noise_prediction_min"]
-                        if "noise_prediction_min" in attrs
-                        else attrs[f"noise_prediction_min_{r}"],
-                        "max": attrs["noise_prediction_max"]
-                        if "noise_prediction_max" in attrs
-                        else attrs[f"noise_prediction_max_{r}"],
-                        attrs["noise_prediction_mean"]
-                        if "noise_prediction_mean" in attrs
-                        else "mean": attrs[f"noise_prediction_mean_{r}"],
-                        attrs["noise_prediction_std"]
-                        if "noise_prediction_std" in attrs
-                        else "std": attrs[f"noise_prediction_std_{r}"],
+                        "min": (
+                            attrs["noise_prediction_min"]
+                            if "noise_prediction_min" in attrs
+                            else attrs[f"noise_prediction_min_{r}"]
+                        ),
+                        "max": (
+                            attrs["noise_prediction_max"]
+                            if "noise_prediction_max" in attrs
+                            else attrs[f"noise_prediction_max_{r}"]
+                        ),
+                        attrs["noise_prediction_mean"] if "noise_prediction_mean" in attrs else "mean": attrs[
+                            f"noise_prediction_mean_{r}"
+                        ],
+                        attrs["noise_prediction_std"] if "noise_prediction_std" in attrs else "std": attrs[
+                            f"noise_prediction_std_{r}"
+                        ],
                     },
                     self.normalization_type,
                 )
@@ -196,9 +200,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
diff --git a/mridc/collections/reconstruction/nn/cirim.py b/mridc/collections/reconstruction/nn/cirim.py
index 424dd8be..6d88bb00 100644
--- a/mridc/collections/reconstruction/nn/cirim.py
+++ b/mridc/collections/reconstruction/nn/cirim.py
@@ -219,9 +219,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
@@ -229,18 +229,22 @@ def process_reconstruction_loss(  # noqa: W0221
                 prediction = utils.unnormalize(
                     prediction,
                     {
-                        "min": attrs["noise_prediction_min"]
-                        if "noise_prediction_min" in attrs
-                        else attrs[f"noise_prediction_min_{r}"],
-                        "max": attrs["noise_prediction_max"]
-                        if "noise_prediction_max" in attrs
-                        else attrs[f"noise_prediction_max_{r}"],
-                        attrs["noise_prediction_mean"]
-                        if "noise_prediction_mean" in attrs
-                        else "mean": attrs[f"noise_prediction_mean_{r}"],
-                        attrs["noise_prediction_std"]
-                        if "noise_prediction_std" in attrs
-                        else "std": attrs[f"noise_prediction_std_{r}"],
+                        "min": (
+                            attrs["noise_prediction_min"]
+                            if "noise_prediction_min" in attrs
+                            else attrs[f"noise_prediction_min_{r}"]
+                        ),
+                        "max": (
+                            attrs["noise_prediction_max"]
+                            if "noise_prediction_max" in attrs
+                            else attrs[f"noise_prediction_max_{r}"]
+                        ),
+                        attrs["noise_prediction_mean"] if "noise_prediction_mean" in attrs else "mean": attrs[
+                            f"noise_prediction_mean_{r}"
+                        ],
+                        attrs["noise_prediction_std"] if "noise_prediction_std" in attrs else "std": attrs[
+                            f"noise_prediction_std_{r}"
+                        ],
                     },
                     self.normalization_type,
                 )
@@ -260,9 +264,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
diff --git a/mridc/collections/reconstruction/nn/crnn.py b/mridc/collections/reconstruction/nn/crnn.py
index c956d77e..db5bc8bb 100644
--- a/mridc/collections/reconstruction/nn/crnn.py
+++ b/mridc/collections/reconstruction/nn/crnn.py
@@ -175,9 +175,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
@@ -185,18 +185,22 @@ def process_reconstruction_loss(  # noqa: W0221
                 prediction = utils.unnormalize(
                     prediction,
                     {
-                        "min": attrs["noise_prediction_min"]
-                        if "noise_prediction_min" in attrs
-                        else attrs[f"noise_prediction_min_{r}"],
-                        "max": attrs["noise_prediction_max"]
-                        if "noise_prediction_max" in attrs
-                        else attrs[f"noise_prediction_max_{r}"],
-                        attrs["noise_prediction_mean"]
-                        if "noise_prediction_mean" in attrs
-                        else "mean": attrs[f"noise_prediction_mean_{r}"],
-                        attrs["noise_prediction_std"]
-                        if "noise_prediction_std" in attrs
-                        else "std": attrs[f"noise_prediction_std_{r}"],
+                        "min": (
+                            attrs["noise_prediction_min"]
+                            if "noise_prediction_min" in attrs
+                            else attrs[f"noise_prediction_min_{r}"]
+                        ),
+                        "max": (
+                            attrs["noise_prediction_max"]
+                            if "noise_prediction_max" in attrs
+                            else attrs[f"noise_prediction_max_{r}"]
+                        ),
+                        attrs["noise_prediction_mean"] if "noise_prediction_mean" in attrs else "mean": attrs[
+                            f"noise_prediction_mean_{r}"
+                        ],
+                        attrs["noise_prediction_std"] if "noise_prediction_std" in attrs else "std": attrs[
+                            f"noise_prediction_std_{r}"
+                        ],
                     },
                     self.normalization_type,
                 )
@@ -216,9 +220,9 @@ def process_reconstruction_loss(  # noqa: W0221
                     {
                         "min": attrs["prediction_min"] if "prediction_min" in attrs else attrs[f"prediction_min_{r}"],
                         "max": attrs["prediction_max"] if "prediction_max" in attrs else attrs[f"prediction_max_{r}"],
-                        "mean": attrs["prediction_mean"]
-                        if "prediction_mean" in attrs
-                        else attrs[f"prediction_mean_{r}"],
+                        "mean": (
+                            attrs["prediction_mean"] if "prediction_mean" in attrs else attrs[f"prediction_mean_{r}"]
+                        ),
                         "std": attrs["prediction_std"] if "prediction_std" in attrs else attrs[f"prediction_std_{r}"],
                     },
                     self.normalization_type,
diff --git a/mridc/collections/reconstruction/nn/didn/didn.py b/mridc/collections/reconstruction/nn/didn/didn.py
index 45796c81..a13df674 100644
--- a/mridc/collections/reconstruction/nn/didn/didn.py
+++ b/mridc/collections/reconstruction/nn/didn/didn.py
@@ -41,9 +41,7 @@ def __init__(  # noqa: W0221
         padding: int = 0,
     ):
         super().__init__()
-        self.conv = nn.Conv2d(
-            in_channels, out_channels * upscale_factor**2, kernel_size=kernel_size, padding=padding
-        )
+        self.conv = nn.Conv2d(in_channels, out_channels * upscale_factor**2, kernel_size=kernel_size, padding=padding)
         self.pixelshuffle = nn.PixelShuffle(upscale_factor)
 
     def forward(self, x):
diff --git a/mridc/collections/reconstruction/nn/recurrentvarnet/recurrentvarnet.py b/mridc/collections/reconstruction/nn/recurrentvarnet/recurrentvarnet.py
index f09da53d..ab91c6cd 100644
--- a/mridc/collections/reconstruction/nn/recurrentvarnet/recurrentvarnet.py
+++ b/mridc/collections/reconstruction/nn/recurrentvarnet/recurrentvarnet.py
@@ -57,7 +57,7 @@ def __init__(  # noqa: W0221
         self.depth = depth
         self.multiscale_depth = multiscale_depth
         tch = in_channels
-        for (curr_channels, curr_dilations) in zip(channels, dilations):
+        for curr_channels, curr_dilations in zip(channels, dilations):
             block = [
                 nn.ReplicationPad2d(curr_dilations),
                 nn.Conv2d(tch, curr_channels, 3, padding=0, dilation=curr_dilations),
diff --git a/mridc/collections/reconstruction/nn/rim/rim_utils.py b/mridc/collections/reconstruction/nn/rim/rim_utils.py
index 3b020e25..cecb5cb7 100644
--- a/mridc/collections/reconstruction/nn/rim/rim_utils.py
+++ b/mridc/collections/reconstruction/nn/rim/rim_utils.py
@@ -69,12 +69,8 @@ def log_likelihood_gradient(  # noqa: W0221
     )
     pred_real, pred_imag = pred.chunk(2, -1)
 
-    re_out = torch.sum(pred_real * sensitivity_maps_real + pred_imag * sensitivity_maps_imag, coil_dim) / (
-        sigma**2.0
-    )
-    im_out = torch.sum(pred_imag * sensitivity_maps_real - pred_real * sensitivity_maps_imag, coil_dim) / (
-        sigma**2.0
-    )
+    re_out = torch.sum(pred_real * sensitivity_maps_real + pred_imag * sensitivity_maps_imag, coil_dim) / (sigma**2.0)
+    im_out = torch.sum(pred_imag * sensitivity_maps_real - pred_real * sensitivity_maps_imag, coil_dim) / (sigma**2.0)
 
     prediction_real = prediction_real.squeeze(coil_dim)
     prediction_imag = prediction_imag.squeeze(coil_dim)
diff --git a/mridc/collections/segmentation/models/seranet_base/convlstm.py b/mridc/collections/segmentation/models/seranet_base/convlstm.py
index 221c6e06..68a7ff38 100644
--- a/mridc/collections/segmentation/models/seranet_base/convlstm.py
+++ b/mridc/collections/segmentation/models/seranet_base/convlstm.py
@@ -67,7 +67,6 @@ def init_hidden(self, batch_size, image_size):
 
 
 class ConvLSTM(nn.Module):
-
     """
 
     Parameters: