rename summary_outputs to summaries

- add summaries function to ModelCommparisonApproximator as well
- add tests for the approximator.summaries functions

Author: vpratz

bayesflow/approximators/continuous_approximator.py

@@ -400,9 +400,9 @@ def _sample(
             **filter_kwargs(kwargs, self.inference_network.sample),
         )
 
-    def summary_outputs(self, data: Mapping[str, np.ndarray], **kwargs):
+    def summaries(self, data: Mapping[str, np.ndarray], **kwargs):
         """
-        Computes the summary outputs of given data.
+        Computes the summaries of given data.
 
         The `data` dictionary is preprocessed using the `adapter` and passed through the summary network.
 
@@ -415,7 +415,7 @@ def summary_outputs(self, data: Mapping[str, np.ndarray], **kwargs):
 
         Returns
         -------
-        summary_outputs : np.ndarray
+        summaries : np.ndarray
             Log-probabilities of the distribution `p(inference_variables | inference_conditions, h(summary_conditions))`
 
         Raises
@@ -425,13 +425,13 @@ def summary_outputs(self, data: Mapping[str, np.ndarray], **kwargs):
             by the summary network.
         """
         if self.summary_network is None:
-            raise ValueError("A summary network is required to compute summary outputs.")
+            raise ValueError("A summary network is required to compute summeries.")
         data_adapted = self.adapter(data, strict=False, stage="inference", **kwargs)
         if "summary_variables" not in data_adapted or data_adapted["summary_variables"] is None:
-            raise ValueError("Summary variables are required to compute summary outputs")
+            raise ValueError("Summary variables are required to compute summaries.")
         summary_variables = keras.ops.convert_to_tensor(data_adapted["summary_variables"])
-        summary_outputs = self.summary_network(summary_variables, **filter_kwargs(kwargs, self.summary_network.call))
-        return summary_outputs
+        summaries = self.summary_network(summary_variables, **filter_kwargs(kwargs, self.summary_network.call))
+        return summaries
 
     def log_prob(self, data: Mapping[str, np.ndarray], **kwargs) -> np.ndarray | dict[str, np.ndarray]:
         """

bayesflow/approximators/model_comparison_approximator.py

@@ -345,3 +345,36 @@ def _predict(self, classifier_conditions: Tensor = None, summary_variables: Tens
         output = self.logits_projector(output)
 
         return output
+
+    def summaries(self, data: Mapping[str, np.ndarray], **kwargs):
+        """
+        Computes the summaries of given data.
+
+        The `data` dictionary is preprocessed using the `adapter` and passed through the summary network.
+
+        Parameters
+        ----------
+        data : Mapping[str, np.ndarray]
+            Dictionary of data as NumPy arrays.
+        **kwargs : dict
+            Additional keyword arguments for the adapter and the summary network.
+
+        Returns
+        -------
+        summaries : np.ndarray
+            Log-probabilities of the distribution `p(inference_variables | inference_conditions, h(summary_conditions))`
+
+        Raises
+        ------
+        ValueError
+            If the approximator does not have a summary network, or the adapter does not produce the output required
+            by the summary network.
+        """
+        if self.summary_network is None:
+            raise ValueError("A summary network is required to compute summaries.")
+        data_adapted = self.adapter(data, strict=False, stage="inference", **kwargs)
+        if "summary_variables" not in data_adapted or data_adapted["summary_variables"] is None:
+            raise ValueError("Summary variables are required to compute summaries.")
+        summary_variables = keras.ops.convert_to_tensor(data_adapted["summary_variables"])
+        summaries = self.summary_network(summary_variables, **filter_kwargs(kwargs, self.summary_network.call))
+        return summaries

bayesflow/diagnostics/metrics/model_misspecification.py

@@ -142,8 +142,8 @@ def summary_space_comparison(
             "statistics, or want to compare raw data and not summary statistics, please use the "
             f"`bootstrap_comparison` function with `comparison_fn={comparison_fn_name}` on the respective arrays."
         )
-    observed_summaries = convert_to_numpy(approximator.summary_outputs(observed_data))
-    reference_summaries = convert_to_numpy(approximator.summary_outputs(reference_data))
+    observed_summaries = convert_to_numpy(approximator.summaries(observed_data))
+    reference_summaries = convert_to_numpy(approximator.summaries(reference_data))
 
     distance_observed, distance_null = bootstrap_comparison(
         observed_samples=observed_summaries,

tests/test_approximators/conftest.py

@@ -163,3 +163,34 @@ def validation_dataset(batch_size, adapter, simulator):
     num_batches = 2
     data = simulator.sample((num_batches * batch_size,))
     return OfflineDataset(data=data, adapter=adapter, batch_size=batch_size, workers=4, max_queue_size=num_batches)
+
+
+@pytest.fixture()
+def mean_std_summary_network():
+    from tests.utils import MeanStdSummaryNetwork
+
+    return MeanStdSummaryNetwork()
+
+
+@pytest.fixture(params=["continuous_approximator", "point_approximator", "model_comparison_approximator"])
+def approximator_with_summaries(request):
+    from bayesflow.adapters import Adapter
+
+    adapter = Adapter()
+    match request.param:
+        case "continuous_approximator":
+            from bayesflow.approximators import ContinuousApproximator
+
+            return ContinuousApproximator(adapter=adapter, inference_network=None, summary_network=None)
+        case "point_approximator":
+            from bayesflow.approximators import PointApproximator
+
+            return PointApproximator(adapter=adapter, inference_network=None, summary_network=None)
+        case "model_comparison_approximator":
+            from bayesflow.approximators import ModelComparisonApproximator
+
+            return ModelComparisonApproximator(
+                num_models=2, classifier_network=None, adapter=adapter, summary_network=None
+            )
+        case _:
+            raise ValueError("Invalid param for approximator class.")

tests/test_approximators/test_summaries.py

@@ -0,0 +1,23 @@
+import pytest
+from tests.utils import assert_allclose
+import keras
+
+
+def test_valid_summaries(approximator_with_summaries, mean_std_summary_network, monkeypatch):
+    monkeypatch.setattr(approximator_with_summaries, "summary_network", mean_std_summary_network)
+    summaries = approximator_with_summaries.summaries({"summary_variables": keras.ops.ones((2, 3))})
+    assert_allclose(summaries, keras.ops.stack([keras.ops.ones((2,)), keras.ops.zeros((2,))], axis=-1))
+
+
+def test_no_summary_network(approximator_with_summaries, monkeypatch):
+    monkeypatch.setattr(approximator_with_summaries, "summary_network", None)
+
+    with pytest.raises(ValueError):
+        approximator_with_summaries.summaries({"summary_variables": keras.ops.ones((2, 3))})
+
+
+def test_no_summary_variables(approximator_with_summaries, mean_std_summary_network, monkeypatch):
+    monkeypatch.setattr(approximator_with_summaries, "summary_network", mean_std_summary_network)
+
+    with pytest.raises(ValueError):
+        approximator_with_summaries.summaries({})

tests/test_diagnostics/conftest.py

@@ -89,12 +89,6 @@ def adapter():
 
 @pytest.fixture()
 def summary_network():
-    from bayesflow.networks import SummaryNetwork
+    from tests.utils import MeanStdSummaryNetwork
 
-    class DummySummaryNetwork(SummaryNetwork):
-        def call(self, x):
-            summary_outputs = keras.ops.stack([keras.ops.mean(x, axis=-1), keras.ops.std(x, axis=-1)], axis=-1)
-            print("summary_outputs", summary_outputs)
-            return summary_outputs
-
-    return DummySummaryNetwork()
+    return MeanStdSummaryNetwork()

tests/utils/__init__.py

@@ -2,4 +2,5 @@
 from .callbacks import *
 from .check_combinations import *
 from .jupyter import *
+from .networks import *
 from .ops import *

tests/utils/networks.py

@@ -0,0 +1,8 @@
+from bayesflow.networks import SummaryNetwork
+import keras
+
+
+class MeanStdSummaryNetwork(SummaryNetwork):
+    def call(self, x):
+        summary_outputs = keras.ops.stack([keras.ops.mean(x, axis=-1), keras.ops.std(x, axis=-1)], axis=-1)
+        return summary_outputs