some more minor changes

Author: mmahsereci

src/probnum/quad/_bayesquad.py

@@ -332,7 +332,7 @@ def multilevel_bayesquad_from_data(
         one element is provided, it is inferred that the same nodes ``nodes[0]`` are
         used on every level.
     fun_diff_evals
-        Tuple of length :math:`L+1`  containing the evaluations of :math:`f_l - f_{l-1}`
+        Tuple of length :math:`L+1` containing the evaluations of :math:`f_l - f_{l-1}`
         for each level at the nodes provided in ``nodes``. Each element must be a
         shape=(n_eval,) ``np.ndarray``. The zeroth element contains the evaluations of
         :math:`f_0`.
@@ -382,6 +382,7 @@ def multilevel_bayesquad_from_data(
     The tuple of kernels provided by the ``kernels`` parameter must contain distinct
     kernel instances, i.e., ``kernels[i] is kernel[j]`` must return ``False`` for any
     :math:`i\neq j`.
+
     References
     ----------
     .. [1] Li, K., et al., Multilevel Bayesian quadrature, AISTATS, 2023.

tests/test_quad/test_bayesquad/test_bq.py

@@ -223,53 +223,84 @@ def test_zero_function_gives_zero_variance_with_mle(rng):
 
 
 def test_multilevel_bayesquad_from_data_output_types_and_shapes(kernel, measure, rng):
-    """Test that inputs to multilevel BQ are handled properly."""
-    n_level = 3
+    """Test correct output for different inputs to multilevel BQ."""
+
+    # full set of nodes
     ns_1 = (3, 7, 2)
-    fun_diff_evals_1 = tuple(np.zeros(ns_1[l]) for l in range(n_level))
-    nodes_full = tuple(measure.sample((ns_1[l]), rng=rng) for l in range(n_level))
+    n_level_1 = len(ns_1)
+    fun_diff_evals_1 = tuple(np.zeros(ns_1[l]) for l in range(n_level_1))
+    nodes_full = tuple(measure.sample((ns_1[l]), rng=rng) for l in range(n_level_1))
 
+    # i) default kernel
     F, infos = multilevel_bayesquad_from_data(
         nodes=nodes_full,
         fun_diff_evals=fun_diff_evals_1,
         measure=measure,
     )
     assert isinstance(F, Normal)
-    assert len(infos) == n_level
-    # Only one set of nodes
-    kernels_1 = tuple(copy.deepcopy(kernel) for l in range(n_level))
-    ns_2 = (7, 7, 7)
-    fun_diff_evals_2 = n_level * (np.zeros((ns_2[0],)),)
-    kernels_full = n_level * (kernel,)
+    assert len(infos) == n_level_1
+
+    # ii) full kernel list
+    kernels_full_1 = tuple(copy.deepcopy(kernel) for _ in range(n_level_1))
+    F, infos = multilevel_bayesquad_from_data(
+        nodes=nodes_full,
+        fun_diff_evals=fun_diff_evals_1,
+        kernels=kernels_full_1,
+        measure=measure,
+    )
+    assert isinstance(F, Normal)
+    assert len(infos) == n_level_1
+
+    # one set of nodes
+    n_level_2 = 3
+    ns_2 = n_level_2 * (7,)
+    fun_diff_evals_2 = tuple(np.zeros(ns_2[l]) for l in range(n_level_2))
     nodes_1 = (measure.sample(n_sample=ns_2[0], rng=rng),)
+
+    # i) default kernel
+    F, infos = multilevel_bayesquad_from_data(
+        nodes=nodes_1,
+        fun_diff_evals=fun_diff_evals_2,
+        measure=measure,
+    )
+    assert isinstance(F, Normal)
+    assert len(infos) == n_level_2
+
+    # ii) full kernel list
+    kernels_full_2 = tuple(copy.deepcopy(kernel) for _ in range(n_level_2))
     F, infos = multilevel_bayesquad_from_data(
         nodes=nodes_1,
         fun_diff_evals=fun_diff_evals_2,
-        kernels=kernels_full,
+        kernels=kernels_full_2,
         measure=measure,
     )
     assert isinstance(F, Normal)
-    assert len(infos) == n_level
+    assert len(infos) == n_level_2
 
 
 def test_multilevel_bayesquad_from_data_wrong_inputs(kernel, measure, rng):
     """Tests that wrong number inputs to multilevel BQ throw errors."""
-    n_level = 5
     ns = (3, 7, 11)
-    nodes_1 = (measure.sample(n_sample=ns[0], rng=rng),)
-    fun_diff_evals = n_level * (np.zeros((ns[0],)),)
-    kernels = (kernel, kernel)
+    n_level = len(ns)
+    fun_diff_evals = tuple(np.zeros(ns[l]) for l in range(n_level))
+
+    # number of nodes does not match the number of fun evals
+    wrong_n_nodes = 2
+    nodes_2 = tuple(measure.sample((ns[l]), rng=rng) for l in range(wrong_n_nodes))
     with pytest.raises(ValueError):
-        _, _ = multilevel_bayesquad_from_data(
-            nodes=nodes_1,
+        multilevel_bayesquad_from_data(
+            nodes=nodes_2,
             fun_diff_evals=fun_diff_evals,
-            kernels=kernels,
             measure=measure,
         )
-    nodes_2 = tuple(measure.sample((ns[l]), rng=rng) for l in range(2))
+
+    # number of kernels does not match number of fun evals
+    wrong_n_kernels = 2
+    kernels = tuple(copy.deepcopy(kernel) for _ in range(wrong_n_kernels))
+    nodes_1 = (measure.sample(n_sample=ns[0], rng=rng),)
     with pytest.raises(ValueError):
-        _, _ = multilevel_bayesquad_from_data(
-            nodes=nodes_2,
+        multilevel_bayesquad_from_data(
+            nodes=nodes_1,
             fun_diff_evals=fun_diff_evals,
             kernels=kernels,
             measure=measure,
@@ -279,18 +310,16 @@ def test_multilevel_bayesquad_from_data_wrong_inputs(kernel, measure, rng):
 def test_multilevel_bayesquad_from_data_equals_bq_with_trivial_data_1d():
     """Test that multilevel BQ equals BQ when all but one level are given non-zero
     function evaluations for 1D data."""
-    input_dim = 1
     n_level = 5
     domain = (0, 3.3)
-    nodes = ()
-    nodes = [np.linspace(0, 1, 2 * l + 1)[:, None] for l in range(n_level)]
+    nodes = tuple(np.linspace(0, 1, 2 * l + 1)[:, None] for l in range(n_level))
     for i in range(n_level):
         jitter = 1e-5 * (i + 1.0)
-        fun_diff_evals = [np.zeros(shape=(len(xs),)) for xs in nodes]
         fun_evals = nodes[i][:, 0] ** (2 + 0.3 * i) + 1.2
+        fun_diff_evals = [np.zeros(shape=(len(xs),)) for xs in nodes]
         fun_diff_evals[i] = fun_evals
         mlbq_integral, _ = multilevel_bayesquad_from_data(
-            nodes=tuple(nodes),
+            nodes=nodes,
             fun_diff_evals=tuple(fun_diff_evals),
             domain=domain,
             options=dict(jitter=jitter),
@@ -312,16 +341,16 @@ def test_multilevel_bayesquad_from_data_equals_bq_with_trivial_data_2d():
     n_level = 5
     measure = GaussianMeasure(np.full((input_dim,), 0.2), cov=0.6 * np.eye(input_dim))
     _gh = gauss_hermite_tensor
-    nodes = [
+    nodes = tuple(
         _gh(l + 1, input_dim, measure.mean, measure.cov)[0] for l in range(n_level)
-    ]
+    )
     for i in range(n_level):
         jitter = 1e-5 * (i + 1.0)
-        fun_diff_evals = [np.zeros(shape=(len(xs),)) for xs in nodes]
         fun_evals = np.sin(nodes[i][:, 0] * i) + (i + 1.0) * np.cos(nodes[i][:, 1])
+        fun_diff_evals = [np.zeros(shape=(len(xs),)) for xs in nodes]
         fun_diff_evals[i] = fun_evals
         mlbq_integral, _ = multilevel_bayesquad_from_data(
-            nodes=tuple(nodes),
+            nodes=nodes,
             fun_diff_evals=tuple(fun_diff_evals),
             measure=measure,
             options=dict(jitter=jitter),