Made radii required to get around backwards issue; more consistent with eval SH use in GaussianSplat3d

Signed-off-by: Jonathan Swartz <jonathan@jswartz.info>

Author: swahtz

fvdb/__init__.pyi

@@ -96,9 +96,9 @@ def evaluate_spherical_harmonics(
     sh_degree: int,
     num_cameras: int,
     sh0: torch.Tensor,
+    radii: torch.Tensor,
     shN: torch.Tensor | None = None,
     view_directions: torch.Tensor | None = None,
-    radii: torch.Tensor | None = None,
 ) -> torch.Tensor: ...
 
 __all__ = [

fvdb/_fvdb_cpp.pyi

@@ -1125,9 +1125,9 @@ def evaluate_spherical_harmonics(
     sh_degree: int,
     num_cameras: int,
     sh0: torch.Tensor,
+    radii: torch.Tensor,
     shN: Optional[torch.Tensor] = ...,
     view_directions: Optional[torch.Tensor] = ...,
-    radii: Optional[torch.Tensor] = ...,
 ) -> torch.Tensor: ...
 @overload
 def jcat(grid_batches: list[GridBatch]) -> GridBatch: ...

src/fvdb/detail/autograd/EvaluateSphericalHarmonics.cpp

@@ -58,11 +58,12 @@ EvaluateSphericalHarmonics::backward(EvaluateSphericalHarmonics::AutogradContext
     Variable viewDirs  = saved.at(0);
     Variable shNCoeffs = saved.at(1);
 
-    const int shDegreeToUse          = static_cast<int>(ctx->saved_data["shDegreeToUse"].toInt());
-    const int numCameras             = static_cast<int>(ctx->saved_data["numCameras"].toInt());
-    const int numGaussians           = static_cast<int>(ctx->saved_data["numGaussians"].toInt());
-    const bool hasRadii              = ctx->saved_data["hasRadii"].toBool();
-    const bool computeDLossDViewDirs = ctx->needs_input_grad(1);
+    const int shDegreeToUse = static_cast<int>(ctx->saved_data["shDegreeToUse"].toInt());
+    const int numCameras    = static_cast<int>(ctx->saved_data["numCameras"].toInt());
+    const int numGaussians  = static_cast<int>(ctx->saved_data["numGaussians"].toInt());
+    const bool hasRadii     = ctx->saved_data["hasRadii"].toBool();
+    // Only compute viewDirs gradients if viewDirs is defined and requires grad
+    const bool computeDLossDViewDirs = viewDirs.defined() && viewDirs.requires_grad();
 
     // Radii is only saved if it was defined in forward
     Variable radii = hasRadii ? saved.at(2) : torch::Tensor();

src/python/GaussianSplatBinding.cpp

@@ -399,9 +399,9 @@ bind_gaussian_splat3d(py::module &m) {
         [](int64_t shDegree,
            int64_t numCameras,
            const torch::Tensor &sh0,
+           const torch::Tensor &radii,
            const std::optional<torch::Tensor> &shN,
-           const std::optional<torch::Tensor> &viewDirections,
-           const std::optional<torch::Tensor> &radii) {
+           const std::optional<torch::Tensor> &viewDirections) {
             return fvdb::detail::autograd::EvaluateSphericalHarmonics::apply(
                 shDegree, numCameras, viewDirections, sh0, shN, radii)[0];
         },
@@ -419,21 +419,21 @@ view directions for view-dependent appearance.
     num_cameras: Number of camera views (C). The output will have shape [C, N, D].
     sh0: DC term coefficients with shape [N, 1, D] where N is the number of
          points and D is the number of feature channels.
+    radii: Projected radii with shape [C, N] (int32). Points with radii <= 0
+           will output zeros (used to skip invisible gaussians). Pass a tensor
+           of ones to evaluate all points.
     shN: Higher-order SH coefficients with shape [N, K-1, D] where
          K = (sh_degree+1)^2. Required when sh_degree > 0. Pass None for degree 0.
     view_directions: Unnormalized view directions with shape [C, N, 3].
                      Required when sh_degree > 0. Pass None for degree 0.
-    radii: Optional projected radii with shape [C, N] (int32). When provided,
-           points with radii <= 0 will output zeros (used to skip invisible
-           gaussians as an optimization). Pass None to evaluate all points.
 
 Returns:
     Tensor of shape [C, N, D] containing the evaluated features/colors.
 )doc",
         py::arg("sh_degree"),
         py::arg("num_cameras"),
         py::arg("sh0"),
+        py::arg("radii"),
         py::arg("shN")             = std::nullopt,
-        py::arg("view_directions") = std::nullopt,
-        py::arg("radii")           = std::nullopt);
+        py::arg("view_directions") = std::nullopt);
 }

tests/unit/test_gaussian_splat_3d.py

@@ -3126,115 +3126,20 @@ def test_degree_0_basic(self):
         C = 2  # number of cameras
 
         sh0 = torch.randn(N, 1, D, device=self.device)
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         result = evaluate_spherical_harmonics(
             sh_degree=0,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
         )
 
         self.assertEqual(result.shape, (C, N, D))
         # For degree 0, the result should be the same for all cameras
         # since there's no view dependence
         self.assertTrue(torch.allclose(result[0], result[1], atol=1e-6))
 
-    def test_optional_parameters_omitted(self):
-        """Test that optional parameters (shN, view_directions, radii) can be omitted.
-
-        This is a regression test for an issue where passing undefined tensors
-        to save_for_backward caused 'tensor does not have a device' errors.
-        """
-        N = 50
-        D = 3
-        C = 2
-
-        sh0 = torch.randn(N, 1, D, device=self.device)
-
-        # Test degree 0 with no optional parameters
-        result = evaluate_spherical_harmonics(
-            sh_degree=0,
-            num_cameras=C,
-            sh0=sh0,
-        )
-        self.assertEqual(result.shape, (C, N, D))
-        self.assertFalse(torch.isnan(result).any())
-
-        # Test degree 0 with explicit None for optional parameters
-        result = evaluate_spherical_harmonics(
-            sh_degree=0,
-            num_cameras=C,
-            sh0=sh0,
-            shN=None,
-            view_directions=None,
-            radii=None,
-        )
-        self.assertEqual(result.shape, (C, N, D))
-        self.assertFalse(torch.isnan(result).any())
-
-        # Test higher degree without radii
-        shN = torch.randn(N, 15, D, device=self.device)
-        view_dirs = torch.randn(C, N, 3, device=self.device)
-
-        result = evaluate_spherical_harmonics(
-            sh_degree=3,
-            num_cameras=C,
-            sh0=sh0,
-            shN=shN,
-            view_directions=view_dirs,
-            # radii intentionally omitted
-        )
-        self.assertEqual(result.shape, (C, N, D))
-        self.assertFalse(torch.isnan(result).any())
-
-        # Test higher degree with explicit radii=None
-        result = evaluate_spherical_harmonics(
-            sh_degree=3,
-            num_cameras=C,
-            sh0=sh0,
-            shN=shN,
-            view_directions=view_dirs,
-            radii=None,
-        )
-        self.assertEqual(result.shape, (C, N, D))
-        self.assertFalse(torch.isnan(result).any())
-
-    def test_optional_parameters_gradient_flow(self):
-        """Test gradient flow works when optional parameters are omitted.
-
-        Regression test to ensure backward pass works without radii.
-        """
-        N = 20
-        D = 3
-        C = 2
-
-        sh0 = torch.randn(N, 1, D, device=self.device, requires_grad=True)
-        shN = torch.randn(N, 15, D, device=self.device, requires_grad=True)
-        view_dirs = torch.randn(C, N, 3, device=self.device)
-
-        # Forward without radii
-        result = evaluate_spherical_harmonics(
-            sh_degree=3,
-            num_cameras=C,
-            sh0=sh0,
-            shN=shN,
-            view_directions=view_dirs,
-            # radii intentionally omitted
-        )
-
-        # Backward
-        loss = result.sum()
-        loss.backward()
-
-        # Check gradients exist and are valid
-        self.assertIsNotNone(sh0.grad)
-        self.assertIsNotNone(shN.grad)
-        assert sh0.grad is not None  # for type narrowing
-        assert shN.grad is not None  # for type narrowing
-        self.assertTrue(torch.any(sh0.grad != 0))
-        self.assertTrue(torch.any(shN.grad != 0))
-        self.assertFalse(torch.isnan(sh0.grad).any())
-        self.assertFalse(torch.isnan(shN.grad).any())
-
     def test_degree_0_matches_expected(self):
         """Test that degree 0 SH evaluation produces expected output."""
         N = 10
@@ -3243,11 +3148,13 @@ def test_degree_0_matches_expected(self):
 
         # Known sh0 values
         sh0 = torch.ones(N, 1, D, device=self.device)
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         result = evaluate_spherical_harmonics(
             sh_degree=0,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
         )
 
         # For degree 0: result = 0.2820947917738781 * sh0 + 0.5
@@ -3264,13 +3171,15 @@ def test_degree_1_requires_view_directions(self):
 
         sh0 = torch.randn(N, 1, D, device=self.device)
         shN = torch.randn(N, 3, D, device=self.device)  # 3 coefficients for degree 1
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
-        # Should raise error when view_directions is not provided for degree > 0
-        with self.assertRaises(RuntimeError):
+        # Should raise ValueError when view_directions is not provided for degree > 0
+        with self.assertRaises(ValueError):
             evaluate_spherical_harmonics(
                 sh_degree=1,
                 num_cameras=C,
                 sh0=sh0,
+                radii=radii,
                 shN=shN,
                 view_directions=None,
             )
@@ -3281,6 +3190,7 @@ def test_degree_1_requires_view_directions(self):
             sh_degree=1,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
             shN=shN,
             view_directions=view_dirs,
         )
@@ -3296,11 +3206,13 @@ def test_degree_3_full(self):
         # Degree 3 has (3+1)^2 = 16 bases, so K-1 = 15 higher order coefficients
         shN = torch.randn(N, 15, D, device=self.device)
         view_dirs = torch.randn(C, N, 3, device=self.device)
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         result = evaluate_spherical_harmonics(
             sh_degree=3,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
             shN=shN,
             view_directions=view_dirs,
         )
@@ -3343,11 +3255,15 @@ def test_gradient_flow_sh0(self):
         C = 1
 
         sh0 = torch.randn(N, 1, D, device=self.device, requires_grad=True)
+        # Note: radii must be provided for backward pass to work correctly
+        # (matches GaussianSplat3d usage pattern)
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         result = evaluate_spherical_harmonics(
             sh_degree=0,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
         )
 
         loss = result.sum()
@@ -3365,11 +3281,14 @@ def test_gradient_flow_shN(self):
         sh0 = torch.randn(N, 1, D, device=self.device, requires_grad=True)
         shN = torch.randn(N, 15, D, device=self.device, requires_grad=True)
         view_dirs = torch.randn(C, N, 3, device=self.device)
+        # Note: radii must be provided for backward pass to work correctly
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         result = evaluate_spherical_harmonics(
             sh_degree=3,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
             shN=shN,
             view_directions=view_dirs,
         )
@@ -3391,11 +3310,13 @@ def test_gradient_flow_view_directions(self):
         sh0 = torch.randn(N, 1, D, device=self.device)
         shN = torch.randn(N, 15, D, device=self.device)
         view_dirs = torch.randn(C, N, 3, device=self.device, requires_grad=True)
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         result = evaluate_spherical_harmonics(
             sh_degree=3,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
             shN=shN,
             view_directions=view_dirs,
         )
@@ -3415,11 +3336,13 @@ def test_single_gaussian(self):
         sh0 = torch.randn(N, 1, D, device=self.device)
         shN = torch.randn(N, 15, D, device=self.device)
         view_dirs = torch.randn(C, N, 3, device=self.device)
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         result = evaluate_spherical_harmonics(
             sh_degree=3,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
             shN=shN,
             view_directions=view_dirs,
         )
@@ -3435,11 +3358,13 @@ def test_many_channels(self):
         sh0 = torch.randn(N, 1, D, device=self.device)
         shN = torch.randn(N, 15, D, device=self.device)
         view_dirs = torch.randn(C, N, 3, device=self.device)
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         result = evaluate_spherical_harmonics(
             sh_degree=3,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
             shN=shN,
             view_directions=view_dirs,
         )
@@ -3457,11 +3382,13 @@ def test_different_sh_degrees(self, sh_degree):
         K = (sh_degree + 1) ** 2
         shN = torch.randn(N, K - 1, D, device=self.device)
         view_dirs = torch.randn(C, N, 3, device=self.device)
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         result = evaluate_spherical_harmonics(
             sh_degree=sh_degree,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
             shN=shN,
             view_directions=view_dirs,
         )
@@ -3476,6 +3403,7 @@ def test_view_directions_not_prenormalized(self):
 
         sh0 = torch.randn(N, 1, D, device=self.device)
         shN = torch.randn(N, 15, D, device=self.device)
+        radii = torch.ones(C, N, dtype=torch.int32, device=self.device)
 
         # Unnormalized view directions (varying magnitudes)
         view_dirs = torch.randn(C, N, 3, device=self.device) * 10.0
@@ -3485,6 +3413,7 @@ def test_view_directions_not_prenormalized(self):
             sh_degree=3,
             num_cameras=C,
             sh0=sh0,
+            radii=radii,
             shN=shN,
             view_directions=view_dirs,
         )