rebuild

Author: seashoo

test/sampling/pathwise/features/test_generators.py

@@ -232,7 +232,7 @@ def test_odd_num_random_features_error(self):
             )
 
     def test_rbf_weight_generator_shape_error(self):
-        """Test shape validation error in RBF weight generator"""
+        """Test shape validation in RBF weight generator"""
         from unittest.mock import patch
 
         from botorch.sampling.pathwise.features.generators import (
@@ -242,38 +242,24 @@ def test_rbf_weight_generator_shape_error(self):
         config = TestCaseConfig(seed=0, device=self.device, num_inputs=2)
         kernel = gen_module(kernels.RBFKernel, config)
 
-        # Mock draw_sobol_normal_samples to trigger the shape error
-        def mock_weight_gen(shape):
-            if len(shape) != 2:
-                raise ValueError("Wrong shape dimensions")
-            return torch.randn(shape, device=kernel.device, dtype=kernel.dtype)
-
-        # Trigger the internal weight generator with wrong shape
+        # Patch _gen_fourier_features to call weight generator with invalid shape
         with patch(
-            "botorch.sampling.pathwise.features.generators.draw_sobol_normal_samples",
-            side_effect=mock_weight_gen,
-        ):
-            # This should call the weight generator with a 1D shape to trigger the error
-            with patch(
-                "botorch.sampling.pathwise.features.generators._gen_fourier_features"
-            ) as mock_fourier:
-
-                def mock_fourier_call(*args, **kwargs):
-                    # Call the weight generator with malformed shape to trigger lines
-                    weight_gen = kwargs["weight_generator"]
-                    try:
-                        weight_gen(
-                            torch.Size([10])
-                        )  # 1D shape should trigger the error
-                    except UnsupportedError:
-                        pass
-                    return torch.nn.Identity()  # Return dummy
-
-                mock_fourier.side_effect = mock_fourier_call
-                _gen_kernel_feature_map_rbf(kernel, num_random_features=64)
+            "botorch.sampling.pathwise.features.generators._gen_fourier_features"
+        ) as mock_fourier:
+
+            def mock_fourier_call(weight_generator, **kwargs):
+                # Call the weight generator with 1D shape to trigger ValueError
+                with self.assertRaisesRegex(
+                    UnsupportedError, "Expected.*2-dimensional"
+                ):
+                    weight_generator(torch.Size([10]))  # 1D shape
+                return None
+
+            mock_fourier.side_effect = mock_fourier_call
+            _gen_kernel_feature_map_rbf(kernel, num_random_features=64)
 
     def test_matern_weight_generator_shape_error(self):
-        """Test shape validation error in Matern weight generator"""
+        """Test shape validation in Matern weight generator"""
         from unittest.mock import patch
 
         from botorch.sampling.pathwise.features.generators import (
@@ -283,35 +269,21 @@ def test_matern_weight_generator_shape_error(self):
         config = TestCaseConfig(seed=0, device=self.device, num_inputs=2)
         kernel = gen_module(kernels.MaternKernel, config)
 
-        # Mock draw_sobol_normal_samples to trigger the shape error
-        def mock_weight_gen(shape):
-            if len(shape) != 2:
-                raise ValueError("Wrong shape dimensions")
-            return torch.randn(shape, device=kernel.device, dtype=kernel.dtype)
-
-        # Trigger the internal weight generator with wrong shape
+        # Patch _gen_fourier_features to call weight generator with invalid shape
         with patch(
-            "botorch.sampling.pathwise.features.generators.draw_sobol_normal_samples",
-            side_effect=mock_weight_gen,
-        ):
-            # This should call the weight generator with a 1D shape to trigger the error
-            with patch(
-                "botorch.sampling.pathwise.features.generators._gen_fourier_features"
-            ) as mock_fourier:
-
-                def mock_fourier_call(*args, **kwargs):
-                    # Call the weight generator with malformed shape to trigger lines
-                    weight_gen = kwargs["weight_generator"]
-                    try:
-                        weight_gen(
-                            torch.Size([10])
-                        )  # 1D shape should trigger the error
-                    except UnsupportedError:
-                        pass
-                    return torch.nn.Identity()  # Return dummy
-
-                mock_fourier.side_effect = mock_fourier_call
-                _gen_kernel_feature_map_matern(kernel, num_random_features=64)
+            "botorch.sampling.pathwise.features.generators._gen_fourier_features"
+        ) as mock_fourier:
+
+            def mock_fourier_call(weight_generator, **kwargs):
+                # Call the weight generator with 1D shape to trigger ValueError
+                with self.assertRaisesRegex(
+                    UnsupportedError, "Expected.*2-dimensional"
+                ):
+                    weight_generator(torch.Size([10]))  # 1D shape
+                return None
+
+            mock_fourier.side_effect = mock_fourier_call
+            _gen_kernel_feature_map_matern(kernel, num_random_features=64)
 
     def test_scale_kernel_coverage(self):
         """Test ScaleKernel condition - active_dims different from base kernel"""

test/sampling/pathwise/features/test_maps.py

@@ -547,7 +547,7 @@ def forward(self, x):
         map_3d = MixedDimFeatureMap(Size([2, 3, 5]))  # 3D: max_ndim will be 3
         map_2d = MixedDimFeatureMap(Size([4, 6]))  # 2D: will be expanded to 3D
 
-        # This should trigger lines where ndim < max_ndim and we're in the else branch
+        # This should trigger code where ndim < max_ndim and we're in the else branch
         # for i in range(max_ndim - 1), specifically the else part where
         # idx = i - (max_ndim - ndim)
         mixed_direct_sum_2 = maps.DirectSumFeatureMap([map_3d, map_2d])
@@ -558,7 +558,7 @@ def forward(self, x):
         # map_2d has ndim = 2, so ndim < max_ndim
         # For i in range(2): i=0,1
         # For map_2d: when i >= max_ndim - ndim (i.e., i >= 3-2=1), we go to else branch
-        # So when i=1, we execute lines 179-180: idx = 1 - (3-2) = 0,
+        # So when i=1, we execute: idx = 1 - (3-2) = 0,
         # result_shape[1] = max(result_shape[1], shape[0])
         self.assertEqual(len(shape_2), 3)  # Should have 3 dimensions
         self.assertEqual(shape_2[-1], 5 + 6)  # Concatenation: last dims added

test/sampling/pathwise/test_prior_samplers.py

@@ -128,7 +128,6 @@ def test_model_lists(self):
 
     def test_weight_generator_custom(self):
         """Test custom weight generator in prior_samplers.py"""
-        import torch
         from botorch.sampling.pathwise.prior_samplers import (
             _draw_kernel_feature_paths_fallback,
         )
@@ -184,30 +183,8 @@ def custom_weight_generator(shape):
         )
         self.assertTrue(torch.allclose(result.weight, torch.ones_like(result.weight)))
 
-    def test_weight_generator_device_handling(self):
-        """Test weight generator with proper device handling."""
-        from botorch.sampling.pathwise.prior_samplers import (
-            _draw_kernel_feature_paths_fallback,
-        )
-        from gpytorch.kernels import RBFKernel
-
-        kernel = RBFKernel(ard_num_dims=2)
-
-        def custom_weight_generator(shape):
-            return torch.zeros(shape)
-
-        result = _draw_kernel_feature_paths_fallback(
-            mean_module=None,
-            covar_module=kernel,
-            sample_shape=Size([2]),
-            weight_generator=custom_weight_generator,
-        )
-
-        # This should exercise the device handling code
-        self.assertTrue(torch.allclose(result.weight, torch.zeros_like(result.weight)))
-
     def test_approximategp_dispatcher(self):
-        """Test ApproximateGP dispatcher registration (line 193)."""
+        """Test ApproximateGP dispatcher registration."""
         from botorch.sampling.pathwise.prior_samplers import DrawKernelFeaturePaths
         from gpytorch.models import ApproximateGP
         from gpytorch.variational import VariationalStrategy

test/sampling/pathwise/test_update_strategies.py

@@ -240,7 +240,7 @@ def test_error_branches(self):
         from botorch.models import SingleTaskVariationalGP
         from linear_operator.operators import DiagLinearOperator
 
-        # Test exact model with non-Gaussian likelihood (lines 195-196)
+        # Test exact model with non-Gaussian likelihood
         config = TestCaseConfig(device=self.device)
         model = gen_module(models.SingleTaskGP, config)
         model.likelihood = BernoulliLikelihood()
@@ -250,7 +250,7 @@ def test_error_branches(self):
         with self.assertRaises(NotImplementedError):
             gaussian_update(model=model, sample_values=sample_values)
 
-        # Test variational model with non-zero noise covariance (lines 203-204)
+        # Test variational model with non-zero noise covariance
         variational_model = SingleTaskVariationalGP(
             train_X=torch.rand(5, 2),
             train_Y=torch.rand(5, 1),
@@ -264,7 +264,7 @@ def test_error_branches(self):
                 noise_covariance=DiagLinearOperator(torch.ones(5)),
             )
 
-        # Test the tensor splitting with None target_values (line 217)
+        # Test the tensor splitting with None target_values
         config = TestCaseConfig(device=self.device)
         model_list = gen_module(models.ModelListGP, config)
 

test/sampling/pathwise/test_utils.py

@@ -205,7 +205,7 @@ def test_sparse_block_diag_with_linear_operator(self):
         self.assertEqual(dense_result.shape, expected_shape)
 
     def test_untransform_shape_with_input_transform(self):
-        """Test untransform_shape with InputTransform - covers line 142"""
+        """Test untransform_shape with InputTransform."""
         from botorch.models.transforms.input import Normalize
         from botorch.sampling.pathwise.utils.helpers import untransform_shape
 
@@ -223,7 +223,7 @@ def test_untransform_shape_with_input_transform(self):
         self.assertEqual(result_shape, shape)
 
     def test_get_kernel_num_inputs_error_case(self):
-        """Test get_kernel_num_inputs error case - covers lines 209-214"""
+        """Test get_kernel_num_inputs error case."""
         from botorch.sampling.pathwise.utils.helpers import get_kernel_num_inputs
         from gpytorch.kernels import RBFKernel
 
@@ -390,18 +390,3 @@ def untransform(self, Y, Yvar=None):
         result_shape = untransform_shape(transform, shape)
         # Should return the transformed shape (doubled last dimension)
         self.assertEqual(result_shape, torch.Size([10, 4]))
-
-    def test_get_train_inputs_branch_coverage(self):
-        """Test specific branch in _get_train_inputs_SingleTaskVariationalGP"""
-        from botorch.sampling.pathwise.utils.helpers import get_train_inputs
-
-        # Create a variational model
-        model = self.models[2]  # Use a SingleTaskVariationalGP
-        if not isinstance(model, SingleTaskVariationalGP):
-            return  # Skip if not the right model type
-
-        # Test with training=False and transformed=False to hit specific branch
-        model.eval()  # Set to eval mode
-        result = get_train_inputs(model, transformed=False)
-        self.assertIsInstance(result, tuple)
-        self.assertEqual(len(result), 1)