fix(augment): align Kornia GaussianBlur/GaussNoise defaults with albumentations

Two Kornia factory defaults did not match the Albumentations defaults they
stand in for, so switching augmentation_backend silently changed
augmentation strength for the same aug_config.

GaussianBlur sigma defaulted to Kornia's own (0.1, 2.0) while the
albumentations default is (0.5, 3.0), so an unspecified sigma blurred less
on the GPU path. The call-site comment claimed the opposite. AUG_INDUSTRIAL
reaches this default (it sets blur_limit but no sigma).

GaussNoise std_range defaulted to rf-detr's own (0.01, 0.05) against the
albumentations default (0.2, 0.44) on the same 0-1 image scale, 4-9x weaker,
and the divergence warning reported rf-detr's own range as if it were
albumentations'. The default is now the albumentations one; the warning text
is unchanged and still correct for an explicit range.

Doc table updated; regression tests pin both defaults to the live
albumentations values.

Author: adhavan18

src/rfdetr/datasets/aug_configs.py

@@ -80,7 +80,7 @@
 | ``Affine`` | ``K.RandomAffine`` | ``translate_percent`` treated as fraction |
 | ``ColorJitter`` | ``K.ColorJiggle`` | Same multiplicative semantics |
 | ``RandomBrightnessContrast`` | ``K.ColorJiggle`` | ``brightness_limit`` / ``contrast_limit`` direct |
-| ``GaussianBlur`` | ``K.RandomGaussianBlur`` | ``blur_limit`` rounded up to odd; ``sigma=(0.1, 2.0)`` |
+| ``GaussianBlur`` | ``K.RandomGaussianBlur`` | ``blur_limit`` rounded up to odd; ``sigma`` defaults to the albumentations (0.5, 3.0) |
 | ``GaussNoise`` | ``K.RandomGaussianNoise`` | Upper bound of ``std_range`` used as fixed std |
 
 Segmentation models are supported by the GPU augmentation path; masks are augmented in sync with images and boxes.

src/rfdetr/datasets/kornia_transforms.py

@@ -369,8 +369,11 @@ def _make_gaussian_blur(params: dict[str, Any]) -> Any:
     if blur_limit % 2 == 0:
         blur_limit = blur_limit + 1
     blur_limit = max(3, blur_limit)
-    # Match the CPU albumentations default sigma range while allowing an explicit override via config.
-    sigma_range = params.get("sigma", (0.1, 2.0))
+    # Default to the CPU (albumentations) GaussianBlur sigma_limit default, (0.5, 3.0), so the same
+    # aug_config blurs by the same amount on either backend. The previous default (0.1, 2.0) is Kornia's
+    # own convention, not Albumentations', so an unspecified sigma blurred noticeably less on the GPU path;
+    # AUG_INDUSTRIAL reaches this default (it sets blur_limit but no sigma). An explicit sigma still wins.
+    sigma_range = params.get("sigma", (0.5, 3.0))
     blur_sigma = tuple(sigma_range) if len(sigma_range) == 2 else (sigma_range[0], sigma_range[0])
     return RandomGaussianBlur(
         kernel_size=(blur_limit, blur_limit),
@@ -385,10 +388,14 @@ def _make_gauss_noise(params: dict[str, Any]) -> Any:
     Kornia takes a single ``std`` value, so the upper bound of ``std_range`` is used as a fixed standard deviation. When
     the configured range is non-degenerate this diverges from the CPU (albumentations) path, which samples a fresh std
     per call; a warning is emitted at build time so the drift is visible.
+
+    The default matches the CPU (albumentations) ``GaussNoise.std_range`` default, ``(0.2, 0.44)`` on the 0-1 image
+    scale both backends use, so an unspecified ``std_range`` adds the same amount of noise on either path. The previous
+    default ``(0.01, 0.05)`` was rf-detr's own, 4-9x weaker than the CPU backend for the same config.
     """
     from kornia.augmentation import RandomGaussianNoise
 
-    std_range = params.get("std_range", (0.01, 0.05))
+    std_range = params.get("std_range", (0.2, 0.44))
     if std_range[0] != std_range[1]:
         logger.warning(
             "GPU augmentation (Kornia) uses fixed std=%.3f for GaussianNoise "

tests/datasets/test_kornia_transforms.py

@@ -730,6 +730,60 @@ def test_no_warning_for_degenerate_std_range(self):
         mock_warning.assert_not_called()
 
 
+class TestGaussianDefaultsMatchAlbumentations:
+    """The unspecified GaussianBlur sigma and GaussNoise std defaults must match the
+    Albumentations defaults they stand in for (issue #1351): the same aug_config with no
+    explicit value should augment by the same amount on either backend."""
+
+    @pytest.fixture(autouse=True)
+    def _require_kornia(self):
+        pytest.importorskip("kornia")
+
+    def test_gaussian_blur_sigma_default_matches_albumentations(self):
+        """An unspecified sigma must equal albumentations' GaussianBlur sigma_limit default."""
+        albumentations = pytest.importorskip("albumentations")
+
+        from rfdetr.datasets import kornia_transforms
+
+        cpu_default = tuple(albumentations.GaussianBlur().sigma_limit)
+        transform = kornia_transforms._make_gaussian_blur({"blur_limit": 3, "p": 0.3})
+        gpu_default = tuple(float(v) for v in transform._param_generator.sigma)
+
+        assert gpu_default == pytest.approx(cpu_default), (
+            f"unspecified GaussianBlur sigma is {gpu_default} on the GPU path but "
+            f"{cpu_default} on the CPU path, so the same config blurs by different amounts"
+        )
+
+    def test_gauss_noise_std_default_matches_albumentations(self):
+        """An unspecified std_range must equal albumentations' GaussNoise std_range default."""
+        albumentations = pytest.importorskip("albumentations")
+
+        from rfdetr.datasets import kornia_transforms
+
+        cpu_default = tuple(albumentations.GaussNoise().std_range)
+        # Kornia takes a single std (the range's upper bound); the DEFAULT range must still
+        # be the albumentations one, so an unspecified config lands on the same upper bound.
+        transform = kornia_transforms._make_gauss_noise({"p": 0.3})
+        gpu_std = float(transform.flags["std"])
+
+        assert gpu_std == pytest.approx(cpu_default[1]), (
+            f"unspecified GaussNoise std is {gpu_std} on the GPU path but the CPU path "
+            f"samples up to {cpu_default[1]}, so the same config adds different noise"
+        )
+
+    def test_default_gauss_noise_warns_because_the_default_range_is_non_degenerate(self):
+        """The albumentations default range is non-degenerate, so building with no std_range
+        still emits the fixed-std divergence warning rather than going silent."""
+        from unittest import mock
+
+        from rfdetr.datasets import kornia_transforms
+
+        with mock.patch.object(kornia_transforms.logger, "warning") as mock_warning:
+            kornia_transforms._make_gauss_noise({"p": 0.3})
+
+        mock_warning.assert_called_once()
+
+
 # ---------------------------------------------------------------------------
 # TestResolveAugmentationBackend — the single resolution seam that maps backend
 # strings (incl. sentinels/legacy aliases) to concrete AugmentationBackend members.