From 71b6eac8da929775da4e31f92ca7abb8e2c35130 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 5 Sep 2024 11:01:06 +0200
Subject: [PATCH 01/17] wip: first draft on categorical made

---
 sbi/neural_nets/estimators/categorical_net.py | 93 ++++++++++++++++++-
 1 file changed, 92 insertions(+), 1 deletion(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index e1f3ea8ca..81f904919 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -4,13 +4,104 @@
 from typing import Optional
 
 import torch
-from torch import Tensor, nn
+from torch import Tensor, nn, distributions
 from torch.distributions import Categorical
 from torch.nn import Sigmoid, Softmax
 
 from sbi.neural_nets.estimators.base import ConditionalDensityEstimator
+from nflows.nn.nde.made import MADE
+from torch.nn import functional as F
+from nflows.utils import torchutils
+import numpy as np
 
 
+class CategoricalMADE(MADE):
+    def __init__(
+        self,
+        categories, # List[int] or Tensor[int]
+        hidden_features,
+        context_features=None,
+        num_blocks=2,
+        use_residual_blocks=True,
+        random_mask=False,
+        activation=F.relu,
+        dropout_probability=0.0,
+        use_batch_norm=False,
+        epsilon=1e-2,
+        custom_initialization=True,
+    ):
+
+        if use_residual_blocks and random_mask:
+            raise ValueError("Residual blocks can't be used with random masks.")
+
+        self.num_variables = len(categories)
+        self.max_categories = max(categories)
+        self.categories = categories
+
+        super().__init__(
+            self.num_variables,
+            hidden_features,
+            context_features=context_features,
+            num_blocks=num_blocks,
+            output_multiplier=self.max_categories,
+            use_residual_blocks=use_residual_blocks,
+            random_mask=random_mask,
+            activation=activation,
+            dropout_probability=dropout_probability,
+            use_batch_norm=use_batch_norm,
+        )
+
+        self.hidden_features = hidden_features
+        self.epsilon = epsilon
+
+        if custom_initialization:
+            self._initialize()
+
+    def forward(self, inputs, context=None):
+        return super().forward(inputs, context=context)
+    
+    def log_prob(self, inputs, context=None):
+        outputs = self.forward(inputs, context=context)
+        outputs = outputs.reshape(*inputs.shape, self.max_categories)
+        ps = F.softmax(outputs, dim=-1)
+
+        # TODO: trim the outputs to the actual number of categories
+        # outputs (batch_size, num_variables, max_categories)
+
+        log_prob = torch.zeros(inputs.shape[0])
+        for variable in range(self.num_variables):
+            ps_var = ps[:, variable, :self.categories[variable]] # trim the outputs to the actual number of categories
+            log_prob += Categorical(probs=ps_var).log_prob(input.squeeze(dim=-1))        
+        return log_prob
+
+    def sample(self, num_samples, context=None):
+
+        if context is not None:
+            context = torchutils.repeat_rows(context, num_samples)
+
+        with torch.no_grad():
+            
+            samples = torch.zeros(context.shape[0], self.num_variables)
+
+            for variable in range(self.num_variables):
+                outputs = self.forward(samples, context)
+                outputs = outputs.reshape(*samples.shape, self.max_categories)
+                ps = F.softmax(outputs, dim=-1)
+                ps_var = ps[:, variable, :self.categories[variable]]  # trim the outputs to the actual number of categories
+                samples[:, variable] = Categorical(probs=ps_var).sample(sample_shape=torch.Size(num_samples,)).detach()
+
+        return samples.reshape(-1, num_samples, self.num_variables)
+
+    def _initialize(self):
+        # TODO: initialize the weights and biases properly
+        # TODO: set empty categories to zero
+        self.final_layer.weight.data = self.epsilon * torch.randn(
+            self.num_variables * self.max_categories, self.hidden_features
+        )
+        self.final_layer.bias.data = self.epsilon * torch.randn(
+            self.num_variables * self.max_categories
+        )
+
 class CategoricalNet(nn.Module):
     """Conditional density (mass) estimation for a categorical random variable.
 

From abac11429d800f7eb0a9f645f68b12a05439898b Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 5 Sep 2024 15:19:35 +0200
Subject: [PATCH 02/17] wip: forward, log_prob, sample working

---
 sbi/neural_nets/estimators/__init__.py        |  1 +
 sbi/neural_nets/estimators/categorical_net.py | 38 +++++++++----------
 2 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/sbi/neural_nets/estimators/__init__.py b/sbi/neural_nets/estimators/__init__.py
index 370dfb01e..a8792bd93 100644
--- a/sbi/neural_nets/estimators/__init__.py
+++ b/sbi/neural_nets/estimators/__init__.py
@@ -2,6 +2,7 @@
 from sbi.neural_nets.estimators.categorical_net import (
     CategoricalMassEstimator,
     CategoricalNet,
+    CategoricalMADE,
 )
 from sbi.neural_nets.estimators.flowmatching_estimator import FlowMatchingEstimator
 from sbi.neural_nets.estimators.mixed_density_estimator import (
diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 81f904919..7c89b672e 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -37,6 +37,9 @@ def __init__(
         self.num_variables = len(categories)
         self.max_categories = max(categories)
         self.categories = categories
+        self.mask = torch.zeros(self.num_variables, self.max_categories)
+        for i, c in enumerate(categories):
+            self.mask[i, :c] = 1
 
         super().__init__(
             self.num_variables,
@@ -60,18 +63,21 @@ def __init__(
     def forward(self, inputs, context=None):
         return super().forward(inputs, context=context)
     
+    def compute_probs(self, outputs):
+        ps = F.softmax(outputs, dim=-1)*self.mask
+        ps = ps / ps.sum(dim=-1, keepdim=True)
+        return ps
+        
+    # outputs (batch_size, num_variables, max_categories)
     def log_prob(self, inputs, context=None):
         outputs = self.forward(inputs, context=context)
         outputs = outputs.reshape(*inputs.shape, self.max_categories)
-        ps = F.softmax(outputs, dim=-1)
-
-        # TODO: trim the outputs to the actual number of categories
-        # outputs (batch_size, num_variables, max_categories)
-
-        log_prob = torch.zeros(inputs.shape[0])
-        for variable in range(self.num_variables):
-            ps_var = ps[:, variable, :self.categories[variable]] # trim the outputs to the actual number of categories
-            log_prob += Categorical(probs=ps_var).log_prob(input.squeeze(dim=-1))        
+        ps = self.compute_probs(outputs)
+        
+        # categorical log prob
+        log_prob = torch.log(ps.gather(-1, inputs.unsqueeze(-1).long()).squeeze(-1))
+        log_prob = log_prob.sum(dim=-1)
+       
         return log_prob
 
     def sample(self, num_samples, context=None):
@@ -86,21 +92,13 @@ def sample(self, num_samples, context=None):
             for variable in range(self.num_variables):
                 outputs = self.forward(samples, context)
                 outputs = outputs.reshape(*samples.shape, self.max_categories)
-                ps = F.softmax(outputs, dim=-1)
-                ps_var = ps[:, variable, :self.categories[variable]]  # trim the outputs to the actual number of categories
-                samples[:, variable] = Categorical(probs=ps_var).sample(sample_shape=torch.Size(num_samples,)).detach()
+                ps = self.compute_probs(outputs)
+                samples[:, variable] = Categorical(probs=ps[:,variable]).sample()
 
         return samples.reshape(-1, num_samples, self.num_variables)
 
     def _initialize(self):
-        # TODO: initialize the weights and biases properly
-        # TODO: set empty categories to zero
-        self.final_layer.weight.data = self.epsilon * torch.randn(
-            self.num_variables * self.max_categories, self.hidden_features
-        )
-        self.final_layer.bias.data = self.epsilon * torch.randn(
-            self.num_variables * self.max_categories
-        )
+        pass
 
 class CategoricalNet(nn.Module):
     """Conditional density (mass) estimation for a categorical random variable.

From f2db6eb1db1e2cab3472789d9958eaf95e6126cd Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 5 Sep 2024 21:43:20 +0200
Subject: [PATCH 03/17] wip: CategoricalMassEstimator can be build and
 MixedDensityEstimator too. log_prob has shape issues tho

---
 sbi/made_mnle.ipynb                           | 181 ++++++++++++++++++
 sbi/neural_nets/estimators/categorical_net.py |  13 +-
 sbi/neural_nets/net_builders/categorial.py    |  54 +++++-
 3 files changed, 240 insertions(+), 8 deletions(-)
 create mode 100644 sbi/made_mnle.ipynb

diff --git a/sbi/made_mnle.ipynb b/sbi/made_mnle.ipynb
new file mode 100644
index 000000000..34c3186c5
--- /dev/null
+++ b/sbi/made_mnle.ipynb
@@ -0,0 +1,181 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 499,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from sbi.neural_nets.estimators.categorical_net import CategoricalMADE, CategoricalMassEstimator\n",
+    "from sbi.utils.torchutils import BoxUniform\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sbi.inference import MNLE\n",
+    "from sbi.neural_nets.estimators import MixedDensityEstimator\n",
+    "from sbi.neural_nets.estimators.nflows_flow import NFlowsFlow\n",
+    "from sbi.neural_nets.net_builders.mdn import build_mdn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 487,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def toy_simulator(theta):\n",
+    "    x_centers = torch.tensor([[-0.5, 0.5]])\n",
+    "    y_centers = torch.tensor([[-1, 0, 1]])\n",
+    "\n",
+    "    x_c = x_centers[:,torch.argmin(torch.abs(x_centers.T - theta[:,0]), dim=0)]\n",
+    "    y_c = y_centers[:,torch.argmin(torch.abs(y_centers.T - theta[:,1]), dim=0)]\n",
+    "\n",
+    "    std2 = 0.3\n",
+    "    m = torch.cat([x_c, y_c])\n",
+    "    x_cont = m + std2*torch.randn(m.shape)    \n",
+    "\n",
+    "    # Calculate integer indices after x_cont is computed\n",
+    "    x_c = torch.argmin(torch.abs(x_centers.T - x_c), dim=0)\n",
+    "    y_c = torch.argmin(torch.abs(y_centers.T - y_c), dim=0)\n",
+    "\n",
+    "    return torch.vstack([x_cont, x_c, y_c]).T"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 488,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prior = BoxUniform(low=torch.tensor([-2.0]*2), high=torch.tensor([2.0]*2))\n",
+    "theta = prior.sample((10000,))\n",
+    "x = toy_simulator(theta)\n",
+    "\n",
+    "# define a unique color for every combination of x1 and x2\n",
+    "unique_classes = torch.unique(x[:,2:], dim=0)\n",
+    "colors = torch.linspace(0, 1, len(unique_classes))\n",
+    "color = torch.zeros(x.shape[0])\n",
+    "for i, c in enumerate(unique_classes):\n",
+    "    color[(x[:,2:] == c).all(dim=1)] = colors[i]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 489,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(x[:,0], x[:,1], c=color)\n",
+    "plt.xlim(-2, 2)\n",
+    "plt.ylim(-2, 2)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 500,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "NFlowsFlow(\n",
+       "  (net): Flow(\n",
+       "    (_transform): CompositeTransform(\n",
+       "      (_transforms): ModuleList(\n",
+       "        (0): PointwiseAffineTransform()\n",
+       "        (1): IdentityTransform()\n",
+       "      )\n",
+       "    )\n",
+       "    (_distribution): MultivariateGaussianMDN(\n",
+       "      (_hidden_net): Sequential(\n",
+       "        (0): Linear(in_features=2, out_features=50, bias=True)\n",
+       "        (1): ReLU()\n",
+       "        (2): Dropout(p=0.0, inplace=False)\n",
+       "        (3): Linear(in_features=50, out_features=50, bias=True)\n",
+       "        (4): ReLU()\n",
+       "        (5): Linear(in_features=50, out_features=50, bias=True)\n",
+       "        (6): ReLU()\n",
+       "      )\n",
+       "      (_logits_layer): Linear(in_features=50, out_features=10, bias=True)\n",
+       "      (_means_layer): Linear(in_features=50, out_features=20, bias=True)\n",
+       "      (_unconstrained_diagonal_layer): Linear(in_features=50, out_features=20, bias=True)\n",
+       "      (_upper_layer): Linear(in_features=50, out_features=10, bias=True)\n",
+       "    )\n",
+       "    (_embedding_net): Sequential(\n",
+       "      (0): Standardize()\n",
+       "      (1): Identity()\n",
+       "    )\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 500,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "CategoricalMassEstimator(CategoricalMADE([2,3], 50, 2), (2,),(2,))\n",
+    "# build_mdn(x[:,:2], theta)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mnle_posterior = trainer.build_posterior(prior=prior)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "sbi",
+   "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.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 7c89b672e..0a56e8184 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -29,15 +29,16 @@ def __init__(
         use_batch_norm=False,
         epsilon=1e-2,
         custom_initialization=True,
+        #TODO: embedding_net: Optional[nn.Module] = None,
     ):
 
         if use_residual_blocks and random_mask:
             raise ValueError("Residual blocks can't be used with random masks.")
 
         self.num_variables = len(categories)
-        self.max_categories = max(categories)
+        self.num_categories = int(max(categories))
         self.categories = categories
-        self.mask = torch.zeros(self.num_variables, self.max_categories)
+        self.mask = torch.zeros(self.num_variables, self.num_categories)
         for i, c in enumerate(categories):
             self.mask[i, :c] = 1
 
@@ -46,7 +47,7 @@ def __init__(
             hidden_features,
             context_features=context_features,
             num_blocks=num_blocks,
-            output_multiplier=self.max_categories,
+            output_multiplier=self.num_categories,
             use_residual_blocks=use_residual_blocks,
             random_mask=random_mask,
             activation=activation,
@@ -68,10 +69,10 @@ def compute_probs(self, outputs):
         ps = ps / ps.sum(dim=-1, keepdim=True)
         return ps
         
-    # outputs (batch_size, num_variables, max_categories)
+    # outputs (batch_size, num_variables, num_categories)
     def log_prob(self, inputs, context=None):
         outputs = self.forward(inputs, context=context)
-        outputs = outputs.reshape(*inputs.shape, self.max_categories)
+        outputs = outputs.reshape(*inputs.shape, self.num_categories)
         ps = self.compute_probs(outputs)
         
         # categorical log prob
@@ -91,7 +92,7 @@ def sample(self, num_samples, context=None):
 
             for variable in range(self.num_variables):
                 outputs = self.forward(samples, context)
-                outputs = outputs.reshape(*samples.shape, self.max_categories)
+                outputs = outputs.reshape(*samples.shape, self.num_categories)
                 ps = self.compute_probs(outputs)
                 samples[:, variable] = Categorical(probs=ps[:,variable]).sample()
 
diff --git a/sbi/neural_nets/net_builders/categorial.py b/sbi/neural_nets/net_builders/categorial.py
index 2c2add091..b59e58538 100644
--- a/sbi/neural_nets/net_builders/categorial.py
+++ b/sbi/neural_nets/net_builders/categorial.py
@@ -3,9 +3,9 @@
 
 from typing import Optional
 
-from torch import Tensor, nn, unique
+from torch import Tensor, nn, unique, tensor
 
-from sbi.neural_nets.estimators import CategoricalMassEstimator, CategoricalNet
+from sbi.neural_nets.estimators import CategoricalMassEstimator, CategoricalNet, CategoricalMADE
 from sbi.utils.nn_utils import get_numel
 from sbi.utils.sbiutils import (
     standardizing_net,
@@ -61,3 +61,53 @@ def build_categoricalmassestimator(
     return CategoricalMassEstimator(
         categorical_net, input_shape=batch_x[0].shape, condition_shape=batch_y[0].shape
     )
+
+
+def build_autoregressive_categoricalmassestimator(
+    batch_x: Tensor,
+    batch_y: Tensor,
+    z_score_x: Optional[str] = "none",
+    z_score_y: Optional[str] = "independent",
+    num_hidden: int = 20,
+    num_layers: int = 2,
+    embedding_net: nn.Module = nn.Identity(),
+):
+    """Returns a density estimator for a categorical random variable.
+
+    Args:
+        batch_x: A batch of input data.
+        batch_y: A batch of condition data.
+        z_score_x: Whether to z-score the input data.
+        z_score_y: Whether to z-score the condition data.
+        num_hidden: Number of hidden units per layer.
+        num_layers: Number of hidden layers.
+        embedding_net: Embedding net for y.
+    """
+
+    if z_score_x != "none":
+        raise ValueError("Categorical input should not be z-scored.")
+
+    check_data_device(batch_x, batch_y)
+
+    z_score_y_bool, structured_y = z_score_parser(z_score_y)
+    y_numel = get_numel(batch_y, embedding_net=embedding_net)
+
+    if z_score_y_bool:
+        embedding_net = nn.Sequential(
+            standardizing_net(batch_y, structured_y), embedding_net
+        )
+
+
+    categories = tensor([unique(variable).numel() for variable in batch_x.T])
+
+    categorical_net = CategoricalMADE(
+        categories=categories,
+        context_features=y_numel,
+        hidden_features=num_hidden,
+        num_blocks=num_layers,
+        #TODO: embedding_net=embedding_net,
+    )
+
+    return CategoricalMassEstimator(
+        categorical_net, input_shape=batch_x[0].shape, condition_shape=batch_y[0].shape
+    )
\ No newline at end of file

From 73e85b535ec02ac8c0a38cd870d3a3cf3d6368ab Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Wed, 11 Sep 2024 17:02:16 +0200
Subject: [PATCH 04/17] wip: sampling and log_prob works for categorical_made.
 working on getting mixed_density estimator log_probs and sample to work as
 well

---
 sbi/neural_nets/estimators/categorical_net.py | 30 ++++++++++++-------
 sbi/neural_nets/net_builders/categorial.py    |  7 +++--
 2 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 0a56e8184..dbcac3e4e 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -76,27 +76,37 @@ def log_prob(self, inputs, context=None):
         ps = self.compute_probs(outputs)
         
         # categorical log prob
-        log_prob = torch.log(ps.gather(-1, inputs.unsqueeze(-1).long()).squeeze(-1))
+        log_prob = torch.log(ps.gather(-1, inputs.unsqueeze(-1).long()))
         log_prob = log_prob.sum(dim=-1)
        
         return log_prob
 
-    def sample(self, num_samples, context=None):
-
+    def sample(self, sample_shape, context=None):
+        # Ensure sample_shape is a tuple
+        if isinstance(sample_shape, int):
+            sample_shape = (sample_shape,)
+        sample_shape = torch.Size(sample_shape)
+        
+        # Calculate total number of samples
+        num_samples = torch.prod(torch.tensor(sample_shape)).item()
+        
+        # Prepare context
         if context is not None:
+            if context.ndim == 1:
+                context = context.unsqueeze(0)
             context = torchutils.repeat_rows(context, num_samples)
-
+        else:
+            context = torch.zeros(num_samples, self.context_dim)
+        
         with torch.no_grad():
-            
-            samples = torch.zeros(context.shape[0], self.num_variables)
-
+            samples = torch.zeros(num_samples, self.num_variables)
             for variable in range(self.num_variables):
                 outputs = self.forward(samples, context)
-                outputs = outputs.reshape(*samples.shape, self.num_categories)
+                outputs = outputs.reshape(num_samples, self.num_variables, self.num_categories)
                 ps = self.compute_probs(outputs)
                 samples[:, variable] = Categorical(probs=ps[:,variable]).sample()
-
-        return samples.reshape(-1, num_samples, self.num_variables)
+        
+        return samples.reshape(*sample_shape, self.num_variables)
 
     def _initialize(self):
         pass
diff --git a/sbi/neural_nets/net_builders/categorial.py b/sbi/neural_nets/net_builders/categorial.py
index b59e58538..c8662dd64 100644
--- a/sbi/neural_nets/net_builders/categorial.py
+++ b/sbi/neural_nets/net_builders/categorial.py
@@ -70,6 +70,7 @@ def build_autoregressive_categoricalmassestimator(
     z_score_y: Optional[str] = "independent",
     num_hidden: int = 20,
     num_layers: int = 2,
+    num_variables: int = 1,
     embedding_net: nn.Module = nn.Identity(),
 ):
     """Returns a density estimator for a categorical random variable.
@@ -97,15 +98,15 @@ def build_autoregressive_categoricalmassestimator(
             standardizing_net(batch_y, structured_y), embedding_net
         )
 
-
     categories = tensor([unique(variable).numel() for variable in batch_x.T])
+    categories = categories[-num_variables:]
 
     categorical_net = CategoricalMADE(
         categories=categories,
-        context_features=y_numel,
         hidden_features=num_hidden,
+        context_features=y_numel,
         num_blocks=num_layers,
-        #TODO: embedding_net=embedding_net,
+        # TODO: embedding_net=embedding_net,
     )
 
     return CategoricalMassEstimator(

From 8bbb764e2ef042fc38cfcc0ebb8193574d70edb2 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 12 Sep 2024 00:16:28 +0200
Subject: [PATCH 05/17] wip: build_mnle works and trains without log_transform.
 Add made as arg to categorical_model

---
 sbi/neural_nets/estimators/categorical_net.py |  6 ++-
 sbi/neural_nets/net_builders/mnle.py          | 38 ++++++++++++++-----
 2 files changed, 32 insertions(+), 12 deletions(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index dbcac3e4e..2ca6e9ab4 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -29,7 +29,7 @@ def __init__(
         use_batch_norm=False,
         epsilon=1e-2,
         custom_initialization=True,
-        #TODO: embedding_net: Optional[nn.Module] = None,
+        embedding_net: Optional[nn.Module] = nn.Identity(),
     ):
 
         if use_residual_blocks and random_mask:
@@ -55,6 +55,7 @@ def __init__(
             use_batch_norm=use_batch_norm,
         )
 
+        self.embedding_net = embedding_net
         self.hidden_features = hidden_features
         self.epsilon = epsilon
 
@@ -62,7 +63,8 @@ def __init__(
             self._initialize()
 
     def forward(self, inputs, context=None):
-        return super().forward(inputs, context=context)
+        embedded_inputs = self.embedding_net.forward(inputs)
+        return super().forward(embedded_inputs, context=context)
     
     def compute_probs(self, outputs):
         ps = F.softmax(outputs, dim=-1)*self.mask
diff --git a/sbi/neural_nets/net_builders/mnle.py b/sbi/neural_nets/net_builders/mnle.py
index fd7ef6d3a..034366e14 100644
--- a/sbi/neural_nets/net_builders/mnle.py
+++ b/sbi/neural_nets/net_builders/mnle.py
@@ -9,7 +9,7 @@
 
 from sbi.neural_nets.estimators import MixedDensityEstimator
 from sbi.neural_nets.estimators.mixed_density_estimator import _separate_input
-from sbi.neural_nets.net_builders.categorial import build_categoricalmassestimator
+from sbi.neural_nets.net_builders.categorial import build_categoricalmassestimator, build_autoregressive_categoricalmassestimator
 from sbi.neural_nets.net_builders.flow import (
     build_made,
     build_maf,
@@ -56,6 +56,7 @@ def build_mnle(
     z_score_x: Optional[str] = "independent",
     z_score_y: Optional[str] = "independent",
     flow_model: str = "nsf",
+    categorical_model: str = "made",
     embedding_net: nn.Module = nn.Identity(),
     combined_embedding_net: Optional[nn.Module] = None,
     num_transforms: int = 2,
@@ -102,6 +103,8 @@ def build_mnle(
             as z_score_x.
         flow_model: type of flow model to use for the continuous part of the
             data.
+        categorical_model: type of categorical net to use for the discrete part of
+            the data. Can be "made" or "categorical".
         embedding_net: Optional embedding network for y, required if y is > 1D.
         combined_embedding_net: Optional embedding for combining the discrete
             part of the input and the embedded condition into a joined
@@ -144,15 +147,30 @@ def build_mnle(
     combined_condition = torch.cat([disc_x, embedded_batch_y], dim=-1)
 
     # Set up a categorical RV neural net for modelling the discrete data.
-    discrete_net = build_categoricalmassestimator(
-        disc_x,
-        batch_y,
-        z_score_x="none",  # discrete data should not be z-scored.
-        z_score_y="none",  # y-embedding net already z-scores.
-        num_hidden=hidden_features,
-        num_layers=hidden_layers,
-        embedding_net=embedding_net,
-    )
+    if categorical_model == "made":
+        discrete_net = build_autoregressive_categoricalmassestimator(
+            disc_x,
+            batch_y,
+            z_score_x="none",  # discrete data should not be z-scored.
+            z_score_y="none",  # y-embedding net already z-scores.
+            num_hidden=hidden_features,
+            num_layers=hidden_layers,
+            embedding_net=embedding_net,
+        )
+    elif categorical_model == "categorical":
+        discrete_net = build_categoricalmassestimator(
+            disc_x,
+            batch_y,
+            z_score_x="none",  # discrete data should not be z-scored.
+            z_score_y="none",  # y-embedding net already z-scores.
+            num_hidden=hidden_features,
+            num_layers=hidden_layers,
+            embedding_net=embedding_net,
+        )
+    else:
+        raise ValueError(
+            f"Unknown categorical net {categorical_model}. Must be 'made' or 'categorical'."
+        )
 
     if combined_embedding_net is None:
         # set up linear embedding net for combining discrete and continuous

From 913776e3097621c44206c9fb6ce8923119e9db7c Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 12 Sep 2024 17:54:03 +0200
Subject: [PATCH 06/17] fix: categorical_made now trains in 1D MNLE

---
 sbi/neural_nets/estimators/categorical_net.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 2ca6e9ab4..2e8ce49d8 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -69,7 +69,7 @@ def forward(self, inputs, context=None):
     def compute_probs(self, outputs):
         ps = F.softmax(outputs, dim=-1)*self.mask
         ps = ps / ps.sum(dim=-1, keepdim=True)
-        return ps
+        return ps.squeeze(-2)
         
     # outputs (batch_size, num_variables, num_categories)
     def log_prob(self, inputs, context=None):
@@ -78,7 +78,7 @@ def log_prob(self, inputs, context=None):
         ps = self.compute_probs(outputs)
         
         # categorical log prob
-        log_prob = torch.log(ps.gather(-1, inputs.unsqueeze(-1).long()))
+        log_prob = torch.log(ps.gather(-1, inputs.long()))
         log_prob = log_prob.sum(dim=-1)
        
         return log_prob

From c9e2b885bb897702a2fedfd8dd446fc50e3391e6 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Fri, 13 Sep 2024 12:09:16 +0200
Subject: [PATCH 07/17] fix: change net kwarg

---
 sbi/neural_nets/net_builders/mnle.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/sbi/neural_nets/net_builders/mnle.py b/sbi/neural_nets/net_builders/mnle.py
index 034366e14..03c151daf 100644
--- a/sbi/neural_nets/net_builders/mnle.py
+++ b/sbi/neural_nets/net_builders/mnle.py
@@ -56,7 +56,7 @@ def build_mnle(
     z_score_x: Optional[str] = "independent",
     z_score_y: Optional[str] = "independent",
     flow_model: str = "nsf",
-    categorical_model: str = "made",
+    categorical_model: str = "mlp",
     embedding_net: nn.Module = nn.Identity(),
     combined_embedding_net: Optional[nn.Module] = None,
     num_transforms: int = 2,
@@ -104,7 +104,7 @@ def build_mnle(
         flow_model: type of flow model to use for the continuous part of the
             data.
         categorical_model: type of categorical net to use for the discrete part of
-            the data. Can be "made" or "categorical".
+            the data. Can be "made" or "mlp".
         embedding_net: Optional embedding network for y, required if y is > 1D.
         combined_embedding_net: Optional embedding for combining the discrete
             part of the input and the embedded condition into a joined
@@ -157,7 +157,7 @@ def build_mnle(
             num_layers=hidden_layers,
             embedding_net=embedding_net,
         )
-    elif categorical_model == "categorical":
+    elif categorical_model == "mlp":
         discrete_net = build_categoricalmassestimator(
             disc_x,
             batch_y,
@@ -169,7 +169,7 @@ def build_mnle(
         )
     else:
         raise ValueError(
-            f"Unknown categorical net {categorical_model}. Must be 'made' or 'categorical'."
+            f"Unknown categorical net {categorical_model}. Must be 'made' or 'mlp'."
         )
 
     if combined_embedding_net is None:

From db03a5b7e549e2ead91d2b12a6da9f2d771e4013 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Fri, 13 Sep 2024 17:16:38 +0200
Subject: [PATCH 08/17] fix: verify ND training is working with CatMADE.

---
 sbi/neural_nets/estimators/categorical_net.py | 44 ++++++++++---------
 .../estimators/mixed_density_estimator.py     | 14 ++++--
 sbi/neural_nets/net_builders/categorial.py    | 31 ++++++++-----
 sbi/neural_nets/net_builders/mnle.py          | 23 ++++++----
 4 files changed, 68 insertions(+), 44 deletions(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 2e8ce49d8..77a690147 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -4,21 +4,20 @@
 from typing import Optional
 
 import torch
-from torch import Tensor, nn, distributions
+from nflows.nn.nde.made import MADE
+from nflows.utils import torchutils
+from torch import Tensor, nn
 from torch.distributions import Categorical
 from torch.nn import Sigmoid, Softmax
+from torch.nn import functional as F
 
 from sbi.neural_nets.estimators.base import ConditionalDensityEstimator
-from nflows.nn.nde.made import MADE
-from torch.nn import functional as F
-from nflows.utils import torchutils
-import numpy as np
 
 
 class CategoricalMADE(MADE):
     def __init__(
         self,
-        categories, # List[int] or Tensor[int]
+        categories,  # Tensor[int]
         hidden_features,
         context_features=None,
         num_blocks=2,
@@ -31,7 +30,6 @@ def __init__(
         custom_initialization=True,
         embedding_net: Optional[nn.Module] = nn.Identity(),
     ):
-
         if use_residual_blocks and random_mask:
             raise ValueError("Residual blocks can't be used with random masks.")
 
@@ -65,22 +63,22 @@ def __init__(
     def forward(self, inputs, context=None):
         embedded_inputs = self.embedding_net.forward(inputs)
         return super().forward(embedded_inputs, context=context)
-    
+
     def compute_probs(self, outputs):
-        ps = F.softmax(outputs, dim=-1)*self.mask
+        ps = F.softmax(outputs, dim=-1) * self.mask
         ps = ps / ps.sum(dim=-1, keepdim=True)
-        return ps.squeeze(-2)
-        
+        return ps
+
     # outputs (batch_size, num_variables, num_categories)
     def log_prob(self, inputs, context=None):
         outputs = self.forward(inputs, context=context)
         outputs = outputs.reshape(*inputs.shape, self.num_categories)
         ps = self.compute_probs(outputs)
-        
+
         # categorical log prob
-        log_prob = torch.log(ps.gather(-1, inputs.long()))
-        log_prob = log_prob.sum(dim=-1)
-       
+        log_prob = torch.log(ps.gather(-1, inputs.unsqueeze(-1).long()))
+        log_prob = log_prob.squeeze(-1).sum(dim=-1)
+
         return log_prob
 
     def sample(self, sample_shape, context=None):
@@ -88,10 +86,10 @@ def sample(self, sample_shape, context=None):
         if isinstance(sample_shape, int):
             sample_shape = (sample_shape,)
         sample_shape = torch.Size(sample_shape)
-        
+
         # Calculate total number of samples
         num_samples = torch.prod(torch.tensor(sample_shape)).item()
-        
+
         # Prepare context
         if context is not None:
             if context.ndim == 1:
@@ -99,20 +97,23 @@ def sample(self, sample_shape, context=None):
             context = torchutils.repeat_rows(context, num_samples)
         else:
             context = torch.zeros(num_samples, self.context_dim)
-        
+
         with torch.no_grad():
             samples = torch.zeros(num_samples, self.num_variables)
             for variable in range(self.num_variables):
                 outputs = self.forward(samples, context)
-                outputs = outputs.reshape(num_samples, self.num_variables, self.num_categories)
+                outputs = outputs.reshape(
+                    num_samples, self.num_variables, self.num_categories
+                )
                 ps = self.compute_probs(outputs)
-                samples[:, variable] = Categorical(probs=ps[:,variable]).sample()
-        
+                samples[:, variable] = Categorical(probs=ps[:, variable]).sample()
+
         return samples.reshape(*sample_shape, self.num_variables)
 
     def _initialize(self):
         pass
 
+
 class CategoricalNet(nn.Module):
     """Conditional density (mass) estimation for a categorical random variable.
 
@@ -145,6 +146,7 @@ def __init__(
         self.activation = Sigmoid()
         self.softmax = Softmax(dim=1)
         self.num_categories = num_categories
+        self.num_variables = 1
 
         # Maybe add embedding net in front.
         if embedding_net is not None:
diff --git a/sbi/neural_nets/estimators/mixed_density_estimator.py b/sbi/neural_nets/estimators/mixed_density_estimator.py
index dedba1b52..27cc2d2b6 100644
--- a/sbi/neural_nets/estimators/mixed_density_estimator.py
+++ b/sbi/neural_nets/estimators/mixed_density_estimator.py
@@ -80,8 +80,10 @@ def sample(
                 sample_shape=sample_shape,
                 condition=condition,
             )
-            # Trailing `1` because `Categorical` has event_shape `()`.
-            discrete_samples = discrete_samples.reshape(num_samples * batch_dim, 1)
+            num_variables = self.discrete_net.net.num_variables
+            discrete_samples = discrete_samples.reshape(
+                num_samples * batch_dim, num_variables
+            )
 
             # repeat the batch of embedded condition to match number of choices.
             condition_event_dim = embedded_condition.dim() - 1
@@ -145,7 +147,8 @@ def log_prob(self, input: Tensor, condition: Tensor) -> Tensor:
             f"{input_batch_dim} do not match."
         )
 
-        cont_input, disc_input = _separate_input(input)
+        num_disc = self.discrete_net.net.num_variables
+        cont_input, disc_input = _separate_input(input, num_discrete_columns=num_disc)
         # Embed continuous condition
         embedded_condition = self.condition_embedding(condition)
         # expand and repeat to match batch of inputs.
@@ -204,3 +207,8 @@ def _separate_input(
     Assumes the discrete data to live in the last columns of input.
     """
     return input[..., :-num_discrete_columns], input[..., -num_discrete_columns:]
+
+
+def _is_discrete(input: Tensor) -> Tensor:
+    """Infer discrete columns in input data."""
+    return torch.tensor([torch.allclose(col, col.round()) for col in input.T])
diff --git a/sbi/neural_nets/net_builders/categorial.py b/sbi/neural_nets/net_builders/categorial.py
index c8662dd64..adf59cecf 100644
--- a/sbi/neural_nets/net_builders/categorial.py
+++ b/sbi/neural_nets/net_builders/categorial.py
@@ -1,16 +1,19 @@
 # This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed
 # under the Apache License Version 2.0, see <https://www.apache.org/licenses/>
 
+import warnings
 from typing import Optional
 
-from torch import Tensor, nn, unique, tensor
+from torch import Tensor, nn, tensor, unique
 
-from sbi.neural_nets.estimators import CategoricalMassEstimator, CategoricalNet, CategoricalMADE
-from sbi.utils.nn_utils import get_numel
-from sbi.utils.sbiutils import (
-    standardizing_net,
-    z_score_parser,
+from sbi.neural_nets.estimators import (
+    CategoricalMADE,
+    CategoricalMassEstimator,
+    CategoricalNet,
 )
+from sbi.neural_nets.estimators.mixed_density_estimator import _is_discrete
+from sbi.utils.nn_utils import get_numel
+from sbi.utils.sbiutils import standardizing_net, z_score_parser
 from sbi.utils.user_input_checks import check_data_device
 
 
@@ -70,7 +73,7 @@ def build_autoregressive_categoricalmassestimator(
     z_score_y: Optional[str] = "independent",
     num_hidden: int = 20,
     num_layers: int = 2,
-    num_variables: int = 1,
+    categories: Optional[Tensor] = None,
     embedding_net: nn.Module = nn.Identity(),
 ):
     """Returns a density estimator for a categorical random variable.
@@ -87,6 +90,11 @@ def build_autoregressive_categoricalmassestimator(
 
     if z_score_x != "none":
         raise ValueError("Categorical input should not be z-scored.")
+    if categories is None:
+        warnings.warn(
+            "Inferring categories from batch_x. Ensure all categories are present.",
+            stacklevel=2,
+        )
 
     check_data_device(batch_x, batch_y)
 
@@ -98,17 +106,18 @@ def build_autoregressive_categoricalmassestimator(
             standardizing_net(batch_y, structured_y), embedding_net
         )
 
-    categories = tensor([unique(variable).numel() for variable in batch_x.T])
-    categories = categories[-num_variables:]
+    batch_x_discrete = batch_x[:, _is_discrete(batch_x)]
+    inferred_categories = tensor([unique(col).numel() for col in batch_x_discrete.T])
+    categories = categories if categories is not None else inferred_categories
 
     categorical_net = CategoricalMADE(
         categories=categories,
         hidden_features=num_hidden,
         context_features=y_numel,
         num_blocks=num_layers,
-        # TODO: embedding_net=embedding_net,
+        embedding_net=embedding_net,
     )
 
     return CategoricalMassEstimator(
         categorical_net, input_shape=batch_x[0].shape, condition_shape=batch_y[0].shape
-    )
\ No newline at end of file
+    )
diff --git a/sbi/neural_nets/net_builders/mnle.py b/sbi/neural_nets/net_builders/mnle.py
index 03c151daf..00801e4c6 100644
--- a/sbi/neural_nets/net_builders/mnle.py
+++ b/sbi/neural_nets/net_builders/mnle.py
@@ -8,8 +8,14 @@
 from torch import Tensor, nn
 
 from sbi.neural_nets.estimators import MixedDensityEstimator
-from sbi.neural_nets.estimators.mixed_density_estimator import _separate_input
-from sbi.neural_nets.net_builders.categorial import build_categoricalmassestimator, build_autoregressive_categoricalmassestimator
+from sbi.neural_nets.estimators.mixed_density_estimator import (
+    _is_discrete,
+    _separate_input,
+)
+from sbi.neural_nets.net_builders.categorial import (
+    build_autoregressive_categoricalmassestimator,
+    build_categoricalmassestimator,
+)
 from sbi.neural_nets.net_builders.flow import (
     build_made,
     build_maf,
@@ -26,10 +32,7 @@
     build_zuko_unaf,
 )
 from sbi.neural_nets.net_builders.mdn import build_mdn
-from sbi.utils.sbiutils import (
-    standardizing_net,
-    z_score_parser,
-)
+from sbi.utils.sbiutils import standardizing_net, z_score_parser
 from sbi.utils.user_input_checks import check_data_device
 
 model_builders = {
@@ -128,13 +131,14 @@ def build_mnle(
 
     warnings.warn(
         "The mixed neural likelihood estimator assumes that x contains "
-        "continuous data in the first n-1 columns (e.g., reaction times) and "
-        "categorical data in the last column (e.g., corresponding choices). If "
+        "continuous data in the first n-k columns (e.g., reaction times) and "
+        "categorical data in the last k columns (e.g., corresponding choices). If "
         "this is not the case for the passed `x` do not use this function.",
         stacklevel=2,
     )
     # Separate continuous and discrete data.
-    cont_x, disc_x = _separate_input(batch_x)
+    num_disc = int(torch.sum(_is_discrete(batch_x)))
+    cont_x, disc_x = _separate_input(batch_x, num_discrete_columns=num_disc)
 
     # Set up y-embedding net with z-scoring.
     z_score_y_bool, structured_y = z_score_parser(z_score_y)
@@ -158,6 +162,7 @@ def build_mnle(
             embedding_net=embedding_net,
         )
     elif categorical_model == "mlp":
+        assert num_disc == 1, "MLP only supports 1D input."
         discrete_net = build_categoricalmassestimator(
             disc_x,
             batch_y,

From b3cefa91fc85ad783da6aadefa8235d4858b4e03 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Mon, 16 Sep 2024 07:47:55 +0200
Subject: [PATCH 09/17] fix: fix embedding net mistake

---
 sbi/neural_nets/estimators/categorical_net.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 77a690147..8e79e7072 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -61,8 +61,8 @@ def __init__(
             self._initialize()
 
     def forward(self, inputs, context=None):
-        embedded_inputs = self.embedding_net.forward(inputs)
-        return super().forward(embedded_inputs, context=context)
+        embedded_context = self.embedding_net.forward(context)
+        return super().forward(inputs, context=embedded_context)
 
     def compute_probs(self, outputs):
         ps = F.softmax(outputs, dim=-1) * self.mask

From ba5ae95c9d9892060045dfc1958656a9b6995992 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 14 Nov 2024 13:12:09 +0100
Subject: [PATCH 10/17] fix: address comments

---
 sbi/neural_nets/estimators/__init__.py        |  6 +-
 sbi/neural_nets/estimators/categorical_net.py | 74 ++++++++++++++-----
 .../estimators/mixed_density_estimator.py     |  4 +-
 sbi/neural_nets/net_builders/categorial.py    | 13 ++--
 sbi/neural_nets/net_builders/mnle.py          |  9 ++-
 5 files changed, 75 insertions(+), 31 deletions(-)

diff --git a/sbi/neural_nets/estimators/__init__.py b/sbi/neural_nets/estimators/__init__.py
index a8792bd93..a885655ba 100644
--- a/sbi/neural_nets/estimators/__init__.py
+++ b/sbi/neural_nets/estimators/__init__.py
@@ -1,13 +1,11 @@
 from sbi.neural_nets.estimators.base import ConditionalDensityEstimator
 from sbi.neural_nets.estimators.categorical_net import (
+    CategoricalMADE,
     CategoricalMassEstimator,
     CategoricalNet,
-    CategoricalMADE,
 )
 from sbi.neural_nets.estimators.flowmatching_estimator import FlowMatchingEstimator
-from sbi.neural_nets.estimators.mixed_density_estimator import (
-    MixedDensityEstimator,
-)
+from sbi.neural_nets.estimators.mixed_density_estimator import MixedDensityEstimator
 from sbi.neural_nets.estimators.nflows_flow import NFlowsFlow
 from sbi.neural_nets.estimators.score_estimator import ConditionalScoreEstimator
 from sbi.neural_nets.estimators.zuko_flow import ZukoFlow
diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 8e79e7072..b10cff021 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -1,7 +1,7 @@
 # This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed
 # under the Apache License Version 2.0, see <https://www.apache.org/licenses/>
 
-from typing import Optional
+from typing import Callable, Optional
 
 import torch
 from nflows.nn.nde.made import MADE
@@ -15,29 +15,46 @@
 
 
 class CategoricalMADE(MADE):
+    """Conditional density (mass) estimation for a n-dim categorical random variable.
+
+    Takes as input parameters theta and learns the parameters p of a Categorical.
+
+    Defines log prob and sample functions.
+    """
+
     def __init__(
         self,
-        categories,  # Tensor[int]
-        hidden_features,
-        context_features=None,
-        num_blocks=2,
-        use_residual_blocks=True,
-        random_mask=False,
-        activation=F.relu,
-        dropout_probability=0.0,
-        use_batch_norm=False,
-        epsilon=1e-2,
-        custom_initialization=True,
+        num_categories: Tensor,  # Tensor[int]
+        hidden_features: int,
+        context_features: Optional[int] = None,
+        num_blocks: int = 2,
+        use_residual_blocks: bool = True,
+        random_mask: bool = False,
+        activation: Callable = F.relu,
+        dropout_probability: float = 0.0,
+        use_batch_norm: bool = False,
+        epsilon: float = 1e-2,
+        custom_initialization: bool = True,
         embedding_net: Optional[nn.Module] = nn.Identity(),
     ):
+        """Initialize the neural net.
+
+        Args:
+            num_categories: number of categories for each variable. len(categories)
+                defines the number of input units, i.e., dimensionality of the features.
+                max(categories) defines the number of output units, i.e., the largest
+                number of categories.
+            num_hidden: number of hidden units per layer.
+            num_layers: number of hidden layers.
+            embedding_net: emebedding net for input.
+        """
         if use_residual_blocks and random_mask:
             raise ValueError("Residual blocks can't be used with random masks.")
 
-        self.num_variables = len(categories)
-        self.num_categories = int(max(categories))
-        self.categories = categories
+        self.num_variables = len(num_categories)
+        self.num_categories = int(torch.max(num_categories))
         self.mask = torch.zeros(self.num_variables, self.num_categories)
-        for i, c in enumerate(categories):
+        for i, c in enumerate(num_categories):
             self.mask[i, :c] = 1
 
         super().__init__(
@@ -60,7 +77,18 @@ def __init__(
         if custom_initialization:
             self._initialize()
 
-    def forward(self, inputs, context=None):
+    def forward(self, inputs: Tensor, context: Optional[Tensor] = None) -> Tensor:
+        r"""Forward pass of the categorical density estimator network to compute the
+        conditional density at a given time.
+
+        Args:
+            input: Original data, x0. (batch_size, *input_shape)
+            condition: Conditioning variable. (batch_size, *condition_shape)
+
+        Returns:
+            Predicted categorical probabilities. (batch_size, *input_shape,
+                num_categories)
+        """
         embedded_context = self.embedding_net.forward(context)
         return super().forward(inputs, context=embedded_context)
 
@@ -69,8 +97,16 @@ def compute_probs(self, outputs):
         ps = ps / ps.sum(dim=-1, keepdim=True)
         return ps
 
-    # outputs (batch_size, num_variables, num_categories)
-    def log_prob(self, inputs, context=None):
+    def log_prob(self, inputs: Tensor, context: Optional[Tensor] = None) -> Tensor:
+        r"""Return log-probability of samples.
+
+        Args:
+            input: Input datapoints of shape `(batch_size, *input_shape)`.
+            context: Context of shape `(batch_size, *condition_shape)`.
+
+        Returns:
+            Log-probabilities of shape `(batch_size, num_variables, num_categories)`.
+        """
         outputs = self.forward(inputs, context=context)
         outputs = outputs.reshape(*inputs.shape, self.num_categories)
         ps = self.compute_probs(outputs)
diff --git a/sbi/neural_nets/estimators/mixed_density_estimator.py b/sbi/neural_nets/estimators/mixed_density_estimator.py
index 27cc2d2b6..e46d7baeb 100644
--- a/sbi/neural_nets/estimators/mixed_density_estimator.py
+++ b/sbi/neural_nets/estimators/mixed_density_estimator.py
@@ -147,8 +147,8 @@ def log_prob(self, input: Tensor, condition: Tensor) -> Tensor:
             f"{input_batch_dim} do not match."
         )
 
-        num_disc = self.discrete_net.net.num_variables
-        cont_input, disc_input = _separate_input(input, num_discrete_columns=num_disc)
+        num_discrete_variables = self.discrete_net.net.num_variables
+        cont_input, disc_input = _separate_input(input, num_discrete_variables)
         # Embed continuous condition
         embedded_condition = self.condition_embedding(condition)
         # expand and repeat to match batch of inputs.
diff --git a/sbi/neural_nets/net_builders/categorial.py b/sbi/neural_nets/net_builders/categorial.py
index adf59cecf..0c98892b9 100644
--- a/sbi/neural_nets/net_builders/categorial.py
+++ b/sbi/neural_nets/net_builders/categorial.py
@@ -73,7 +73,7 @@ def build_autoregressive_categoricalmassestimator(
     z_score_y: Optional[str] = "independent",
     num_hidden: int = 20,
     num_layers: int = 2,
-    categories: Optional[Tensor] = None,
+    num_categories: Optional[Tensor] = None,
     embedding_net: nn.Module = nn.Identity(),
 ):
     """Returns a density estimator for a categorical random variable.
@@ -86,13 +86,14 @@ def build_autoregressive_categoricalmassestimator(
         num_hidden: Number of hidden units per layer.
         num_layers: Number of hidden layers.
         embedding_net: Embedding net for y.
+        num_categories: number of categories for each variable.
     """
 
     if z_score_x != "none":
         raise ValueError("Categorical input should not be z-scored.")
-    if categories is None:
+    if num_categories is None:
         warnings.warn(
-            "Inferring categories from batch_x. Ensure all categories are present.",
+            "Inferring num_categories from batch_x. Ensure all categories are present.",
             stacklevel=2,
         )
 
@@ -108,10 +109,12 @@ def build_autoregressive_categoricalmassestimator(
 
     batch_x_discrete = batch_x[:, _is_discrete(batch_x)]
     inferred_categories = tensor([unique(col).numel() for col in batch_x_discrete.T])
-    categories = categories if categories is not None else inferred_categories
+    num_categories = (
+        num_categories if num_categories is not None else inferred_categories
+    )
 
     categorical_net = CategoricalMADE(
-        categories=categories,
+        num_categories=num_categories,
         hidden_features=num_hidden,
         context_features=y_numel,
         num_blocks=num_layers,
diff --git a/sbi/neural_nets/net_builders/mnle.py b/sbi/neural_nets/net_builders/mnle.py
index 00801e4c6..391abce8c 100644
--- a/sbi/neural_nets/net_builders/mnle.py
+++ b/sbi/neural_nets/net_builders/mnle.py
@@ -60,6 +60,7 @@ def build_mnle(
     z_score_y: Optional[str] = "independent",
     flow_model: str = "nsf",
     categorical_model: str = "mlp",
+    num_categorical_columns: Optional[Tensor] = None,
     embedding_net: nn.Module = nn.Identity(),
     combined_embedding_net: Optional[nn.Module] = None,
     num_transforms: int = 2,
@@ -108,6 +109,8 @@ def build_mnle(
             data.
         categorical_model: type of categorical net to use for the discrete part of
             the data. Can be "made" or "mlp".
+        num_categorical_columns: Number of categorical columns of each variable in the
+            input data. If None, the function will infer this from the data.
         embedding_net: Optional embedding network for y, required if y is > 1D.
         combined_embedding_net: Optional embedding for combining the discrete
             part of the input and the embedded condition into a joined
@@ -137,7 +140,10 @@ def build_mnle(
         stacklevel=2,
     )
     # Separate continuous and discrete data.
-    num_disc = int(torch.sum(_is_discrete(batch_x)))
+    if num_categorical_columns is None:
+        num_disc = int(torch.sum(_is_discrete(batch_x)))
+    else:
+        num_disc = len(num_categorical_columns)
     cont_x, disc_x = _separate_input(batch_x, num_discrete_columns=num_disc)
 
     # Set up y-embedding net with z-scoring.
@@ -160,6 +166,7 @@ def build_mnle(
             num_hidden=hidden_features,
             num_layers=hidden_layers,
             embedding_net=embedding_net,
+            num_categories=num_categorical_columns,
         )
     elif categorical_model == "mlp":
         assert num_disc == 1, "MLP only supports 1D input."

From ee7a34e5322c08786e0075dc90b3bc798b675aa4 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 14 Nov 2024 13:13:05 +0100
Subject: [PATCH 11/17] wip: save dev nb

---
 sbi/made_mnle.ipynb | 293 +++++++++++++++++++++++++++++++-------------
 1 file changed, 210 insertions(+), 83 deletions(-)

diff --git a/sbi/made_mnle.ipynb b/sbi/made_mnle.ipynb
index 34c3186c5..c1cfc22db 100644
--- a/sbi/made_mnle.ipynb
+++ b/sbi/made_mnle.ipynb
@@ -12,149 +12,276 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 499,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n"
+     ]
+    }
+   ],
    "source": [
     "import torch\n",
+    "from sbi.neural_nets.estimators import MixedDensityEstimator\n",
     "from sbi.neural_nets.estimators.categorical_net import CategoricalMADE, CategoricalMassEstimator\n",
     "from sbi.utils.torchutils import BoxUniform\n",
     "import matplotlib.pyplot as plt\n",
     "from sbi.inference import MNLE\n",
-    "from sbi.neural_nets.estimators import MixedDensityEstimator\n",
     "from sbi.neural_nets.estimators.nflows_flow import NFlowsFlow\n",
-    "from sbi.neural_nets.net_builders.mdn import build_mdn"
+    "from sbi.neural_nets.net_builders.mdn import build_mdn\n",
+    "from sbi.neural_nets.net_builders.categorial import build_autoregressive_categoricalmassestimator, build_categoricalmassestimator\n",
+    "from sbi.neural_nets.net_builders.mnle import build_mnle\n",
+    "from sbi.analysis import pairplot"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 487,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def toy_simulator(theta):\n",
-    "    x_centers = torch.tensor([[-0.5, 0.5]])\n",
-    "    y_centers = torch.tensor([[-1, 0, 1]])\n",
+    "def toy_simulator(theta: torch.Tensor, centers: list[torch.Tensor]) -> torch.Tensor:\n",
+    "    batch_size, n_dimensions = theta.shape\n",
+    "    assert len(centers) == n_dimensions, \"Number of center sets must match theta dimensions\"\n",
+    "    \n",
+    "    # Calculate discrete classes by assiging to the closest center\n",
+    "    x_disc = torch.stack([\n",
+    "        torch.argmin(torch.abs(centers[i].unsqueeze(1) - theta[:, i].unsqueeze(0)), dim=0)\n",
+    "        for i in range(n_dimensions)\n",
+    "    ], dim=1)\n",
+    "\n",
+    "    closest_centers = torch.stack([centers[i][x_disc[:, i]] for i in range(n_dimensions)], dim=1)\n",
+    "    # Add Gaussian noise to assigned class centers\n",
+    "    std = 0.4\n",
+    "    x_cont = closest_centers + std * torch.randn_like(closest_centers)\n",
+    "       \n",
+    "    return torch.cat([x_cont, x_disc], dim=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_706796/1950430755.py:17: UserWarning: Inferring categories from batch_x. Ensure all categories are present.\n",
+      "  cmade = build_autoregressive_categoricalmassestimator(x[:,-len(centers):], theta)\n",
+      "/tmp/ipykernel_706796/1950430755.py:19: UserWarning: The mixed neural likelihood estimator assumes that x contains continuous data in the first n-k columns (e.g., reaction times) and categorical data in the last k columns (e.g., corresponding choices). If this is not the case for the passed `x` do not use this function.\n",
+      "  cmade_mnle = build_mnle(x, theta, categorical_model=\"made\")\n",
+      "/tmp/ipykernel_706796/1950430755.py:28: UserWarning: The mixed neural likelihood estimator assumes that x contains continuous data in the first n-k columns (e.g., reaction times) and categorical data in the last k columns (e.g., corresponding choices). If this is not the case for the passed `x` do not use this function.\n",
+      "  trainer = MNLE(density_estimator=lambda x,y: build_mnle(y,x,categorical_model=\"made\"))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Neural network successfully converged after 20 epochs."
+     ]
+    }
+   ],
+   "source": [
+    "# THIS WORKS FOR 1D\n",
+    "\n",
+    "torch.random.manual_seed(0)\n",
+    "centers = [\n",
+    "    torch.tensor([-0.5, 0.5]),\n",
+    "    # torch.tensor([-1.0, 0.0, 1.0]),\n",
+    "]\n",
     "\n",
-    "    x_c = x_centers[:,torch.argmin(torch.abs(x_centers.T - theta[:,0]), dim=0)]\n",
-    "    y_c = y_centers[:,torch.argmin(torch.abs(y_centers.T - theta[:,1]), dim=0)]\n",
+    "prior = BoxUniform(low=torch.tensor([-2.0]*len(centers)), high=torch.tensor([2.0]*len(centers)))\n",
+    "theta = prior.sample((10000,))\n",
+    "x = toy_simulator(theta, centers)\n",
+    "theta = torch.hstack([theta, torch.randn_like(theta)])\n",
     "\n",
-    "    std2 = 0.3\n",
-    "    m = torch.cat([x_c, y_c])\n",
-    "    x_cont = m + std2*torch.randn(m.shape)    \n",
+    "theta_o = prior.sample((1,))\n",
+    "x_o = toy_simulator(theta_o, centers)\n",
     "\n",
-    "    # Calculate integer indices after x_cont is computed\n",
-    "    x_c = torch.argmin(torch.abs(x_centers.T - x_c), dim=0)\n",
-    "    y_c = torch.argmin(torch.abs(y_centers.T - y_c), dim=0)\n",
+    "cmade = build_autoregressive_categoricalmassestimator(x[:,-len(centers):], theta)\n",
+    "mlp = build_categoricalmassestimator(x[:,-len(centers):], theta)\n",
+    "cmade_mnle = build_mnle(x, theta, categorical_model=\"made\")\n",
     "\n",
-    "    return torch.vstack([x_cont, x_c, y_c]).T"
+    "# MNLE mixes up x,y (input and condition data!)\n",
+    "# Train MNLE and obtain MCMC-based posterior.\n",
+    "trainer = MNLE(density_estimator=lambda x,y: build_mnle(y,x,categorical_model=\"made\"))\n",
+    "estimator = trainer.append_simulations(theta, x).train(training_batch_size=1000)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 488,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [],
    "source": [
-    "prior = BoxUniform(low=torch.tensor([-2.0]*2), high=torch.tensor([2.0]*2))\n",
-    "theta = prior.sample((10000,))\n",
-    "x = toy_simulator(theta)\n",
+    "from sbi.inference import SNPE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_706796/1968649956.py:16: UserWarning: Inferring categories from batch_x. Ensure all categories are present.\n",
+      "  cmade = build_autoregressive_categoricalmassestimator(x[:,-len(centers):], theta)\n",
+      "/tmp/ipykernel_706796/1968649956.py:17: UserWarning: The mixed neural likelihood estimator assumes that x contains continuous data in the first n-k columns (e.g., reaction times) and categorical data in the last k columns (e.g., corresponding choices). If this is not the case for the passed `x` do not use this function.\n",
+      "  cmade_mnle = build_mnle(x, theta, categorical_model=\"made\")\n",
+      "/home/jnsbck/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/neural_nets/net_builders/mnle.py:155: UserWarning: Inferring categories from batch_x. Ensure all categories are present.\n",
+      "  discrete_net = build_autoregressive_categoricalmassestimator(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Training neural network. Epochs trained: 117"
+     ]
+    }
+   ],
+   "source": [
+    "# THIS WORKS FOR 2D\n",
+    "\n",
+    "torch.random.manual_seed(0)\n",
+    "centers = [\n",
+    "    torch.tensor([-0.5, 0.5]),\n",
+    "    torch.tensor([-1.0, 0.0, 1.0]),\n",
+    "]\n",
+    "\n",
+    "prior = BoxUniform(low=torch.tensor([-2.0]*len(centers)), high=torch.tensor([2.0]*len(centers)))\n",
+    "theta = prior.sample((20000,))\n",
+    "x = toy_simulator(theta, centers)\n",
+    "\n",
+    "theta_o = prior.sample((1,))\n",
+    "x_o = toy_simulator(theta_o, centers)\n",
     "\n",
-    "# define a unique color for every combination of x1 and x2\n",
-    "unique_classes = torch.unique(x[:,2:], dim=0)\n",
-    "colors = torch.linspace(0, 1, len(unique_classes))\n",
-    "color = torch.zeros(x.shape[0])\n",
-    "for i, c in enumerate(unique_classes):\n",
-    "    color[(x[:,2:] == c).all(dim=1)] = colors[i]"
+    "cmade = build_autoregressive_categoricalmassestimator(x[:,-len(centers):], theta)\n",
+    "cmade_mnle = build_mnle(x, theta, categorical_model=\"made\")\n",
+    "\n",
+    "# Train MNLE and obtain MCMC-based posterior.\n",
+    "# trainer = MNLE(density_estimator=lambda x,y: build_mnle(y,x,categorical_model=\"made\"))\n",
+    "trainer = SNPE()\n",
+    "estimator = trainer.append_simulations(theta=theta, x=x).train(training_batch_size=1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "snpe_posterior = trainer.build_posterior(prior=prior)\n",
+    "posterior_samples = snpe_posterior.sample((2000,), x=x_o)\n",
+    "pairplot(posterior_samples, limits=[[-2, 2], [-2, 2]], figsize=(5, 5), points=theta_o)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 489,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bf5cc867b10d4548aa39a703c08bdf0c",
+       "version_major": 2,
+       "version_minor": 0
+      },
       "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+       "Running vectorized MCMC with 20 chains:   0%|          | 0/12000 [00:00<?, ?it/s]"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[41], line 16\u001b[0m\n\u001b[1;32m     13\u001b[0m theta_o \u001b[38;5;241m=\u001b[39m prior\u001b[38;5;241m.\u001b[39msample((\u001b[38;5;241m1\u001b[39m,))\n\u001b[1;32m     14\u001b[0m x_o \u001b[38;5;241m=\u001b[39m toy_simulator(theta_o, centers)\n\u001b[0;32m---> 16\u001b[0m mnle_samples \u001b[38;5;241m=\u001b[39m \u001b[43mmnle_posterior\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msample\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m10000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mx_o\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmcmc_kwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/posteriors/mcmc_posterior.py:318\u001b[0m, in \u001b[0;36mMCMCPosterior.sample\u001b[0;34m(self, sample_shape, x, method, thin, warmup_steps, num_chains, init_strategy, init_strategy_parameters, init_strategy_num_candidates, mcmc_parameters, mcmc_method, sample_with, num_workers, mp_context, show_progress_bars)\u001b[0m\n\u001b[1;32m    316\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mset_grad_enabled(track_gradients):\n\u001b[1;32m    317\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01min\u001b[39;00m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mslice_np\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mslice_np_vectorized\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m--> 318\u001b[0m         transformed_samples \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_slice_np_mcmc\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    319\u001b[0m \u001b[43m            \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    320\u001b[0m \u001b[43m            \u001b[49m\u001b[43mpotential_function\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpotential_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    321\u001b[0m \u001b[43m            \u001b[49m\u001b[43minitial_params\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minitial_params\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    322\u001b[0m \u001b[43m            \u001b[49m\u001b[43mthin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mthin\u001b[49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# type: ignore\u001b[39;49;00m\n\u001b[1;32m    323\u001b[0m \u001b[43m            \u001b[49m\u001b[43mwarmup_steps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwarmup_steps\u001b[49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# type: ignore\u001b[39;49;00m\n\u001b[1;32m    324\u001b[0m \u001b[43m            \u001b[49m\u001b[43mvectorized\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mslice_np_vectorized\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    325\u001b[0m \u001b[43m            \u001b[49m\u001b[43minterchangeable_chains\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    326\u001b[0m \u001b[43m            \u001b[49m\u001b[43mnum_workers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_workers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    327\u001b[0m \u001b[43m            \u001b[49m\u001b[43mshow_progress_bars\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_progress_bars\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    328\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    329\u001b[0m     \u001b[38;5;28;01melif\u001b[39;00m method \u001b[38;5;129;01min\u001b[39;00m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhmc_pyro\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnuts_pyro\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m    330\u001b[0m         transformed_samples \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pyro_mcmc(\n\u001b[1;32m    331\u001b[0m             num_samples\u001b[38;5;241m=\u001b[39mnum_samples,\n\u001b[1;32m    332\u001b[0m             potential_function\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpotential_,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    339\u001b[0m             mp_context\u001b[38;5;241m=\u001b[39mmp_context,\n\u001b[1;32m    340\u001b[0m         )\n",
+      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/posteriors/mcmc_posterior.py:753\u001b[0m, in \u001b[0;36mMCMCPosterior._slice_np_mcmc\u001b[0;34m(self, num_samples, potential_function, initial_params, thin, warmup_steps, vectorized, interchangeable_chains, num_workers, init_width, show_progress_bars)\u001b[0m\n\u001b[1;32m    751\u001b[0m num_samples_ \u001b[38;5;241m=\u001b[39m ceil((num_samples \u001b[38;5;241m*\u001b[39m thin) \u001b[38;5;241m/\u001b[39m num_chains)\n\u001b[1;32m    752\u001b[0m \u001b[38;5;66;03m# Run mcmc including warmup\u001b[39;00m\n\u001b[0;32m--> 753\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[43mposterior_sampler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwarmup_\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mnum_samples_\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    754\u001b[0m samples \u001b[38;5;241m=\u001b[39m samples[:, warmup_steps:, :]  \u001b[38;5;66;03m# discard warmup steps\u001b[39;00m\n\u001b[1;32m    755\u001b[0m samples \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mfrom_numpy(samples)  \u001b[38;5;66;03m# chains x samples x dim\u001b[39;00m\n",
+      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/samplers/mcmc/slice_numpy.py:462\u001b[0m, in \u001b[0;36mSliceSamplerVectorized.run\u001b[0;34m(self, num_samples)\u001b[0m\n\u001b[1;32m    455\u001b[0m         sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnext_param\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mconcatenate([\n\u001b[1;32m    456\u001b[0m             sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m][: sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124morder\u001b[39m\u001b[38;5;124m\"\u001b[39m][sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mi\u001b[39m\u001b[38;5;124m\"\u001b[39m]]],\n\u001b[1;32m    457\u001b[0m             [sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcxi\u001b[39m\u001b[38;5;124m\"\u001b[39m]],\n\u001b[1;32m    458\u001b[0m             sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m][sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124morder\u001b[39m\u001b[38;5;124m\"\u001b[39m][sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mi\u001b[39m\u001b[38;5;124m\"\u001b[39m]] \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m :],\n\u001b[1;32m    459\u001b[0m         ])\n\u001b[1;32m    461\u001b[0m params \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mstack([sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnext_param\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m sc \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mvalues()])\n\u001b[0;32m--> 462\u001b[0m log_probs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_log_prob_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    464\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m c \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_chains):\n\u001b[1;32m    465\u001b[0m     sc \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate[c]\n",
+      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/posteriors/mcmc_posterior.py:738\u001b[0m, in \u001b[0;36mMCMCPosterior._slice_np_mcmc.<locals>.multi_obs_potential\u001b[0;34m(params)\u001b[0m\n\u001b[1;32m    736\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmulti_obs_potential\u001b[39m(params):\n\u001b[1;32m    737\u001b[0m     \u001b[38;5;66;03m# Params are of shape (num_chains * num_obs, event).\u001b[39;00m\n\u001b[0;32m--> 738\u001b[0m     all_potentials \u001b[38;5;241m=\u001b[39m \u001b[43mpotential_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# Shape: (num_chains, num_obs)\u001b[39;00m\n\u001b[1;32m    739\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m all_potentials\u001b[38;5;241m.\u001b[39mflatten()\n",
+      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/utils/potentialutils.py:44\u001b[0m, in \u001b[0;36mtransformed_potential\u001b[0;34m(theta, potential_fn, theta_transform, device, track_gradients)\u001b[0m\n\u001b[1;32m     41\u001b[0m theta \u001b[38;5;241m=\u001b[39m theta_transform\u001b[38;5;241m.\u001b[39minv(transformed_theta)  \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n\u001b[1;32m     42\u001b[0m log_abs_det \u001b[38;5;241m=\u001b[39m theta_transform\u001b[38;5;241m.\u001b[39mlog_abs_det_jacobian(theta, transformed_theta)\n\u001b[0;32m---> 44\u001b[0m posterior_potential \u001b[38;5;241m=\u001b[39m \u001b[43mpotential_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtheta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrack_gradients\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtrack_gradients\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     45\u001b[0m posterior_potential_transformed \u001b[38;5;241m=\u001b[39m posterior_potential \u001b[38;5;241m-\u001b[39m log_abs_det\n\u001b[1;32m     46\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m posterior_potential_transformed\n",
+      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/potentials/likelihood_based_potential.py:95\u001b[0m, in \u001b[0;36mLikelihoodBasedPotential.__call__\u001b[0;34m(self, theta, track_gradients)\u001b[0m\n\u001b[1;32m     84\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Returns the potential $\\log(p(x_o|\\theta)p(\\theta))$.\u001b[39;00m\n\u001b[1;32m     85\u001b[0m \n\u001b[1;32m     86\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     91\u001b[0m \u001b[38;5;124;03m    The potential $\\log(p(x_o|\\theta)p(\\theta))$.\u001b[39;00m\n\u001b[1;32m     92\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m     93\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mx_is_iid:\n\u001b[1;32m     94\u001b[0m     \u001b[38;5;66;03m# For each theta, calculate the likelihood sum over all x in batch.\u001b[39;00m\n\u001b[0;32m---> 95\u001b[0m     log_likelihood_trial_sum \u001b[38;5;241m=\u001b[39m \u001b[43m_log_likelihoods_over_trials\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     96\u001b[0m \u001b[43m        \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx_o\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     97\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtheta\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtheta\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     98\u001b[0m \u001b[43m        \u001b[49m\u001b[43mestimator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlikelihood_estimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     99\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtrack_gradients\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtrack_gradients\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    100\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    101\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m log_likelihood_trial_sum \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprior\u001b[38;5;241m.\u001b[39mlog_prob(theta)  \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n\u001b[1;32m    102\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    103\u001b[0m     \u001b[38;5;66;03m# Calculate likelihood for each (theta,x) pair separately\u001b[39;00m\n",
+      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/potentials/likelihood_based_potential.py:168\u001b[0m, in \u001b[0;36m_log_likelihoods_over_trials\u001b[0;34m(x, theta, estimator, track_gradients)\u001b[0m\n\u001b[1;32m    166\u001b[0m \u001b[38;5;66;03m# Calculate likelihood in one batch.\u001b[39;00m\n\u001b[1;32m    167\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mset_grad_enabled(track_gradients):\n\u001b[0;32m--> 168\u001b[0m     log_likelihood_trial_batch \u001b[38;5;241m=\u001b[39m \u001b[43mestimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlog_prob\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcondition\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtheta\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    169\u001b[0m     \u001b[38;5;66;03m# Sum over trial-log likelihoods.\u001b[39;00m\n\u001b[1;32m    170\u001b[0m     log_likelihood_trial_sum \u001b[38;5;241m=\u001b[39m log_likelihood_trial_batch\u001b[38;5;241m.\u001b[39msum(\u001b[38;5;241m0\u001b[39m)\n",
+      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/neural_nets/estimators/nflows_flow.py:109\u001b[0m, in \u001b[0;36mNFlowsFlow.log_prob\u001b[0;34m(self, input, condition)\u001b[0m\n\u001b[1;32m    106\u001b[0m ones_for_event_dims \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m1\u001b[39m,) \u001b[38;5;241m*\u001b[39m condition_event_dims  \u001b[38;5;66;03m# Tuple of 1s, e.g. (1, 1, 1)\u001b[39;00m\n\u001b[1;32m    107\u001b[0m condition \u001b[38;5;241m=\u001b[39m condition\u001b[38;5;241m.\u001b[39mrepeat(input_sample_dim, \u001b[38;5;241m*\u001b[39mones_for_event_dims)\n\u001b[0;32m--> 109\u001b[0m log_probs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnet\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlog_prob\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcondition\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m log_probs\u001b[38;5;241m.\u001b[39mreshape((input_sample_dim, input_batch_dim))\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/distributions/base.py:40\u001b[0m, in \u001b[0;36mDistribution.log_prob\u001b[0;34m(self, inputs, context)\u001b[0m\n\u001b[1;32m     36\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m inputs\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m!=\u001b[39m context\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]:\n\u001b[1;32m     37\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m     38\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNumber of input items must be equal to number of context items.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m     39\u001b[0m         )\n\u001b[0;32m---> 40\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_log_prob\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/flows/base.py:39\u001b[0m, in \u001b[0;36mFlow._log_prob\u001b[0;34m(self, inputs, context)\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_log_prob\u001b[39m(\u001b[38;5;28mself\u001b[39m, inputs, context):\n\u001b[1;32m     38\u001b[0m     embedded_context \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_embedding_net(context)\n\u001b[0;32m---> 39\u001b[0m     noise, logabsdet \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_transform\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43membedded_context\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     40\u001b[0m     log_prob \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_distribution\u001b[38;5;241m.\u001b[39mlog_prob(noise, context\u001b[38;5;241m=\u001b[39membedded_context)\n\u001b[1;32m     41\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m log_prob \u001b[38;5;241m+\u001b[39m logabsdet\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1509\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1518\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1519\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1523\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/transforms/base.py:56\u001b[0m, in \u001b[0;36mCompositeTransform.forward\u001b[0;34m(self, inputs, context)\u001b[0m\n\u001b[1;32m     54\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, inputs, context\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m     55\u001b[0m     funcs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_transforms\n\u001b[0;32m---> 56\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cascade\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfuncs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/transforms/base.py:50\u001b[0m, in \u001b[0;36mCompositeTransform._cascade\u001b[0;34m(inputs, funcs, context)\u001b[0m\n\u001b[1;32m     48\u001b[0m total_logabsdet \u001b[38;5;241m=\u001b[39m inputs\u001b[38;5;241m.\u001b[39mnew_zeros(batch_size)\n\u001b[1;32m     49\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m func \u001b[38;5;129;01min\u001b[39;00m funcs:\n\u001b[0;32m---> 50\u001b[0m     outputs, logabsdet \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     51\u001b[0m     total_logabsdet \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m logabsdet\n\u001b[1;32m     52\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m outputs, total_logabsdet\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1509\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1518\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1519\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1523\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/transforms/autoregressive.py:39\u001b[0m, in \u001b[0;36mAutoregressiveTransform.forward\u001b[0;34m(self, inputs, context)\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, inputs, context\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m     38\u001b[0m     autoregressive_params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mautoregressive_net(inputs, context)\n\u001b[0;32m---> 39\u001b[0m     outputs, logabsdet \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_elementwise_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mautoregressive_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     40\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m outputs, logabsdet\n",
+      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/transforms/autoregressive.py:96\u001b[0m, in \u001b[0;36mMaskedAffineAutoregressiveTransform._elementwise_forward\u001b[0;34m(self, inputs, autoregressive_params)\u001b[0m\n\u001b[1;32m     95\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_elementwise_forward\u001b[39m(\u001b[38;5;28mself\u001b[39m, inputs, autoregressive_params):\n\u001b[0;32m---> 96\u001b[0m     unconstrained_scale, shift \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_unconstrained_scale_and_shift\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     97\u001b[0m \u001b[43m        \u001b[49m\u001b[43mautoregressive_params\u001b[49m\n\u001b[1;32m     98\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     99\u001b[0m     \u001b[38;5;66;03m# scale = torch.sigmoid(unconstrained_scale + 2.0) + self._epsilon\u001b[39;00m\n\u001b[1;32m    100\u001b[0m     scale \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39msoftplus(unconstrained_scale) \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_epsilon\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
     }
    ],
    "source": [
-    "plt.scatter(x[:,0], x[:,1], c=color)\n",
-    "plt.xlim(-2, 2)\n",
-    "plt.ylim(-2, 2)\n",
-    "plt.show()"
+    "mcmc_kwargs = dict(\n",
+    "    num_chains=20,\n",
+    "    warmup_steps=50,\n",
+    "    method=\"slice_np_vectorized\",\n",
+    "    init_strategy=\"proposal\",\n",
+    ")\n",
+    "\n",
+    "# Build posterior from the trained estimator and prior.\n",
+    "mnle_posterior = trainer.build_posterior(prior=prior)\n",
+    "\n",
+    "\n",
+    "torch.random.manual_seed(0)\n",
+    "theta_o = prior.sample((1,))\n",
+    "x_o = toy_simulator(theta_o, centers)\n",
+    "\n",
+    "mnle_samples = mnle_posterior.sample((10000,), x=x_o, **mcmc_kwargs)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 500,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "NFlowsFlow(\n",
-       "  (net): Flow(\n",
-       "    (_transform): CompositeTransform(\n",
-       "      (_transforms): ModuleList(\n",
-       "        (0): PointwiseAffineTransform()\n",
-       "        (1): IdentityTransform()\n",
-       "      )\n",
-       "    )\n",
-       "    (_distribution): MultivariateGaussianMDN(\n",
-       "      (_hidden_net): Sequential(\n",
-       "        (0): Linear(in_features=2, out_features=50, bias=True)\n",
-       "        (1): ReLU()\n",
-       "        (2): Dropout(p=0.0, inplace=False)\n",
-       "        (3): Linear(in_features=50, out_features=50, bias=True)\n",
-       "        (4): ReLU()\n",
-       "        (5): Linear(in_features=50, out_features=50, bias=True)\n",
-       "        (6): ReLU()\n",
-       "      )\n",
-       "      (_logits_layer): Linear(in_features=50, out_features=10, bias=True)\n",
-       "      (_means_layer): Linear(in_features=50, out_features=20, bias=True)\n",
-       "      (_unconstrained_diagonal_layer): Linear(in_features=50, out_features=20, bias=True)\n",
-       "      (_upper_layer): Linear(in_features=50, out_features=10, bias=True)\n",
-       "    )\n",
-       "    (_embedding_net): Sequential(\n",
-       "      (0): Standardize()\n",
-       "      (1): Identity()\n",
-       "    )\n",
-       "  )\n",
-       ")"
+       "(<Figure size 500x500 with 4 Axes>,\n",
+       " array([[<Axes: xlabel='dim 1'>, <Axes: >],\n",
+       "        [<Axes: xlabel='dim 1'>, <Axes: xlabel='dim 2'>]], dtype=object))"
       ]
      },
-     "execution_count": 500,
+     "execution_count": 36,
      "metadata": {},
      "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x500 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "CategoricalMassEstimator(CategoricalMADE([2,3], 50, 2), (2,),(2,))\n",
-    "# build_mdn(x[:,:2], theta)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mnle_posterior = trainer.build_posterior(prior=prior)\n"
+    "pairplot(mnle_samples, limits=[[-2, 2], [-2, 2]], figsize=(5, 5), points=theta_o)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

From 1d23ae5f0a787014ba34486ec9117efa6a77d1b1 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Wed, 8 Jan 2025 17:13:42 +0100
Subject: [PATCH 12/17] wip: update toy simulator

---
 sbi/neural_nets/estimators/categorical_net.py |  2 +-
 sbi/neural_nets/net_builders/categorial.py    | 11 ++++++-----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index b10cff021..daea7583e 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -124,7 +124,7 @@ def sample(self, sample_shape, context=None):
         sample_shape = torch.Size(sample_shape)
 
         # Calculate total number of samples
-        num_samples = torch.prod(torch.tensor(sample_shape)).item()
+        num_samples = int(torch.prod(torch.tensor(sample_shape)))
 
         # Prepare context
         if context is not None:
diff --git a/sbi/neural_nets/net_builders/categorial.py b/sbi/neural_nets/net_builders/categorial.py
index 0c98892b9..bf8a8c48b 100644
--- a/sbi/neural_nets/net_builders/categorial.py
+++ b/sbi/neural_nets/net_builders/categorial.py
@@ -107,11 +107,12 @@ def build_autoregressive_categoricalmassestimator(
             standardizing_net(batch_y, structured_y), embedding_net
         )
 
-    batch_x_discrete = batch_x[:, _is_discrete(batch_x)]
-    inferred_categories = tensor([unique(col).numel() for col in batch_x_discrete.T])
-    num_categories = (
-        num_categories if num_categories is not None else inferred_categories
-    )
+    if num_categories is None:
+        batch_x_discrete = batch_x[:, _is_discrete(batch_x)]
+        inferred_categories = tensor([
+            unique(col).numel() for col in batch_x_discrete.T
+        ])
+        num_categories = inferred_categories
 
     categorical_net = CategoricalMADE(
         num_categories=num_categories,

From 70b287fb9b27ecef06853443af8db6a870435bd9 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Wed, 8 Jan 2025 19:03:11 +0100
Subject: [PATCH 13/17] wip: save wip

---
 sbi/neural_nets/estimators/categorical_net.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index daea7583e..a59c86329 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -73,6 +73,7 @@ def __init__(
         self.embedding_net = embedding_net
         self.hidden_features = hidden_features
         self.epsilon = epsilon
+        self.context_features = context_features
 
         if custom_initialization:
             self._initialize()
@@ -132,17 +133,15 @@ def sample(self, sample_shape, context=None):
                 context = context.unsqueeze(0)
             context = torchutils.repeat_rows(context, num_samples)
         else:
-            context = torch.zeros(num_samples, self.context_dim)
+            context = torch.zeros(num_samples, self.context_features)
 
         with torch.no_grad():
             samples = torch.zeros(num_samples, self.num_variables)
-            for variable in range(self.num_variables):
+            for i in range(self.num_variables):
                 outputs = self.forward(samples, context)
-                outputs = outputs.reshape(
-                    num_samples, self.num_variables, self.num_categories
-                )
+                outputs = outputs.reshape(*samples.shape, self.num_categories)
                 ps = self.compute_probs(outputs)
-                samples[:, variable] = Categorical(probs=ps[:, variable]).sample()
+                samples[:, i] = Categorical(probs=ps[:, i]).sample()
 
         return samples.reshape(*sample_shape, self.num_variables)
 

From a0f6f4419458cf9269ef714bb601333a79f0fd87 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 9 Jan 2025 11:37:48 +0100
Subject: [PATCH 14/17] rm: rm legacy CategoricalNet

---
 sbi/neural_nets/estimators/__init__.py        |   1 -
 sbi/neural_nets/estimators/categorical_net.py | 107 +-----------------
 sbi/neural_nets/net_builders/categorial.py    |  50 --------
 sbi/neural_nets/net_builders/mnle.py          |  38 ++-----
 4 files changed, 13 insertions(+), 183 deletions(-)

diff --git a/sbi/neural_nets/estimators/__init__.py b/sbi/neural_nets/estimators/__init__.py
index a885655ba..121fe401e 100644
--- a/sbi/neural_nets/estimators/__init__.py
+++ b/sbi/neural_nets/estimators/__init__.py
@@ -2,7 +2,6 @@
 from sbi.neural_nets.estimators.categorical_net import (
     CategoricalMADE,
     CategoricalMassEstimator,
-    CategoricalNet,
 )
 from sbi.neural_nets.estimators.flowmatching_estimator import FlowMatchingEstimator
 from sbi.neural_nets.estimators.mixed_density_estimator import MixedDensityEstimator
diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index a59c86329..8ddf923cb 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -8,7 +8,6 @@
 from nflows.utils import torchutils
 from torch import Tensor, nn
 from torch.distributions import Categorical
-from torch.nn import Sigmoid, Softmax
 from torch.nn import functional as F
 
 from sbi.neural_nets.estimators.base import ConditionalDensityEstimator
@@ -87,7 +86,7 @@ def forward(self, inputs: Tensor, context: Optional[Tensor] = None) -> Tensor:
             condition: Conditioning variable. (batch_size, *condition_shape)
 
         Returns:
-            Predicted categorical probabilities. (batch_size, *input_shape,
+            Predicted categorical logits. (batch_size, *input_shape,
                 num_categories)
         """
         embedded_context = self.embedding_net.forward(context)
@@ -149,106 +148,6 @@ def _initialize(self):
         pass
 
 
-class CategoricalNet(nn.Module):
-    """Conditional density (mass) estimation for a categorical random variable.
-
-    Takes as input parameters theta and learns the parameters p of a Categorical.
-
-    Defines log prob and sample functions.
-    """
-
-    def __init__(
-        self,
-        num_input: int,
-        num_categories: int,
-        num_hidden: int = 20,
-        num_layers: int = 2,
-        embedding_net: Optional[nn.Module] = None,
-    ):
-        """Initialize the neural net.
-
-        Args:
-            num_input: number of input units, i.e., dimensionality of the features.
-            num_categories: number of output units, i.e., number of categories.
-            num_hidden: number of hidden units per layer.
-            num_layers: number of hidden layers.
-            embedding_net: emebedding net for input.
-        """
-        super().__init__()
-
-        self.num_hidden = num_hidden
-        self.num_input = num_input
-        self.activation = Sigmoid()
-        self.softmax = Softmax(dim=1)
-        self.num_categories = num_categories
-        self.num_variables = 1
-
-        # Maybe add embedding net in front.
-        if embedding_net is not None:
-            self.input_layer = nn.Sequential(
-                embedding_net, nn.Linear(num_input, num_hidden)
-            )
-        else:
-            self.input_layer = nn.Linear(num_input, num_hidden)
-
-        # Repeat hidden units hidden layers times.
-        self.hidden_layers = nn.ModuleList()
-        for _ in range(num_layers):
-            self.hidden_layers.append(nn.Linear(num_hidden, num_hidden))
-
-        self.output_layer = nn.Linear(num_hidden, num_categories)
-
-    def forward(self, condition: Tensor) -> Tensor:
-        """Return categorical probability predicted from a batch of inputs.
-
-        Args:
-            condition: batch of context parameters for the net.
-
-        Returns:
-            Tensor: batch of predicted categorical probabilities.
-        """
-        # forward path
-        condition = self.activation(self.input_layer(condition))
-
-        # iterate n hidden layers, input condition and calculate tanh activation
-        for layer in self.hidden_layers:
-            condition = self.activation(layer(condition))
-
-        return self.softmax(self.output_layer(condition))
-
-    def log_prob(self, input: Tensor, condition: Tensor) -> Tensor:
-        """Return categorical log probability of categories input, given condition.
-
-        Args:
-            input: categories to evaluate.
-            condition: parameters.
-
-        Returns:
-            Tensor: log probs with shape (input.shape[0],)
-        """
-        # Predict categorical ps and evaluate.
-        ps = self.forward(condition)
-        # Squeeze the last dimension (event dim) because `Categorical` has
-        # `event_shape=()` but our data usually has an event_shape of `(1,)`.
-        return Categorical(probs=ps).log_prob(input.squeeze(dim=-1))
-
-    def sample(self, sample_shape: torch.Size, condition: Tensor) -> Tensor:
-        """Returns samples from categorical random variable with probs predicted from
-        the neural net.
-
-        Args:
-            sample_shape: number of samples to obtain.
-            condition: batch of parameters for prediction.
-
-        Returns:
-            Tensor: Samples with shape (num_samples, 1)
-        """
-
-        # Predict Categorical ps and sample.
-        ps = self.forward(condition)
-        return Categorical(probs=ps).sample(sample_shape=sample_shape)
-
-
 class CategoricalMassEstimator(ConditionalDensityEstimator):
     """Conditional density (mass) estimation for a categorical random variable.
 
@@ -256,12 +155,12 @@ class CategoricalMassEstimator(ConditionalDensityEstimator):
     """
 
     def __init__(
-        self, net: CategoricalNet, input_shape: torch.Size, condition_shape: torch.Size
+        self, net: CategoricalMADE, input_shape: torch.Size, condition_shape: torch.Size
     ) -> None:
         """Initialize the mass estimator.
 
         Args:
-            net: CategoricalNet.
+            net: CategoricalMADE.
             input_shape: Shape of the input data.
             condition_shape: Shape of the condition data
         """
diff --git a/sbi/neural_nets/net_builders/categorial.py b/sbi/neural_nets/net_builders/categorial.py
index bf8a8c48b..18ced4397 100644
--- a/sbi/neural_nets/net_builders/categorial.py
+++ b/sbi/neural_nets/net_builders/categorial.py
@@ -9,7 +9,6 @@
 from sbi.neural_nets.estimators import (
     CategoricalMADE,
     CategoricalMassEstimator,
-    CategoricalNet,
 )
 from sbi.neural_nets.estimators.mixed_density_estimator import _is_discrete
 from sbi.utils.nn_utils import get_numel
@@ -18,55 +17,6 @@
 
 
 def build_categoricalmassestimator(
-    batch_x: Tensor,
-    batch_y: Tensor,
-    z_score_x: Optional[str] = "none",
-    z_score_y: Optional[str] = "independent",
-    num_hidden: int = 20,
-    num_layers: int = 2,
-    embedding_net: nn.Module = nn.Identity(),
-):
-    """Returns a density estimator for a categorical random variable.
-
-    Args:
-        batch_x: A batch of input data.
-        batch_y: A batch of condition data.
-        z_score_x: Whether to z-score the input data.
-        z_score_y: Whether to z-score the condition data.
-        num_hidden: Number of hidden units per layer.
-        num_layers: Number of hidden layers.
-        embedding_net: Embedding net for y.
-    """
-
-    if z_score_x != "none":
-        raise ValueError("Categorical input should not be z-scored.")
-
-    check_data_device(batch_x, batch_y)
-    if batch_x.shape[1] > 1:
-        raise NotImplementedError("CategoricalMassEstimator only supports 1D input.")
-    num_categories = unique(batch_x).numel()
-    dim_condition = get_numel(batch_y, embedding_net=embedding_net)
-
-    z_score_y_bool, structured_y = z_score_parser(z_score_y)
-    if z_score_y_bool:
-        embedding_net = nn.Sequential(
-            standardizing_net(batch_y, structured_y), embedding_net
-        )
-
-    categorical_net = CategoricalNet(
-        num_input=dim_condition,
-        num_categories=num_categories,
-        num_hidden=num_hidden,
-        num_layers=num_layers,
-        embedding_net=embedding_net,
-    )
-
-    return CategoricalMassEstimator(
-        categorical_net, input_shape=batch_x[0].shape, condition_shape=batch_y[0].shape
-    )
-
-
-def build_autoregressive_categoricalmassestimator(
     batch_x: Tensor,
     batch_y: Tensor,
     z_score_x: Optional[str] = "none",
diff --git a/sbi/neural_nets/net_builders/mnle.py b/sbi/neural_nets/net_builders/mnle.py
index 391abce8c..208f2c534 100644
--- a/sbi/neural_nets/net_builders/mnle.py
+++ b/sbi/neural_nets/net_builders/mnle.py
@@ -13,7 +13,6 @@
     _separate_input,
 )
 from sbi.neural_nets.net_builders.categorial import (
-    build_autoregressive_categoricalmassestimator,
     build_categoricalmassestimator,
 )
 from sbi.neural_nets.net_builders.flow import (
@@ -59,7 +58,6 @@ def build_mnle(
     z_score_x: Optional[str] = "independent",
     z_score_y: Optional[str] = "independent",
     flow_model: str = "nsf",
-    categorical_model: str = "mlp",
     num_categorical_columns: Optional[Tensor] = None,
     embedding_net: nn.Module = nn.Identity(),
     combined_embedding_net: Optional[nn.Module] = None,
@@ -157,32 +155,16 @@ def build_mnle(
     combined_condition = torch.cat([disc_x, embedded_batch_y], dim=-1)
 
     # Set up a categorical RV neural net for modelling the discrete data.
-    if categorical_model == "made":
-        discrete_net = build_autoregressive_categoricalmassestimator(
-            disc_x,
-            batch_y,
-            z_score_x="none",  # discrete data should not be z-scored.
-            z_score_y="none",  # y-embedding net already z-scores.
-            num_hidden=hidden_features,
-            num_layers=hidden_layers,
-            embedding_net=embedding_net,
-            num_categories=num_categorical_columns,
-        )
-    elif categorical_model == "mlp":
-        assert num_disc == 1, "MLP only supports 1D input."
-        discrete_net = build_categoricalmassestimator(
-            disc_x,
-            batch_y,
-            z_score_x="none",  # discrete data should not be z-scored.
-            z_score_y="none",  # y-embedding net already z-scores.
-            num_hidden=hidden_features,
-            num_layers=hidden_layers,
-            embedding_net=embedding_net,
-        )
-    else:
-        raise ValueError(
-            f"Unknown categorical net {categorical_model}. Must be 'made' or 'mlp'."
-        )
+    discrete_net = build_categoricalmassestimator(
+        disc_x,
+        batch_y,
+        z_score_x="none",  # discrete data should not be z-scored.
+        z_score_y="none",  # y-embedding net already z-scores.
+        num_hidden=hidden_features,
+        num_layers=hidden_layers,
+        embedding_net=embedding_net,
+        num_categories=num_categorical_columns,
+    )
 
     if combined_embedding_net is None:
         # set up linear embedding net for combining discrete and continuous

From 2e5898b2b31b0deaf2aa5f8cf285c0516441f82b Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 9 Jan 2025 16:46:59 +0100
Subject: [PATCH 15/17] fix: correct i/o shapes, updated tutorial

---
 sbi/made_mnle.ipynb                           | 308 ------------------
 sbi/neural_nets/estimators/categorical_net.py |  19 +-
 tests/density_estimator_test.py               |   3 -
 .../Example_01_DecisionMakingModel.ipynb      |   2 +-
 tutorials/example_01_utils.py                 |   2 +-
 5 files changed, 14 insertions(+), 320 deletions(-)
 delete mode 100644 sbi/made_mnle.ipynb

diff --git a/sbi/made_mnle.ipynb b/sbi/made_mnle.ipynb
deleted file mode 100644
index c1cfc22db..000000000
--- a/sbi/made_mnle.ipynb
+++ /dev/null
@@ -1,308 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n"
-     ]
-    }
-   ],
-   "source": [
-    "import torch\n",
-    "from sbi.neural_nets.estimators import MixedDensityEstimator\n",
-    "from sbi.neural_nets.estimators.categorical_net import CategoricalMADE, CategoricalMassEstimator\n",
-    "from sbi.utils.torchutils import BoxUniform\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sbi.inference import MNLE\n",
-    "from sbi.neural_nets.estimators.nflows_flow import NFlowsFlow\n",
-    "from sbi.neural_nets.net_builders.mdn import build_mdn\n",
-    "from sbi.neural_nets.net_builders.categorial import build_autoregressive_categoricalmassestimator, build_categoricalmassestimator\n",
-    "from sbi.neural_nets.net_builders.mnle import build_mnle\n",
-    "from sbi.analysis import pairplot"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def toy_simulator(theta: torch.Tensor, centers: list[torch.Tensor]) -> torch.Tensor:\n",
-    "    batch_size, n_dimensions = theta.shape\n",
-    "    assert len(centers) == n_dimensions, \"Number of center sets must match theta dimensions\"\n",
-    "    \n",
-    "    # Calculate discrete classes by assiging to the closest center\n",
-    "    x_disc = torch.stack([\n",
-    "        torch.argmin(torch.abs(centers[i].unsqueeze(1) - theta[:, i].unsqueeze(0)), dim=0)\n",
-    "        for i in range(n_dimensions)\n",
-    "    ], dim=1)\n",
-    "\n",
-    "    closest_centers = torch.stack([centers[i][x_disc[:, i]] for i in range(n_dimensions)], dim=1)\n",
-    "    # Add Gaussian noise to assigned class centers\n",
-    "    std = 0.4\n",
-    "    x_cont = closest_centers + std * torch.randn_like(closest_centers)\n",
-    "       \n",
-    "    return torch.cat([x_cont, x_disc], dim=1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_706796/1950430755.py:17: UserWarning: Inferring categories from batch_x. Ensure all categories are present.\n",
-      "  cmade = build_autoregressive_categoricalmassestimator(x[:,-len(centers):], theta)\n",
-      "/tmp/ipykernel_706796/1950430755.py:19: UserWarning: The mixed neural likelihood estimator assumes that x contains continuous data in the first n-k columns (e.g., reaction times) and categorical data in the last k columns (e.g., corresponding choices). If this is not the case for the passed `x` do not use this function.\n",
-      "  cmade_mnle = build_mnle(x, theta, categorical_model=\"made\")\n",
-      "/tmp/ipykernel_706796/1950430755.py:28: UserWarning: The mixed neural likelihood estimator assumes that x contains continuous data in the first n-k columns (e.g., reaction times) and categorical data in the last k columns (e.g., corresponding choices). If this is not the case for the passed `x` do not use this function.\n",
-      "  trainer = MNLE(density_estimator=lambda x,y: build_mnle(y,x,categorical_model=\"made\"))\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Neural network successfully converged after 20 epochs."
-     ]
-    }
-   ],
-   "source": [
-    "# THIS WORKS FOR 1D\n",
-    "\n",
-    "torch.random.manual_seed(0)\n",
-    "centers = [\n",
-    "    torch.tensor([-0.5, 0.5]),\n",
-    "    # torch.tensor([-1.0, 0.0, 1.0]),\n",
-    "]\n",
-    "\n",
-    "prior = BoxUniform(low=torch.tensor([-2.0]*len(centers)), high=torch.tensor([2.0]*len(centers)))\n",
-    "theta = prior.sample((10000,))\n",
-    "x = toy_simulator(theta, centers)\n",
-    "theta = torch.hstack([theta, torch.randn_like(theta)])\n",
-    "\n",
-    "theta_o = prior.sample((1,))\n",
-    "x_o = toy_simulator(theta_o, centers)\n",
-    "\n",
-    "cmade = build_autoregressive_categoricalmassestimator(x[:,-len(centers):], theta)\n",
-    "mlp = build_categoricalmassestimator(x[:,-len(centers):], theta)\n",
-    "cmade_mnle = build_mnle(x, theta, categorical_model=\"made\")\n",
-    "\n",
-    "# MNLE mixes up x,y (input and condition data!)\n",
-    "# Train MNLE and obtain MCMC-based posterior.\n",
-    "trainer = MNLE(density_estimator=lambda x,y: build_mnle(y,x,categorical_model=\"made\"))\n",
-    "estimator = trainer.append_simulations(theta, x).train(training_batch_size=1000)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from sbi.inference import SNPE"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_706796/1968649956.py:16: UserWarning: Inferring categories from batch_x. Ensure all categories are present.\n",
-      "  cmade = build_autoregressive_categoricalmassestimator(x[:,-len(centers):], theta)\n",
-      "/tmp/ipykernel_706796/1968649956.py:17: UserWarning: The mixed neural likelihood estimator assumes that x contains continuous data in the first n-k columns (e.g., reaction times) and categorical data in the last k columns (e.g., corresponding choices). If this is not the case for the passed `x` do not use this function.\n",
-      "  cmade_mnle = build_mnle(x, theta, categorical_model=\"made\")\n",
-      "/home/jnsbck/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/neural_nets/net_builders/mnle.py:155: UserWarning: Inferring categories from batch_x. Ensure all categories are present.\n",
-      "  discrete_net = build_autoregressive_categoricalmassestimator(\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Training neural network. Epochs trained: 117"
-     ]
-    }
-   ],
-   "source": [
-    "# THIS WORKS FOR 2D\n",
-    "\n",
-    "torch.random.manual_seed(0)\n",
-    "centers = [\n",
-    "    torch.tensor([-0.5, 0.5]),\n",
-    "    torch.tensor([-1.0, 0.0, 1.0]),\n",
-    "]\n",
-    "\n",
-    "prior = BoxUniform(low=torch.tensor([-2.0]*len(centers)), high=torch.tensor([2.0]*len(centers)))\n",
-    "theta = prior.sample((20000,))\n",
-    "x = toy_simulator(theta, centers)\n",
-    "\n",
-    "theta_o = prior.sample((1,))\n",
-    "x_o = toy_simulator(theta_o, centers)\n",
-    "\n",
-    "cmade = build_autoregressive_categoricalmassestimator(x[:,-len(centers):], theta)\n",
-    "cmade_mnle = build_mnle(x, theta, categorical_model=\"made\")\n",
-    "\n",
-    "# Train MNLE and obtain MCMC-based posterior.\n",
-    "# trainer = MNLE(density_estimator=lambda x,y: build_mnle(y,x,categorical_model=\"made\"))\n",
-    "trainer = SNPE()\n",
-    "estimator = trainer.append_simulations(theta=theta, x=x).train(training_batch_size=1000)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "snpe_posterior = trainer.build_posterior(prior=prior)\n",
-    "posterior_samples = snpe_posterior.sample((2000,), x=x_o)\n",
-    "pairplot(posterior_samples, limits=[[-2, 2], [-2, 2]], figsize=(5, 5), points=theta_o)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "bf5cc867b10d4548aa39a703c08bdf0c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Running vectorized MCMC with 20 chains:   0%|          | 0/12000 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[41], line 16\u001b[0m\n\u001b[1;32m     13\u001b[0m theta_o \u001b[38;5;241m=\u001b[39m prior\u001b[38;5;241m.\u001b[39msample((\u001b[38;5;241m1\u001b[39m,))\n\u001b[1;32m     14\u001b[0m x_o \u001b[38;5;241m=\u001b[39m toy_simulator(theta_o, centers)\n\u001b[0;32m---> 16\u001b[0m mnle_samples \u001b[38;5;241m=\u001b[39m \u001b[43mmnle_posterior\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msample\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m10000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mx_o\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmcmc_kwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/posteriors/mcmc_posterior.py:318\u001b[0m, in \u001b[0;36mMCMCPosterior.sample\u001b[0;34m(self, sample_shape, x, method, thin, warmup_steps, num_chains, init_strategy, init_strategy_parameters, init_strategy_num_candidates, mcmc_parameters, mcmc_method, sample_with, num_workers, mp_context, show_progress_bars)\u001b[0m\n\u001b[1;32m    316\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mset_grad_enabled(track_gradients):\n\u001b[1;32m    317\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01min\u001b[39;00m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mslice_np\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mslice_np_vectorized\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m--> 318\u001b[0m         transformed_samples \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_slice_np_mcmc\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    319\u001b[0m \u001b[43m            \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    320\u001b[0m \u001b[43m            \u001b[49m\u001b[43mpotential_function\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpotential_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    321\u001b[0m \u001b[43m            \u001b[49m\u001b[43minitial_params\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minitial_params\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    322\u001b[0m \u001b[43m            \u001b[49m\u001b[43mthin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mthin\u001b[49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# type: ignore\u001b[39;49;00m\n\u001b[1;32m    323\u001b[0m \u001b[43m            \u001b[49m\u001b[43mwarmup_steps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwarmup_steps\u001b[49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# type: ignore\u001b[39;49;00m\n\u001b[1;32m    324\u001b[0m \u001b[43m            \u001b[49m\u001b[43mvectorized\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mslice_np_vectorized\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    325\u001b[0m \u001b[43m            \u001b[49m\u001b[43minterchangeable_chains\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    326\u001b[0m \u001b[43m            \u001b[49m\u001b[43mnum_workers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_workers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    327\u001b[0m \u001b[43m            \u001b[49m\u001b[43mshow_progress_bars\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_progress_bars\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    328\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    329\u001b[0m     \u001b[38;5;28;01melif\u001b[39;00m method \u001b[38;5;129;01min\u001b[39;00m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhmc_pyro\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnuts_pyro\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m    330\u001b[0m         transformed_samples \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pyro_mcmc(\n\u001b[1;32m    331\u001b[0m             num_samples\u001b[38;5;241m=\u001b[39mnum_samples,\n\u001b[1;32m    332\u001b[0m             potential_function\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpotential_,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    339\u001b[0m             mp_context\u001b[38;5;241m=\u001b[39mmp_context,\n\u001b[1;32m    340\u001b[0m         )\n",
-      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/posteriors/mcmc_posterior.py:753\u001b[0m, in \u001b[0;36mMCMCPosterior._slice_np_mcmc\u001b[0;34m(self, num_samples, potential_function, initial_params, thin, warmup_steps, vectorized, interchangeable_chains, num_workers, init_width, show_progress_bars)\u001b[0m\n\u001b[1;32m    751\u001b[0m num_samples_ \u001b[38;5;241m=\u001b[39m ceil((num_samples \u001b[38;5;241m*\u001b[39m thin) \u001b[38;5;241m/\u001b[39m num_chains)\n\u001b[1;32m    752\u001b[0m \u001b[38;5;66;03m# Run mcmc including warmup\u001b[39;00m\n\u001b[0;32m--> 753\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[43mposterior_sampler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwarmup_\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mnum_samples_\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    754\u001b[0m samples \u001b[38;5;241m=\u001b[39m samples[:, warmup_steps:, :]  \u001b[38;5;66;03m# discard warmup steps\u001b[39;00m\n\u001b[1;32m    755\u001b[0m samples \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mfrom_numpy(samples)  \u001b[38;5;66;03m# chains x samples x dim\u001b[39;00m\n",
-      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/samplers/mcmc/slice_numpy.py:462\u001b[0m, in \u001b[0;36mSliceSamplerVectorized.run\u001b[0;34m(self, num_samples)\u001b[0m\n\u001b[1;32m    455\u001b[0m         sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnext_param\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mconcatenate([\n\u001b[1;32m    456\u001b[0m             sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m][: sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124morder\u001b[39m\u001b[38;5;124m\"\u001b[39m][sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mi\u001b[39m\u001b[38;5;124m\"\u001b[39m]]],\n\u001b[1;32m    457\u001b[0m             [sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcxi\u001b[39m\u001b[38;5;124m\"\u001b[39m]],\n\u001b[1;32m    458\u001b[0m             sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m][sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124morder\u001b[39m\u001b[38;5;124m\"\u001b[39m][sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mi\u001b[39m\u001b[38;5;124m\"\u001b[39m]] \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m :],\n\u001b[1;32m    459\u001b[0m         ])\n\u001b[1;32m    461\u001b[0m params \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mstack([sc[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnext_param\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m sc \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mvalues()])\n\u001b[0;32m--> 462\u001b[0m log_probs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_log_prob_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    464\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m c \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_chains):\n\u001b[1;32m    465\u001b[0m     sc \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate[c]\n",
-      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/posteriors/mcmc_posterior.py:738\u001b[0m, in \u001b[0;36mMCMCPosterior._slice_np_mcmc.<locals>.multi_obs_potential\u001b[0;34m(params)\u001b[0m\n\u001b[1;32m    736\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmulti_obs_potential\u001b[39m(params):\n\u001b[1;32m    737\u001b[0m     \u001b[38;5;66;03m# Params are of shape (num_chains * num_obs, event).\u001b[39;00m\n\u001b[0;32m--> 738\u001b[0m     all_potentials \u001b[38;5;241m=\u001b[39m \u001b[43mpotential_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# Shape: (num_chains, num_obs)\u001b[39;00m\n\u001b[1;32m    739\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m all_potentials\u001b[38;5;241m.\u001b[39mflatten()\n",
-      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/utils/potentialutils.py:44\u001b[0m, in \u001b[0;36mtransformed_potential\u001b[0;34m(theta, potential_fn, theta_transform, device, track_gradients)\u001b[0m\n\u001b[1;32m     41\u001b[0m theta \u001b[38;5;241m=\u001b[39m theta_transform\u001b[38;5;241m.\u001b[39minv(transformed_theta)  \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n\u001b[1;32m     42\u001b[0m log_abs_det \u001b[38;5;241m=\u001b[39m theta_transform\u001b[38;5;241m.\u001b[39mlog_abs_det_jacobian(theta, transformed_theta)\n\u001b[0;32m---> 44\u001b[0m posterior_potential \u001b[38;5;241m=\u001b[39m \u001b[43mpotential_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtheta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrack_gradients\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtrack_gradients\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     45\u001b[0m posterior_potential_transformed \u001b[38;5;241m=\u001b[39m posterior_potential \u001b[38;5;241m-\u001b[39m log_abs_det\n\u001b[1;32m     46\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m posterior_potential_transformed\n",
-      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/potentials/likelihood_based_potential.py:95\u001b[0m, in \u001b[0;36mLikelihoodBasedPotential.__call__\u001b[0;34m(self, theta, track_gradients)\u001b[0m\n\u001b[1;32m     84\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Returns the potential $\\log(p(x_o|\\theta)p(\\theta))$.\u001b[39;00m\n\u001b[1;32m     85\u001b[0m \n\u001b[1;32m     86\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     91\u001b[0m \u001b[38;5;124;03m    The potential $\\log(p(x_o|\\theta)p(\\theta))$.\u001b[39;00m\n\u001b[1;32m     92\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m     93\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mx_is_iid:\n\u001b[1;32m     94\u001b[0m     \u001b[38;5;66;03m# For each theta, calculate the likelihood sum over all x in batch.\u001b[39;00m\n\u001b[0;32m---> 95\u001b[0m     log_likelihood_trial_sum \u001b[38;5;241m=\u001b[39m \u001b[43m_log_likelihoods_over_trials\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     96\u001b[0m \u001b[43m        \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx_o\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     97\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtheta\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtheta\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     98\u001b[0m \u001b[43m        \u001b[49m\u001b[43mestimator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlikelihood_estimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     99\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtrack_gradients\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtrack_gradients\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    100\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    101\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m log_likelihood_trial_sum \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprior\u001b[38;5;241m.\u001b[39mlog_prob(theta)  \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n\u001b[1;32m    102\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    103\u001b[0m     \u001b[38;5;66;03m# Calculate likelihood for each (theta,x) pair separately\u001b[39;00m\n",
-      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/inference/potentials/likelihood_based_potential.py:168\u001b[0m, in \u001b[0;36m_log_likelihoods_over_trials\u001b[0;34m(x, theta, estimator, track_gradients)\u001b[0m\n\u001b[1;32m    166\u001b[0m \u001b[38;5;66;03m# Calculate likelihood in one batch.\u001b[39;00m\n\u001b[1;32m    167\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mset_grad_enabled(track_gradients):\n\u001b[0;32m--> 168\u001b[0m     log_likelihood_trial_batch \u001b[38;5;241m=\u001b[39m \u001b[43mestimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlog_prob\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcondition\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtheta\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    169\u001b[0m     \u001b[38;5;66;03m# Sum over trial-log likelihoods.\u001b[39;00m\n\u001b[1;32m    170\u001b[0m     log_likelihood_trial_sum \u001b[38;5;241m=\u001b[39m log_likelihood_trial_batch\u001b[38;5;241m.\u001b[39msum(\u001b[38;5;241m0\u001b[39m)\n",
-      "File \u001b[0;32m~/Uni/PhD/projects/sbi_hackathon/sbi_fork/sbi/neural_nets/estimators/nflows_flow.py:109\u001b[0m, in \u001b[0;36mNFlowsFlow.log_prob\u001b[0;34m(self, input, condition)\u001b[0m\n\u001b[1;32m    106\u001b[0m ones_for_event_dims \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m1\u001b[39m,) \u001b[38;5;241m*\u001b[39m condition_event_dims  \u001b[38;5;66;03m# Tuple of 1s, e.g. (1, 1, 1)\u001b[39;00m\n\u001b[1;32m    107\u001b[0m condition \u001b[38;5;241m=\u001b[39m condition\u001b[38;5;241m.\u001b[39mrepeat(input_sample_dim, \u001b[38;5;241m*\u001b[39mones_for_event_dims)\n\u001b[0;32m--> 109\u001b[0m log_probs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnet\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlog_prob\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcondition\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m log_probs\u001b[38;5;241m.\u001b[39mreshape((input_sample_dim, input_batch_dim))\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/distributions/base.py:40\u001b[0m, in \u001b[0;36mDistribution.log_prob\u001b[0;34m(self, inputs, context)\u001b[0m\n\u001b[1;32m     36\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m inputs\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m!=\u001b[39m context\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]:\n\u001b[1;32m     37\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m     38\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNumber of input items must be equal to number of context items.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m     39\u001b[0m         )\n\u001b[0;32m---> 40\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_log_prob\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/flows/base.py:39\u001b[0m, in \u001b[0;36mFlow._log_prob\u001b[0;34m(self, inputs, context)\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_log_prob\u001b[39m(\u001b[38;5;28mself\u001b[39m, inputs, context):\n\u001b[1;32m     38\u001b[0m     embedded_context \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_embedding_net(context)\n\u001b[0;32m---> 39\u001b[0m     noise, logabsdet \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_transform\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43membedded_context\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     40\u001b[0m     log_prob \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_distribution\u001b[38;5;241m.\u001b[39mlog_prob(noise, context\u001b[38;5;241m=\u001b[39membedded_context)\n\u001b[1;32m     41\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m log_prob \u001b[38;5;241m+\u001b[39m logabsdet\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1509\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1518\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1519\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1523\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/transforms/base.py:56\u001b[0m, in \u001b[0;36mCompositeTransform.forward\u001b[0;34m(self, inputs, context)\u001b[0m\n\u001b[1;32m     54\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, inputs, context\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m     55\u001b[0m     funcs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_transforms\n\u001b[0;32m---> 56\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cascade\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfuncs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/transforms/base.py:50\u001b[0m, in \u001b[0;36mCompositeTransform._cascade\u001b[0;34m(inputs, funcs, context)\u001b[0m\n\u001b[1;32m     48\u001b[0m total_logabsdet \u001b[38;5;241m=\u001b[39m inputs\u001b[38;5;241m.\u001b[39mnew_zeros(batch_size)\n\u001b[1;32m     49\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m func \u001b[38;5;129;01min\u001b[39;00m funcs:\n\u001b[0;32m---> 50\u001b[0m     outputs, logabsdet \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     51\u001b[0m     total_logabsdet \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m logabsdet\n\u001b[1;32m     52\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m outputs, total_logabsdet\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1509\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1518\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1519\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1523\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/transforms/autoregressive.py:39\u001b[0m, in \u001b[0;36mAutoregressiveTransform.forward\u001b[0;34m(self, inputs, context)\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, inputs, context\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m     38\u001b[0m     autoregressive_params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mautoregressive_net(inputs, context)\n\u001b[0;32m---> 39\u001b[0m     outputs, logabsdet \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_elementwise_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mautoregressive_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     40\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m outputs, logabsdet\n",
-      "File \u001b[0;32m~/Applications/miniforge3/envs/sbi/lib/python3.10/site-packages/nflows/transforms/autoregressive.py:96\u001b[0m, in \u001b[0;36mMaskedAffineAutoregressiveTransform._elementwise_forward\u001b[0;34m(self, inputs, autoregressive_params)\u001b[0m\n\u001b[1;32m     95\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_elementwise_forward\u001b[39m(\u001b[38;5;28mself\u001b[39m, inputs, autoregressive_params):\n\u001b[0;32m---> 96\u001b[0m     unconstrained_scale, shift \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_unconstrained_scale_and_shift\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     97\u001b[0m \u001b[43m        \u001b[49m\u001b[43mautoregressive_params\u001b[49m\n\u001b[1;32m     98\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     99\u001b[0m     \u001b[38;5;66;03m# scale = torch.sigmoid(unconstrained_scale + 2.0) + self._epsilon\u001b[39;00m\n\u001b[1;32m    100\u001b[0m     scale \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39msoftplus(unconstrained_scale) \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_epsilon\n",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
-     ]
-    }
-   ],
-   "source": [
-    "mcmc_kwargs = dict(\n",
-    "    num_chains=20,\n",
-    "    warmup_steps=50,\n",
-    "    method=\"slice_np_vectorized\",\n",
-    "    init_strategy=\"proposal\",\n",
-    ")\n",
-    "\n",
-    "# Build posterior from the trained estimator and prior.\n",
-    "mnle_posterior = trainer.build_posterior(prior=prior)\n",
-    "\n",
-    "\n",
-    "torch.random.manual_seed(0)\n",
-    "theta_o = prior.sample((1,))\n",
-    "x_o = toy_simulator(theta_o, centers)\n",
-    "\n",
-    "mnle_samples = mnle_posterior.sample((10000,), x=x_o, **mcmc_kwargs)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(<Figure size 500x500 with 4 Axes>,\n",
-       " array([[<Axes: xlabel='dim 1'>, <Axes: >],\n",
-       "        [<Axes: xlabel='dim 1'>, <Axes: xlabel='dim 2'>]], dtype=object))"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 4 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "pairplot(mnle_samples, limits=[[-2, 2], [-2, 2]], figsize=(5, 5), points=theta_o)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "sbi",
-   "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.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 8ddf923cb..4c9249b2f 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -34,7 +34,7 @@ def __init__(
         use_batch_norm: bool = False,
         epsilon: float = 1e-2,
         custom_initialization: bool = True,
-        embedding_net: Optional[nn.Module] = nn.Identity(),
+        embedding_net: nn.Module = nn.Identity(),
     ):
         """Initialize the neural net.
 
@@ -128,21 +128,26 @@ def sample(self, sample_shape, context=None):
 
         # Prepare context
         if context is not None:
-            if context.ndim == 1:
+            batch_dim = context.shape[0]
+            if context.ndim == 2:
                 context = context.unsqueeze(0)
-            context = torchutils.repeat_rows(context, num_samples)
+            if batch_dim == 1:
+                context = torchutils.repeat_rows(context, num_samples)
         else:
-            context = torch.zeros(num_samples, self.context_features)
+            context_dim = 0 if self.context_features is None else self.context_features
+            context = torch.zeros(num_samples, context_dim)
+            batch_dim = 1
 
         with torch.no_grad():
-            samples = torch.zeros(num_samples, self.num_variables)
+            samples = torch.zeros(num_samples, batch_dim, self.num_variables)
+            print(samples.shape, context.shape)
             for i in range(self.num_variables):
                 outputs = self.forward(samples, context)
                 outputs = outputs.reshape(*samples.shape, self.num_categories)
                 ps = self.compute_probs(outputs)
-                samples[:, i] = Categorical(probs=ps[:, i]).sample()
+                samples[:, :, i] = Categorical(probs=ps[:, :, i]).sample()
 
-        return samples.reshape(*sample_shape, self.num_variables)
+        return samples.reshape(*sample_shape, batch_dim, self.num_variables)
 
     def _initialize(self):
         pass
diff --git a/tests/density_estimator_test.py b/tests/density_estimator_test.py
index 0f006dde1..b958637eb 100644
--- a/tests/density_estimator_test.py
+++ b/tests/density_estimator_test.py
@@ -412,7 +412,4 @@ def test_mixed_density_estimator(
 
     # Test samples
     samples = density_estimator.sample(sample_shape, condition=conditions)
-    if density_estimator_build_fn == build_categoricalmassestimator:
-        # Our categorical is always 1D and does not return `input_event_shape`.
-        input_event_shape = ()
     assert samples.shape == (*sample_shape, batch_dim, *input_event_shape)
diff --git a/tutorials/Example_01_DecisionMakingModel.ipynb b/tutorials/Example_01_DecisionMakingModel.ipynb
index eb16182c2..409a111af 100644
--- a/tutorials/Example_01_DecisionMakingModel.ipynb
+++ b/tutorials/Example_01_DecisionMakingModel.ipynb
@@ -103,7 +103,7 @@
     "    \"\"\"Returns a sample from a mixed distribution given parameters theta.\n",
     "\n",
     "    Args:\n",
-    "        theta: batch of parameters, shape (batch_size, 2) concentration_scaling:\n",
+    "        theta: batch of parameters, shape (batch_size, 1 + num_categories) concentration_scaling:\n",
     "        scaling factor for the concentration parameter of the InverseGamma\n",
     "        distribution, mimics an experimental condition.\n",
     "\n",
diff --git a/tutorials/example_01_utils.py b/tutorials/example_01_utils.py
index 620058d05..a90d58dfe 100644
--- a/tutorials/example_01_utils.py
+++ b/tutorials/example_01_utils.py
@@ -54,7 +54,7 @@ def iid_likelihood(self, theta: Tensor) -> Tensor:
             rate=beta,
         ).log_prob(self.x_o[:, :1].reshape(1, num_trials, -1))
 
-        joint_likelihood = (logprob_choices + logprob_rts).squeeze()
+        joint_likelihood = torch.sum(logprob_choices, dim=2) + logprob_rts.squeeze()
 
         assert joint_likelihood.shape == torch.Size([theta.shape[0], self.x_o.shape[0]])
         return joint_likelihood.sum(1)

From aedff99c9f99caac02745b02c59155e97d1285f9 Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Wed, 5 Feb 2025 14:50:42 +0100
Subject: [PATCH 16/17] doc: fix input arg dostrings

---
 sbi/neural_nets/estimators/categorical_net.py | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 4c9249b2f..7831db84d 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -77,42 +77,42 @@ def __init__(
         if custom_initialization:
             self._initialize()
 
-    def forward(self, inputs: Tensor, context: Optional[Tensor] = None) -> Tensor:
+    def forward(self, input: Tensor, condition: Optional[Tensor] = None) -> Tensor:
         r"""Forward pass of the categorical density estimator network to compute the
         conditional density at a given time.
 
         Args:
-            input: Original data, x0. (batch_size, *input_shape)
-            condition: Conditioning variable. (batch_size, *condition_shape)
+            input: Inputs datapoints of shape `(batch_size, *input_shape)`
+            condition: Conditioning variable. `(batch_size, *condition_shape)`
 
         Returns:
-            Predicted categorical logits. (batch_size, *input_shape,
-                num_categories)
+            Predicted categorical logits. `(batch_size, *input_shape,
+                num_categories)`
         """
-        embedded_context = self.embedding_net.forward(context)
-        return super().forward(inputs, context=embedded_context)
+        embedded_context = self.embedding_net.forward(condition)
+        return super().forward(input, context=embedded_context)
 
     def compute_probs(self, outputs):
         ps = F.softmax(outputs, dim=-1) * self.mask
         ps = ps / ps.sum(dim=-1, keepdim=True)
         return ps
 
-    def log_prob(self, inputs: Tensor, context: Optional[Tensor] = None) -> Tensor:
+    def log_prob(self, input: Tensor, condition: Optional[Tensor] = None) -> Tensor:
         r"""Return log-probability of samples.
 
         Args:
             input: Input datapoints of shape `(batch_size, *input_shape)`.
-            context: Context of shape `(batch_size, *condition_shape)`.
+            condition: Conditioning variable. `(batch_size, *condition_shape)`.
 
         Returns:
             Log-probabilities of shape `(batch_size, num_variables, num_categories)`.
         """
-        outputs = self.forward(inputs, context=context)
-        outputs = outputs.reshape(*inputs.shape, self.num_categories)
+        outputs = self.forward(input, condition=condition)
+        outputs = outputs.reshape(*input.shape, self.num_categories)
         ps = self.compute_probs(outputs)
 
         # categorical log prob
-        log_prob = torch.log(ps.gather(-1, inputs.unsqueeze(-1).long()))
+        log_prob = torch.log(ps.gather(-1, input.unsqueeze(-1).long()))
         log_prob = log_prob.squeeze(-1).sum(dim=-1)
 
         return log_prob

From ce7c656d49fbbb84e415eb08b8513b0a462c1f6a Mon Sep 17 00:00:00 2001
From: jnsbck-uni <jonas.beck@uni-tuebingen.de>
Date: Thu, 6 Feb 2025 13:35:05 +0100
Subject: [PATCH 17/17] wip: fixes from PR implemented

---
 sbi/neural_nets/estimators/categorical_net.py | 32 +++++--------------
 sbi/neural_nets/net_builders/mnle.py          |  2 --
 2 files changed, 8 insertions(+), 26 deletions(-)

diff --git a/sbi/neural_nets/estimators/categorical_net.py b/sbi/neural_nets/estimators/categorical_net.py
index 7831db84d..c09118c79 100644
--- a/sbi/neural_nets/estimators/categorical_net.py
+++ b/sbi/neural_nets/estimators/categorical_net.py
@@ -33,7 +33,6 @@ def __init__(
         dropout_probability: float = 0.0,
         use_batch_norm: bool = False,
         epsilon: float = 1e-2,
-        custom_initialization: bool = True,
         embedding_net: nn.Module = nn.Identity(),
     ):
         """Initialize the neural net.
@@ -74,9 +73,6 @@ def __init__(
         self.epsilon = epsilon
         self.context_features = context_features
 
-        if custom_initialization:
-            self._initialize()
-
     def forward(self, input: Tensor, condition: Optional[Tensor] = None) -> Tensor:
         r"""Forward pass of the categorical density estimator network to compute the
         conditional density at a given time.
@@ -89,13 +85,9 @@ def forward(self, input: Tensor, condition: Optional[Tensor] = None) -> Tensor:
             Predicted categorical logits. `(batch_size, *input_shape,
                 num_categories)`
         """
-        embedded_context = self.embedding_net.forward(condition)
-        return super().forward(input, context=embedded_context)
-
-    def compute_probs(self, outputs):
-        ps = F.softmax(outputs, dim=-1) * self.mask
-        ps = ps / ps.sum(dim=-1, keepdim=True)
-        return ps
+        embedded_condition = self.embedding_net.forward(condition)
+        out = super().forward(input, context=embedded_condition)
+        return out.masked_fill(~self.mask.bool().flatten(), float("-inf"))
 
     def log_prob(self, input: Tensor, condition: Optional[Tensor] = None) -> Tensor:
         r"""Return log-probability of samples.
@@ -109,12 +101,7 @@ def log_prob(self, input: Tensor, condition: Optional[Tensor] = None) -> Tensor:
         """
         outputs = self.forward(input, condition=condition)
         outputs = outputs.reshape(*input.shape, self.num_categories)
-        ps = self.compute_probs(outputs)
-
-        # categorical log prob
-        log_prob = torch.log(ps.gather(-1, input.unsqueeze(-1).long()))
-        log_prob = log_prob.squeeze(-1).sum(dim=-1)
-
+        log_prob = Categorical(logits=outputs).log_prob(input).sum(dim=-1)
         return log_prob
 
     def sample(self, sample_shape, context=None):
@@ -139,19 +126,16 @@ def sample(self, sample_shape, context=None):
             batch_dim = 1
 
         with torch.no_grad():
-            samples = torch.zeros(num_samples, batch_dim, self.num_variables)
-            print(samples.shape, context.shape)
+            samples = torch.randn(num_samples, batch_dim, self.num_variables)
             for i in range(self.num_variables):
                 outputs = self.forward(samples, context)
                 outputs = outputs.reshape(*samples.shape, self.num_categories)
-                ps = self.compute_probs(outputs)
-                samples[:, :, i] = Categorical(probs=ps[:, :, i]).sample()
+                samples[:, :, : i + 1] = Categorical(
+                    logits=outputs[:, :, : i + 1]
+                ).sample()
 
         return samples.reshape(*sample_shape, batch_dim, self.num_variables)
 
-    def _initialize(self):
-        pass
-
 
 class CategoricalMassEstimator(ConditionalDensityEstimator):
     """Conditional density (mass) estimation for a categorical random variable.
diff --git a/sbi/neural_nets/net_builders/mnle.py b/sbi/neural_nets/net_builders/mnle.py
index 208f2c534..2227ccef9 100644
--- a/sbi/neural_nets/net_builders/mnle.py
+++ b/sbi/neural_nets/net_builders/mnle.py
@@ -105,8 +105,6 @@ def build_mnle(
             as z_score_x.
         flow_model: type of flow model to use for the continuous part of the
             data.
-        categorical_model: type of categorical net to use for the discrete part of
-            the data. Can be "made" or "mlp".
         num_categorical_columns: Number of categorical columns of each variable in the
             input data. If None, the function will infer this from the data.
         embedding_net: Optional embedding network for y, required if y is > 1D.