From 9330bc00e7a0a06b43b4dd00394673d380dacc87 Mon Sep 17 00:00:00 2001 From: Kucharssim Date: Wed, 12 Feb 2025 09:45:28 +0100 Subject: [PATCH 1/6] add .predict() to model comparison approximator --- .../model_comparison_approximator.py | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/bayesflow/approximators/model_comparison_approximator.py b/bayesflow/approximators/model_comparison_approximator.py index c10b403e4..6e37a843e 100644 --- a/bayesflow/approximators/model_comparison_approximator.py +++ b/bayesflow/approximators/model_comparison_approximator.py @@ -1,6 +1,7 @@ from collections.abc import Mapping, Sequence import keras +import numpy as np from keras.saving import ( deserialize_keras_object as deserialize, register_keras_serializable as serializable, @@ -198,3 +199,44 @@ def get_config(self): } return base_config | config + + def predict( + self, + *, + conditions: dict[str, np.ndarray], + logits: bool = False, + **kwargs, + ) -> np.ndarray: + conditions = self.adapter(conditions, strict=False, stage="inference", **kwargs) + conditions = keras.tree.map_structure(keras.ops.convert_to_tensor, conditions) + + output = self._predict(**conditions, **kwargs) + + if not logits: + output = keras.ops.softmax(output) + + output = keras.ops.convert_to_numpy(output) + + return output + + def _predict(self, classifier_conditions: Tensor = None, summary_variables: Tensor = None, **kwargs) -> Tensor: + if self.summary_network is None: + if summary_variables is not None: + raise ValueError("Cannot use summary variables without a summary network.") + else: + if summary_variables is None: + raise ValueError("Summary variables are required when a summary network is present") + + summary_outputs = self.summary_network( + summary_variables, **filter_kwargs(kwargs, self.summary_network.call) + ) + + if classifier_conditions is None: + classifier_conditions = summary_outputs + else: + classifier_conditions = keras.ops.concatenate([classifier_conditions, summary_outputs], axis=1) + + output = self.classifier_network(classifier_conditions) + output = self.logits_projector(output) + + return output From 4f52af8549d682f1dd6c8f40cad2aa7341b7243f Mon Sep 17 00:00:00 2001 From: Kucharssim Date: Thu, 13 Feb 2025 08:37:14 +0100 Subject: [PATCH 2/6] mc_calibration: pred_models should be first --- bayesflow/diagnostics/plots/mc_confusion_matrix.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/bayesflow/diagnostics/plots/mc_confusion_matrix.py b/bayesflow/diagnostics/plots/mc_confusion_matrix.py index 68cc2cc69..577424325 100644 --- a/bayesflow/diagnostics/plots/mc_confusion_matrix.py +++ b/bayesflow/diagnostics/plots/mc_confusion_matrix.py @@ -13,8 +13,8 @@ def mc_confusion_matrix( - true_models: dict[str, np.ndarray] | np.ndarray, pred_models: dict[str, np.ndarray] | np.ndarray, + true_models: dict[str, np.ndarray] | np.ndarray, model_names: Sequence[str] = None, fig_size: tuple = (5, 5), label_fontsize: int = 16, @@ -31,10 +31,10 @@ def mc_confusion_matrix( Parameters ---------- - true_models : np.ndarray of shape (num_data_sets, num_models) - The one-hot-encoded true model indices per data set. pred_models : np.ndarray of shape (num_data_sets, num_models) The predicted posterior model probabilities (PMPs) per data set. + true_models : np.ndarray of shape (num_data_sets, num_models) + The one-hot-encoded true model indices per data set. model_names : list or None, optional, default: None The model names for nice plot titles. Inferred if None. fig_size : tuple or None, optional, default: (5, 5) From d421c779f4b191ecca53b0f1c5930b7e1ddee5bf Mon Sep 17 00:00:00 2001 From: Kucharssim Date: Thu, 13 Feb 2025 11:47:34 +0100 Subject: [PATCH 3/6] changes to the model comparison simulator: - individual models can rely on a shared simulations (makes mixed batches much more useable) - mixed batches are sampled more efficiently (batched samples per model, rather than batching individual simulations) --- .../simulators/model_comparison_simulator.py | 44 ++++++++++++------- 1 file changed, 28 insertions(+), 16 deletions(-) diff --git a/bayesflow/simulators/model_comparison_simulator.py b/bayesflow/simulators/model_comparison_simulator.py index abc3d4ec3..7186f024a 100644 --- a/bayesflow/simulators/model_comparison_simulator.py +++ b/bayesflow/simulators/model_comparison_simulator.py @@ -2,12 +2,15 @@ import numpy as np from bayesflow.types import Shape -from bayesflow.utils import tree_stack +from bayesflow.utils import tree_concatenate from bayesflow.utils.decorators import allow_batch_size from bayesflow.utils import numpy_utils as npu +from types import FunctionType + from .simulator import Simulator +from .lambda_simulator import LambdaSimulator class ModelComparisonSimulator(Simulator): @@ -18,10 +21,15 @@ def __init__( simulators: Sequence[Simulator], p: Sequence[float] = None, logits: Sequence[float] = None, - use_mixed_batches: bool = False, + use_mixed_batches: bool = True, + shared_simulator: Simulator | FunctionType = None, ): self.simulators = simulators + if isinstance(shared_simulator, FunctionType): + shared_simulator = LambdaSimulator(shared_simulator, is_batched=True) + self.shared_simulator = shared_simulator + match logits, p: case (None, None): logits = [0.0] * len(simulators) @@ -43,30 +51,34 @@ def __init__( @allow_batch_size def sample(self, batch_shape: Shape, **kwargs) -> dict[str, np.ndarray]: + data = {} + if self.shared_simulator: + data |= self.shared_simulator.sample(batch_shape, **kwargs) + if not self.use_mixed_batches: # draw one model index for the whole batch (faster) model_index = np.random.choice(len(self.simulators), p=npu.softmax(self.logits)) simulator = self.simulators[model_index] - data = simulator.sample(batch_shape) + data = simulator.sample(batch_shape, **(kwargs | data)) model_indices = np.full(batch_shape, model_index, dtype="int32") + model_indices = npu.one_hot(model_indices, len(self.simulators)) else: - # draw a model index for each sample in the batch (slower) - model_indices = np.random.choice(len(self.simulators), p=npu.softmax(self.logits), size=batch_shape) - - data = np.empty(batch_shape, dtype="object") - - for index in np.ndindex(batch_shape): - simulator = self.simulators[int(model_indices[index])] - data[index] = simulator.sample(()) + # generate data randomly from each model (slower) + model_counts = np.random.multinomial(n=batch_shape[0], pvals=npu.softmax(self.logits)) - data = data.flatten().tolist() - data = tree_stack(data, axis=0, numpy=True) + sims = [] + for n, simulator in zip(model_counts, self.simulators): + if n == 0: + continue + sim = simulator.sample(n, **(kwargs | data)) + sims.append(sim) - # restore batch shape - data = {key: np.reshape(value, batch_shape + np.shape(value)[1:]) for key, value in data.items()} + sims = tree_concatenate(sims, numpy=True) + data |= sims - model_indices = npu.one_hot(model_indices, len(self.simulators)) + model_indices = np.eye(len(self.simulators), dtype="int32") + model_indices = np.repeat(model_indices, model_counts, axis=0) return data | {"model_indices": model_indices} From ff45155daef1a1f5192835ce06725521872cf964 Mon Sep 17 00:00:00 2001 From: Kucharssim Date: Thu, 13 Feb 2025 12:36:29 +0100 Subject: [PATCH 4/6] fix mc_confusion_matrix plot --- .../diagnostics/plots/mc_confusion_matrix.py | 25 +++++++++---------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/bayesflow/diagnostics/plots/mc_confusion_matrix.py b/bayesflow/diagnostics/plots/mc_confusion_matrix.py index 577424325..982e331cb 100644 --- a/bayesflow/diagnostics/plots/mc_confusion_matrix.py +++ b/bayesflow/diagnostics/plots/mc_confusion_matrix.py @@ -23,7 +23,7 @@ def mc_confusion_matrix( tick_fontsize: int = 12, xtick_rotation: int = None, ytick_rotation: int = None, - normalize: bool = True, + normalize: str = None, cmap: matplotlib.colors.Colormap | str = None, title: bool = True, ) -> plt.Figure: @@ -51,9 +51,11 @@ def mc_confusion_matrix( Rotation of x-axis tick labels (helps with long model names). ytick_rotation: int, optional, default: None Rotation of y-axis tick labels (helps with long model names). - normalize : bool, optional, default: True - A flag for normalization of the confusion matrix. - If True, each row of the confusion matrix is normalized to sum to 1. + normalize : {'true', 'pred', 'all'}, default=None + Passed to sklearn.metrics.confusion_matrix. + Normalizes confusion matrix over the true (rows), predicted (columns) + conditions or all the population. If None, confusion matrix will not be + normalized. cmap : matplotlib.colors.Colormap or str, optional, default: None Colormap to be used for the cells. If a str, it should be the name of a registered colormap, e.g., 'viridis'. Default colormap matches the BayesFlow defaults by ranging from white to red. @@ -77,29 +79,26 @@ def mc_confusion_matrix( pred_models = ops.argmax(pred_models, axis=1) # Compute confusion matrix - cm = confusion_matrix(true_models, pred_models) - - # if normalize: - # # Sum along rows and keep dimensions for broadcasting - # cm_sum = ops.sum(cm, axis=1, keepdims=True) - # - # # Broadcast division for normalization - # cm_normalized = cm / cm_sum + cm = confusion_matrix(true_models, pred_models, normalize=normalize) # Initialize figure fig, ax = make_figure(1, 1, figsize=fig_size) + ax = ax[0] im = ax.imshow(cm, interpolation="nearest", cmap=cmap) cbar = ax.figure.colorbar(im, ax=ax, shrink=0.75) cbar.ax.tick_params(labelsize=value_fontsize) - ax.set(xticks=ops.arange(cm.shape[1]), yticks=ops.arange(cm.shape[0])) + ax.set_xticks(range(cm.shape[0])) ax.set_xticklabels(model_names, fontsize=tick_fontsize) if xtick_rotation: plt.xticks(rotation=xtick_rotation, ha="right") + + ax.set_yticks(range(cm.shape[1])) ax.set_yticklabels(model_names, fontsize=tick_fontsize) if ytick_rotation: plt.yticks(rotation=ytick_rotation) + ax.set_xlabel("Predicted model", fontsize=label_fontsize) ax.set_ylabel("True model", fontsize=label_fontsize) From 70acae6a2959bca17da3623f30293147f9bbc086 Mon Sep 17 00:00:00 2001 From: Kucharssim Date: Thu, 13 Feb 2025 13:45:40 +0100 Subject: [PATCH 5/6] add simple model comparison notebook --- README.md | 3 +- examples/One_Sample_TTest.ipynb | 553 ++++++++++++++++++++++++++++++++ 2 files changed, 555 insertions(+), 1 deletion(-) create mode 100644 examples/One_Sample_TTest.ipynb diff --git a/README.md b/README.md index ed044a4aa..b883eab7b 100644 --- a/README.md +++ b/README.md @@ -99,7 +99,8 @@ Check out some of our walk-through notebooks below. We are actively working on p 4. [SBML model using an external simulator](examples/From_ABC_to_BayesFlow.ipynb) 5. [Hyperparameter optimization](examples/Hyperparameter_Optimization.ipynb) 6. [Bayesian experimental design](examples/Bayesian_Experimental_Design.ipynb) -7. More coming soon... +7. [Simple model comparison example (One-Sample T-Test)](examples/One_Sample_TTest.ipynb) +8. More coming soon... ## Documentation \& Help diff --git a/examples/One_Sample_TTest.ipynb b/examples/One_Sample_TTest.ipynb new file mode 100644 index 000000000..1a4935b87 --- /dev/null +++ b/examples/One_Sample_TTest.ipynb @@ -0,0 +1,553 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simple Model Comparison - One Sample T-Test\n", + "\n", + "_Authors: Šimon Kucharský_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, we will show how to do a simple model comparison in bayesflow, amortized over the number of observations." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "vscode": { + "languageId": "powershell" + } + }, + "outputs": [], + "source": [ + "# Use the latest version of bayesflow\n", + "# !pip install git+https://github.com/bayesflow-org/bayesflow.git@dev" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "import os\n", + "if \"KERAS_BACKEND\" not in os.environ:\n", + " # set this to \"torch\", \"tensorflow\", or \"jax\"\n", + " os.environ[\"KERAS_BACKEND\"] = \"jax\"\n", + " \n", + "import keras\n", + "import bayesflow as bf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulator\n", + "\n", + "First we define our simulators, one for every model that we want to compare. In this notebook, we will use two simple models\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\mathcal{M}_0: \\mu & = 0 \\\\\n", + "\\mathcal{M}_1: \\mu & \\sim \\text{Normal}(0, 1) \\\\ \n", + "\\\\\n", + "n & \\sim \\text{Uniform}(10, 100) \\\\\n", + "x_i & \\sim \\text{Normal}(\\mu, 1) \\text{ for } i \\in \\{1, \\dots, n \\} \\\\\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "Each model has their own prior but the likelihood (that is responsible for simulating the data $x$) remains the same for both models.\n", + "\n", + "Once we define the two simulators, we wrap them in one overarching simulator that simulates from both models at the same time, for the purpose of training the networks from either of the models. Our context variable $n$ is the _sample size_ that we amortize over as is used as a shared simulator for both models, so that data within each simulated batch can consist of simulations from either model, buth with the same sample size." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def context(batch_shape, n=None):\n", + " if n is None:\n", + " n = np.random.randint(5, 50)\n", + " return dict(n = n)\n", + "\n", + "def prior_null():\n", + " return dict(mu = 0.0)\n", + "\n", + "def prior_alternative():\n", + " mu = np.random.normal(loc=0, scale=1)\n", + " return dict(mu = mu)\n", + "\n", + "def likelihood(n, mu):\n", + " x = np.random.normal(loc=mu, scale=1, size=n)\n", + " return dict(x=x)\n", + "\n", + "simulator_null = bf.make_simulator([prior_null, likelihood])\n", + "simulator_alternative = bf.make_simulator([prior_alternative, likelihood])\n", + "simulator = bf.simulators.ModelComparisonSimulator(\n", + " simulators=[simulator_null, simulator_alternative], \n", + " use_mixed_batches=True, \n", + " shared_simulator=context)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can simulate some data to see what the simulator produces." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n = 41\n", + "n shape: ()\n", + "mu shape: (100, 1)\n", + "x shape: (100, 41)\n", + "model_indices shape: (100, 2)\n" + ] + } + ], + "source": [ + "data = simulator.sample(100)\n", + "print(\"n =\", data[\"n\"])\n", + "for key, value in data.items():\n", + " print(key + \" shape:\", np.array(value).shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that the simulator automaticall adds `model_indices`, which indicates which data was generated which model (it is one-hot encoded, therefore will have as many columns as models).\n", + "\n", + "The size of the observations `x` depends on the context variable `n`. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining the neural networks\n", + "\n", + "To ensure that the training data generated by the simulator can be used for deep learning, we have to do some transformations that will put the data into necessary structures. Here, we will define an `adapter` that takes the data and transforms the input." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "adapter = (\n", + " bf.Adapter()\n", + " .broadcast(\"n\", to=\"x\")\n", + " .as_set(\"x\")\n", + " .rename(\"n\", \"classifier_conditions\")\n", + " .rename(\"x\", \"summary_variables\")\n", + " .drop('mu')\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is what the adapter is doing:\n", + "\n", + "- `.broadcast(\"n\", to=\"x\")` copies the value of `n` `batch_size` times to ensure that it will also have a dimension `(batch_size,)` even though during simulations it was just a single value that is constant over all simulations within the batch. The batch size is inferred from the shape of `x`.\n", + "- `.as_set(\"n\")` indicates that `x` is treated as a set. Their values will be treated as _exchangeable_, meaning that the inference will be the same regardless of their order. \n", + "- `.rename(\"n\", \"classifier_conditions\")` to make an inference for model comparison, we need to know the sample size. Here, we make sure that `n` is passed directly into the classification network as its condition.\n", + "- `.rename(\"x\", \"summary_variables\")` the data `x` will be passed through a summary network. The output of the summary network will be automatically concatenated with `classifier_conditions` before passing them together into the classification network.\n", + "- `.drop(\"mu\")` drops the parameter values `mu` which are not used during model comparison.\n", + "\n", + "We can now apply the adapter to simulated data to see the results" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_indices shape: (100, 2)\n", + "classifier_conditions shape: (100, 1)\n", + "summary_variables shape: (100, 41, 1)\n" + ] + } + ], + "source": [ + "processed_data=adapter(data)\n", + "for key, value in processed_data.items():\n", + " print(key + \" shape:\", value.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All those shapes are correct now. To summarise, we have\n", + "\n", + "- `model_indices`: The indicators of which model produced the data (one-hot encoded)\n", + "- `classifier_conditions`: `n` repeated `batch_size` times\n", + "- `summary_variables`: The observations `x` with shape `(100, n, 1)`. The last axis is added by `as_set` such that it can be passed into a summary network" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can finally define our networks. \n", + "\n", + "As a summary network, we will use a simple deep set architecture which is appropriate for summarising exchangeable data. \n", + "\n", + "As a classification network, we will use a simple multilayer perceptron with 8 hidden layers, each with 32 neurons and ReLU activation function." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "summary_network = bf.networks.DeepSet(summary_dim=4, dropout=0.0)\n", + "classifier_network = keras.Sequential(\n", + " [keras.layers.Dense(32, activation=\"relu\") for _ in range(8)]\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now define our `approximator` consisting of the two networks and the adapter defined above." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "approximator = bf.approximators.ModelComparisonApproximator(\n", + " num_models=2, \n", + " classifier_network=classifier_network,\n", + " summary_network=summary_network, \n", + " adapter=adapter)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "Now we are ready to train our approximator that will alow us to compare the two models.\n", + "\n", + "To achieve this, we will define a bunch of parameters that indicate how long and on how much data we want the train the models." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "num_batches = 64\n", + "batch_size = 512\n", + "epochs = 20" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we define our optimizer, and specify a schedule for its learning rate. In here, we use a `CosineDecay` schedule for `Adam` optimizer." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "learning_rate = keras.optimizers.schedules.CosineDecay(1e-4, decay_steps=epochs*num_batches, alpha=1e-5)\n", + "optimizer = keras.optimizers.Adam(learning_rate=learning_rate, clipnorm=1.0)\n", + "approximator.compile(optimizer=optimizer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And we can fit the networks now!" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:bayesflow:Building dataset from simulator instance of ModelComparisonSimulator.\n", + "INFO:bayesflow:Using 10 data loading workers.\n", + "INFO:bayesflow:Building on a test batch.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m47s\u001b[0m 718ms/step - loss: 0.6690 - loss/classifier_loss: 0.6690\n", + "Epoch 2/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 184ms/step - loss: 0.5315 - loss/classifier_loss: 0.5315\n", + "Epoch 3/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 107ms/step - loss: 0.4293 - loss/classifier_loss: 0.4293\n", + "Epoch 4/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 42ms/step - loss: 0.4099 - loss/classifier_loss: 0.4099\n", + "Epoch 5/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 49ms/step - loss: 0.3929 - loss/classifier_loss: 0.3929\n", + "Epoch 6/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 52ms/step - loss: 0.4036 - loss/classifier_loss: 0.4036\n", + "Epoch 7/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 46ms/step - loss: 0.4066 - loss/classifier_loss: 0.4066\n", + "Epoch 8/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 45ms/step - loss: 0.3983 - loss/classifier_loss: 0.3983\n", + "Epoch 9/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 45ms/step - loss: 0.4059 - loss/classifier_loss: 0.4059\n", + "Epoch 10/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 43ms/step - loss: 0.4010 - loss/classifier_loss: 0.4010\n", + "Epoch 11/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 48ms/step - loss: 0.4011 - loss/classifier_loss: 0.4011\n", + "Epoch 12/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 54ms/step - loss: 0.3972 - loss/classifier_loss: 0.3972\n", + "Epoch 13/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 45ms/step - loss: 0.4088 - loss/classifier_loss: 0.4088\n", + "Epoch 14/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 47ms/step - loss: 0.4018 - loss/classifier_loss: 0.4018\n", + "Epoch 15/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 48ms/step - loss: 0.3787 - loss/classifier_loss: 0.3787\n", + "Epoch 16/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 42ms/step - loss: 0.4122 - loss/classifier_loss: 0.4122\n", + "Epoch 17/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 47ms/step - loss: 0.3896 - loss/classifier_loss: 0.3896\n", + "Epoch 18/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 49ms/step - loss: 0.3895 - loss/classifier_loss: 0.3895\n", + "Epoch 19/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 42ms/step - loss: 0.3969 - loss/classifier_loss: 0.3969\n", + "Epoch 20/20\n", + "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 48ms/step - loss: 0.3744 - loss/classifier_loss: 0.3744\n" + ] + } + ], + "source": [ + "history = approximator.fit(\n", + " epochs=epochs,\n", + " num_batches=num_batches,\n", + " batch_size=batch_size,\n", + " simulator=simulator,\n", + " adapter=adapter\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once training is done, we can visualise the losses." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f=bf.diagnostics.plots.loss(history=history)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Validation\n", + "\n", + "Once we trained the model, we can inspect whether the classification does what we expect it to do.\n", + "\n", + "Here, we will generate a validation dataset which has been fixed to generate data of _sample size_ $n=10$. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "(5000, 10)\n" + ] + } + ], + "source": [ + "df=simulator.sample(5000, n=10)\n", + "print(df[\"n\"])\n", + "print(df[\"x\"].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To apply our approximator on this dataset, we simply use the `.predict` method to obtain the predicted posterior model probabilities, given the data and the approximator." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "pred_models=approximator.predict(conditions=df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We inspect the model comparison calibration now." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:matplotlib.mathtext:Substituting symbol M from STIXNonUnicode\n", + "INFO:matplotlib.mathtext:Substituting symbol M from STIXNonUnicode\n", + "INFO:matplotlib.mathtext:Substituting symbol M from STIXNonUnicode\n", + "INFO:matplotlib.mathtext:Substituting symbol M from STIXNonUnicode\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f=bf.diagnostics.plots.mc_calibration(\n", + " pred_models=pred_models, \n", + " true_models=df[\"model_indices\"],\n", + " model_names=[r\"$\\mathcal{M}_0$\",r\"$\\mathcal{M}_1$\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And the confusion matrix to inspect how often we would make an accurate decision based on picking the model with the highest posterior probability." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:matplotlib.mathtext:Substituting symbol M from STIXNonUnicode\n", + "INFO:matplotlib.mathtext:Substituting symbol M from STIXNonUnicode\n", + "INFO:matplotlib.mathtext:Substituting symbol M from STIXNonUnicode\n", + "INFO:matplotlib.mathtext:Substituting symbol M from STIXNonUnicode\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f=bf.diagnostics.plots.mc_confusion_matrix(\n", + " pred_models=pred_models, \n", + " true_models=df['model_indices'], \n", + " model_names=[r\"$\\mathcal{M}_0$\",r\"$\\mathcal{M}_1$\"],\n", + " normalize=\"true\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bayesflow-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 379f8c03466ef53ec4ec32d4b2e61ba7a3b44dea Mon Sep 17 00:00:00 2001 From: Kucharssim Date: Fri, 14 Feb 2025 15:45:48 +0100 Subject: [PATCH 6/6] flip pred_models and true_models in the docs --- bayesflow/diagnostics/plots/mc_calibration.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bayesflow/diagnostics/plots/mc_calibration.py b/bayesflow/diagnostics/plots/mc_calibration.py index dc863c465..535518afc 100644 --- a/bayesflow/diagnostics/plots/mc_calibration.py +++ b/bayesflow/diagnostics/plots/mc_calibration.py @@ -34,10 +34,10 @@ def mc_calibration( Parameters ---------- - true_models : np.ndarray of shape (num_data_sets, num_models) - The one-hot-encoded true model indices per data set. pred_models : np.ndarray of shape (num_data_sets, num_models) The predicted posterior model probabilities (PMPs) per data set. + true_models : np.ndarray of shape (num_data_sets, num_models) + The one-hot-encoded true model indices per data set. model_names : list or None, optional, default: None The model names for nice plot titles. Inferred if None. num_bins : int, optional, default: 10