diff --git a/docs/docs/index.md b/docs/docs/index.md
index ab9f10915..c0cfa4695 100644
--- a/docs/docs/index.md
+++ b/docs/docs/index.md
@@ -4,13 +4,21 @@
 
 ![using sbi](static/infer_demo.gif)
 
-Inference can be run in a single line of code:
+Inference can be run in a single line of code
 
 ```python
 posterior = infer(simulator, prior, method='SNPE', num_simulations=1000)
 ```
 
-and you can choose from a variety of _amortized_ and _sequential_ SBI methods.
+or in a few lines for more flexibility:
+
+```python
+inference = SNPE(prior=prior)
+_ = inference.append_simulations(theta, x).train()
+posterior = inference.build_posterior()
+```
+
+`sbi` lets you choose from a variety of _amortized_ and _sequential_ SBI methods:
 
 Amortized methods return a posterior that can be applied to many different observations without retraining,
 whereas sequential methods focus the inference on one particular observation to be more simulation-efficient.
diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml
index df72f30f6..3912506ee 100644
--- a/docs/mkdocs.yml
+++ b/docs/mkdocs.yml
@@ -7,18 +7,17 @@ nav:
   - Tutorials and Examples:
       - Introduction:
         - Getting started: tutorial/00_getting_started.md
-        - Amortized inference: tutorial/01_gaussian_amortized.md
         - Flexible interface: tutorial/02_flexible_interface.md
-        - Sampler interface: tutorial/11_sampler_interface.md
+        - Amortized inference: tutorial/01_gaussian_amortized.md
         - Implemented algorithms: tutorial/16_implemented_methods.md
       - Advanced:
         - Multi-round inference: tutorial/03_multiround_inference.md
-        - Using Variational Inference for Building Posteriors: tutorial/17_vi_posteriors.md
+        - Sampling algorithms in sbi: tutorial/11_sampler_interface.md
         - Custom density estimators: tutorial/04_density_estimators.md
         - Learning summary statistics: tutorial/05_embedding_net.md
+        - SBI with trial-based data: tutorial/14_iid_data_and_permutation_invariant_embeddings.md
         - Handling invalid simulations: tutorial/08_restriction_estimator.md
         - Crafting summary statistics: tutorial/10_crafting_summary_statistics.md
-        - SBI with trial-based data: tutorial/14_iid_data_and_permutation_invariant_embeddings.md
       - Diagnostics:
         - Posterior predictive checks: tutorial/12_diagnostics_posterior_predictive_check.md
         - Simulation-based calibration: tutorial/13_diagnostics_simulation_based_calibration.md
diff --git a/tutorials/00_getting_started.ipynb b/tutorials/00_getting_started.ipynb
index ebfe2bdb6..022a8af1b 100644
--- a/tutorials/00_getting_started.ipynb
+++ b/tutorials/00_getting_started.ipynb
@@ -56,7 +56,6 @@
     "num_dim = 3\n",
     "prior = utils.BoxUniform(low=-2 * torch.ones(num_dim), high=2 * torch.ones(num_dim))\n",
     "\n",
-    "\n",
     "def simulator(parameter_set):\n",
     "    return 1.0 + parameter_set + torch.randn(parameter_set.shape) * 0.1"
    ]
@@ -96,6 +95,7 @@
     }
    ],
    "source": [
+    "# Other methods are \"SNLE\" or \"SNRE\".\n",
     "posterior = infer(simulator, prior, method=\"SNPE\", num_simulations=1000)"
    ]
   },
@@ -166,78 +166,7 @@
    "source": [
     "## Next steps\n",
     "\n",
-    "The single-line interface described above provides an easy entry for using `sbi`. However, if you are working on a larger project or need additional features, we strongly recommend using the [flexible interface](https://www.mackelab.org/sbi/tutorial/02_flexible_interface/)."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Requirements for the simulator, prior, and observation\n",
-    "\n",
-    "In the interface described above, you need to provide a prior and a simulator for training. Let's talk about what requirements they need to satisfy."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "### Prior\n",
-    "A prior is a distribution object that allows to sample parameter sets. Any class for the prior is allowed as long as it allows to call `prior.sample()` and `prior.log_prob()`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Simulator\n",
-    "The simulator is a Python callable that takes in a parameter set and outputs data with some (even if very small) stochasticity.\n",
-    "\n",
-    "Allowed data types and shapes for input and output:\n",
-    "\n",
-    "- the input parameter set and the output have to be either a `np.ndarray` or a `torch.Tensor`. \n",
-    "- the input parameter set should have either shape `(1,N)` or `(N)`, and the output must have shape `(1,M)` or `(M)`.\n",
-    "\n",
-    "You can call simulators not written in Python as long as you wrap them in a Python function."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Observation\n",
-    "Once you have a trained posterior, you will want to evaluate or sample the posterior $p(\\theta|x_o)$ at certain observed values $x_o$:\n",
-    "\n",
-    "- The allowable data types are either Numpy `np.ndarray` or a torch `torch.Tensor`.\n",
-    "- The shape must be either `(1,M)` or just `(M)`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Running different algorithms\n",
-    "\n",
-    "`sbi` implements three classes of algorithms that can be used to obtain the posterior distribution: SNPE, SNLE, and SNRE. You can try the different algorithms by simply swapping out the `method`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "posterior = infer(simulator, prior, method=\"SNPE\", num_simulations=1000)\n",
-    "posterior = infer(simulator, prior, method=\"SNLE\", num_simulations=1000)\n",
-    "posterior = infer(simulator, prior, method=\"SNRE\", num_simulations=1000)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can then infer, sample, evaluate, and plot the posterior as described above."
+    "The single-line interface described above provides an easy entry for using `sbi`. However, on almost any real-world problem that goes beyond a simple demonstration, we strongly recommend using the [flexible interface](https://www.mackelab.org/sbi/tutorial/02_flexible_interface/)."
    ]
   }
  ],
diff --git a/tutorials/01_gaussian_amortized.ipynb b/tutorials/01_gaussian_amortized.ipynb
index e2871c2b7..76ef2e0a5 100644
--- a/tutorials/01_gaussian_amortized.ipynb
+++ b/tutorials/01_gaussian_amortized.ipynb
@@ -74,36 +74,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can then run inference:"
+    "We can then run inference (either with the simple interface of with the flexible interface):"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "574bca59922f4e68a7dcf8f5afe3b372",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Running 1000 simulations.:   0%|          | 0/1000 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Neural network successfully converged after 97 epochs."
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "posterior = infer(linear_gaussian, prior, \"SNPE\", num_simulations=1000)"
    ]
@@ -129,12 +107,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "x_o_1 = torch.zeros(\n",
-    "    3,\n",
-    ")\n",
-    "x_o_2 = 2.0 * torch.ones(\n",
-    "    3,\n",
-    ")"
+    "x_o_1 = torch.zeros(3,)\n",
+    "x_o_2 = 2.0 * torch.ones(3,)"
    ]
   },
   {
diff --git a/tutorials/02_flexible_interface.ipynb b/tutorials/02_flexible_interface.ipynb
index 26a4555ed..fcfba71b9 100644
--- a/tutorials/02_flexible_interface.ipynb
+++ b/tutorials/02_flexible_interface.ipynb
@@ -244,9 +244,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "x_o = torch.zeros(\n",
-    "    3,\n",
-    ")"
+    "x_o = torch.zeros(3,)"
    ]
   },
   {
diff --git a/tutorials/11_sampler_interface.ipynb b/tutorials/11_sampler_interface.ipynb
index b4cb07ffc..cbbe08c3a 100644
--- a/tutorials/11_sampler_interface.ipynb
+++ b/tutorials/11_sampler_interface.ipynb
@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# The sampler interface\n",
+    "# Sampling algorithms in `sbi`\n",
     "\n",
     "Note: this tutorial requires that the user is already familiar with the [flexible interface](https://sbi-dev.github.io/sbi/tutorial/02_flexible_interface/).\n",
     "\n",
@@ -16,14 +16,75 @@
     "\n",
     "- Variational inference (VI)\n",
     "\n",
-    "When using the flexible interface, the sampler as well as its attributes can be set with `sample_with=\"mcmc\"`, `mcmc_method=\"slice_np\"`, and `mcmc_parameters={}`. However, for full flexibility in customizing the sampler, we recommend using the **sampler interface**. This interface is described here. Further details can be found [here](https://github.com/sbi-dev/sbi/pull/573)."
+    "Below, we will demonstrate how these samplers can be used in `sbi`. First, we train the neural network as always:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from sbi.inference import SNLE\n",
+    "\n",
+    "# dummy Gaussian simulator for demonstration\n",
+    "num_dim = 2\n",
+    "prior = torch.distributions.MultivariateNormal(torch.zeros(num_dim), torch.eye(num_dim))\n",
+    "theta = prior.sample((1000,))\n",
+    "x = theta + torch.randn((1000, num_dim))\n",
+    "x_o = torch.randn((1, num_dim))\n",
+    "\n",
+    "inference = SNLE(prior=prior, show_progress_bars=False)\n",
+    "likelihood_estimator = inference.append_simulations(theta, x).train()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Main syntax for SNLE"
+    "And then we pass the options for which sampling method to use to the `build_posterior()` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Sampling with MCMC\n",
+    "sampling_algorithm = \"mcmc\"\n",
+    "mcmc_method = \"slice_np\"  # or nuts, or hmc\n",
+    "posterior = inference.build_posterior(sample_with=sampling_algorithm, mcmc_method=mcmc_method)\n",
+    "\n",
+    "# Sampling with variational inference\n",
+    "sampling_algorithm = \"vi\"\n",
+    "vi_method = \"rKL\"  # or fKL\n",
+    "posterior = inference.build_posterior(sample_with=sampling_algorithm, vi_method=vi_method)\n",
+    "# Unlike other methods, vi needs a training step for every observation.\n",
+    "posterior = posterior.set_default_x(x_o).train()\n",
+    "\n",
+    "# Sampling with rejection sampling\n",
+    "sampling_algorithm = \"rejection\"\n",
+    "posterior = inference.build_posterior(sample_with=sampling_algorithm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# More flexibility in adjusting the sampler\n",
+    "\n",
+    "With the above syntax, you can easily try out different sampling algorithms. However, in many cases, you might want to customize your sampler. Below, we demonstrate how you can change hyperparameters of the samplers (e.g. number of warm-up steps of MCMC) or how you can write your own sampler from scratch."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Main syntax (for SNLE and SNRE)\n",
+    "\n",
+    "As above, we begin by training the neural network as always:"
    ]
   },
   {
@@ -43,7 +104,6 @@
     "import torch\n",
     "\n",
     "from sbi.inference import SNLE\n",
-    "from sbi.inference import likelihood_estimator_based_potential, MCMCPosterior\n",
     "\n",
     "# dummy Gaussian simulator for demonstration\n",
     "num_dim = 2\n",
@@ -53,16 +113,62 @@
     "x_o = torch.randn((1, num_dim))\n",
     "\n",
     "inference = SNLE(show_progress_bars=False)\n",
-    "likelihood_estimator = inference.append_simulations(theta, x).train()\n",
+    "likelihood_estimator = inference.append_simulations(theta, x).train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then, for full flexibility on using the sampler, we do not use the `.build_posterior()` method, but instead we explicitly define the potential function and the sampling algorithm (see below for explanation):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sbi.inference import likelihood_estimator_based_potential, MCMCPosterior\n",
     "\n",
     "potential_fn, parameter_transform = likelihood_estimator_based_potential(\n",
     "    likelihood_estimator, prior, x_o\n",
     ")\n",
     "posterior = MCMCPosterior(\n",
+    "    potential_fn, proposal=prior, theta_transform=parameter_transform, warmup_steps=10\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you want to use variational inference or rejection sampling, you have to replace the last line with `VIPosterior` or `RejectionPosterior`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# For VI, we have to train.\n",
+    "posterior = VIPosterior(\n",
+    "    potential_fn, proposal=prior, theta_transform=parameter_transform\n",
+    ").train()\n",
+    "\n",
+    "posterior = RejectionPosterior(\n",
     "    potential_fn, proposal=prior, theta_transform=parameter_transform\n",
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "At this point, you could also plug the `potential_fn` into any sampler of your choice and not rely on any of the in-built `sbi`-samplers."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/tutorials/14_iid_data_and_permutation_invariant_embeddings.ipynb b/tutorials/14_iid_data_and_permutation_invariant_embeddings.ipynb
index 9099f373e..8126b8bd4 100644
--- a/tutorials/14_iid_data_and_permutation_invariant_embeddings.ipynb
+++ b/tutorials/14_iid_data_and_permutation_invariant_embeddings.ipynb
@@ -7,23 +7,21 @@
     "# SBI with iid data and permutation-invariant embeddings\n",
     "\n",
     "There are scenarios in which we observe multiple data points per experiment and we can assume that they are independent and identically distributed (iid, i.e., they are assumed to have the same underlying model parameters). \n",
-    "For example, in a decision-making experiments, the experiment is often repeated in trials with the same experimental settings and conditions. The corresponding set of trials is then assumed to be \"iid\". \n",
+    "For example, in decision-making experiments, the experiment is often repeated in trials with the same experimental settings and conditions. The corresponding set of trials is then assumed to be \"iid\" given a single parameter set. \n",
     "In such a scenario, we may want to obtain the posterior given a set of observation $p(\\theta | X=\\{x_i\\}_i^N)$. \n",
     "\n",
     "### Amortization of neural network training: iid-inference with NLE / NRE\n",
-    "For some SBI variants the iid assumption can be exploited: when using a likelihood-based SBI method (`SNLE`, `SNRE`) one can train the density or ratio estimator on single-trial data, and then perform inference with `MCMC`. Crucially, because the data is iid and the estimator is trained on single-trial data, one can repeat the inference with a different `x_o` (a different set of trials, or different number of trials) without having to retrain the density estimator. One can interpet this as amortization of the SBI training: we can obtain a neural likelihood, or likelihood-ratio estimate for new `x_o`s without retraining, but we still have to run `MCMC` or `VI` to do inference. \n",
+    "For some SBI variants the iid assumption can be exploited: when using a likelihood-based SBI method (`SNLE`, `SNRE`) one can train the density or ratio estimator on single-trial data, and then perform inference with `MCMC` or variational inference (`VI`). Crucially, because the data is iid and the estimator is trained on single-trial data, one can repeat the inference with a different `x_o` (a different set of trials, or different number of trials) without having to retrain the density estimator. One can interpet this as amortization of the SBI training: we can obtain a neural likelihood, or likelihood-ratio estimate for new `x_o`s without retraining, but we still have to run `MCMC` or `VI` to do inference. \n",
     "\n",
-    "In addition, one can not only change the number of trials of a new `x_o`, but also the entire inference setting. \n",
-    "For example, one can apply hierarchical inference scenarios with changing hierarchical denpendencies between the model parameters--all without having to retrain the density estimator because that is based on estimating single-trail likelihoods.\n",
+    "In addition, one cannot only change the number of trials of a new `x_o`, but also the entire inference setting. \n",
+    "For example, one can apply hierarchical inference with changing hierarchical denpendencies between the model parameters--all without having to retrain the density estimator because it estimates single-trail likelihoods.\n",
     "\n",
     "### Full amortization: iid-inference with NPE and permutation-invariant embedding nets\n",
-    "When performing neural posterior estimation (`SNPE`) we cannot exploit the iid assumption directly because we are learning a density estimator in `theta`. \n",
+    "When performing neural posterior estimation (`SNPE`) we cannot exploit the iid assumption directly. \n",
     "Thus, the underlying neural network takes `x` as input and predicts the parameters of the density estimator. \n",
-    "As a consequence, if `x` is a set of iid observations $X=\\{x_i\\}_i^N$ then the neural network has to be invariant to permutations of this set, i.e., it has to be permutation invariant. \n",
-    "Overall, this means that we _can_ use `SNPE` for inference with iid data, however, we need to provide a corresponding embedding network that handles the iid-data and is permutation invariant. \n",
-    "This will likely require some hyperparameter tuning and more training data for the inference to work accurately. But once we have this, the inference is fully amortized, i.e., we can get new posterior samples basically instantly without retraining and without running `MCMC` or `VI`. \n",
-    "\n",
-    "Let us first have a look how trial-based inference works in `SBI` before we discuss models with \"mixed data types\"."
+    "As a consequence, if `x` is a set of iid observations $X=\\{x_i\\}_i^N$ then the neural network has to be invariant to permutations of this set, i.e., it has to be permutation invariant. In addition, the neural network has to be able to consume a varying number of iid datapoints in order to be amortized over the number of trials.\n",
+    "Therefore, in order to use `SNPE` for inference on iid data, we need to provide a corresponding embedding network that handles the iid-data. \n",
+    "This will likely require some hyperparameter tuning and more training data for inference to work accurately. But once we have this, inference is fully amortized, i.e., we can get new posterior samples almost instantly without retraining and without running `MCMC` or `VI`. "
    ]
   },
   {
@@ -32,10 +30,11 @@
    "source": [
     "## SBI with trial-based data\n",
     "\n",
-    "For illustration we use a simple linear Gaussian simulator, as in previous tutorials. The simulator takes a single parameter (vector), the mean of the Gaussian, and its variance is set to one. \n",
+    "For illustration, we use a simple linear Gaussian simulator, as in previous tutorials. The simulator takes a single parameter (vector) which is the mean of a Gaussian. The simulator then adds noise with a fixed variance (set to one). \n",
     "We define a Gaussian prior over the mean and perform inference. \n",
-    "The observed data is again a from a Gaussian with some fixed \"ground-truth\" parameter $\\theta_o$. \n",
-    "Crucially, the observed data `x_o` can consist of multiple samples given the same ground-truth parameters and these samples are then iid: \n",
+    "\n",
+    "The observed data is also sampled from a Gaussian with some fixed \"ground-truth\" parameter $\\theta_o$. \n",
+    "Crucially, the observed data `x_o` can consist of multiple samples given the same ground-truth parameters and these samples are iid given $\\theta$: \n",
     "\n",
     "$$ \n",
     "\\theta \\sim \\mathcal{N}(\\mu_0,\\; \\Sigma_0) \\\\\n",
@@ -43,7 +42,7 @@
     "\\mathbf{x_o} = \\{x_o^i\\}_{i=1}^N \\sim  \\mathcal{N}(\\theta_o,\\; \\Sigma=I)\n",
     "$$\n",
     "\n",
-    "For this toy problem the ground-truth posterior is well defined, it is again a Gaussian, centered on the mean of $\\mathbf{x_o}$ and with variance scaled by the number of trials $N$, i.e., the more trials we observe, the more information about the underlying $\\theta_o$ we have and the more concentrated the posteriors becomes.\n",
+    "For this toy problem, the ground-truth posterior is well defined, it is again a Gaussian, centered on the mean of $\\mathbf{x_o}$ and with variance scaled by the number of trials $N$, i.e., the more trials we observe, the more information about the underlying $\\theta_o$ we have and the more concentrated the posteriors becomes.\n",
     "\n",
     "We will illustrate this below:"
    ]
@@ -177,9 +176,7 @@
    "source": [
     "## IID inference with NLE\n",
     "\n",
-    "(S)NLE can easily perform inference given multiple IID x because it is based on learning the likelihood. Once the likelihood is learned on single trials, i.e., a neural network that given a single observation and a parameter predicts the likelihood of that observation given the parameter, one can perform MCMC to obtain posterior samples. \n",
-    "\n",
-    "MCMC relies on evaluating ratios of likelihoods of candidate parameters to either accept or reject them to be posterior samples. When inferring the posterior given multiple IID observation, these likelihoods are just the joint likelihoods of each IID observation given the current parameter candidate. Thus, given a neural likelihood from SNLE, we can calculate these joint likelihoods and perform MCMC given IID data, we just have to multiply together (or add in log-space) the individual trial-likelihoods (`sbi` takes care of that)."
+    "(S)NLE and (S)NRE can perform inference given multiple IID obserations by using only single-trial training data (i.e., for training, we run the simulator only once per parameter set). Once the likelihood is learned on single trials (i.e., a neural network that predicts the likelihood of a single observation given a parameter set), one can sample the posterior for any number of trials. This works because, given a single-trial neural likelihood from (S)NLE or (S)NRE, we can calculate the joint likelihoods of all trials by multiplying them together (or adding them in log-space). The joint likelihood can then be plugged into `MCMC` or `VI`. `sbi` takes care of all of these steps, so you do not have to implement anything yourself:"
    ]
   },
   {
@@ -420,13 +417,15 @@
    "source": [
     "## IID inference with NPE using permutation-invariant embedding nets\n",
     "\n",
-    "For NPE we need to define an embedding net that handles the set-like structure of iid-data, i.e., that it permutation invariant and can handle different number of trials. \n",
+    "For NPE we need to define an embedding net that handles the set-like structure of iid-data, i.e., that it permutation invariant and can handle different number of trials.  \n",
     "\n",
     "We implemented several embedding net classes that allow to construct such a permutation- and number-of-trials invariant embedding net. \n",
     "\n",
     "To become permutation invariant, the neural net first learns embeddings for single trials and then performs a permutation invariant operation on those embeddings, e.g., by taking the sum or the mean (Chen et al. 2018, Radev et al. 2021).\n",
     "\n",
-    "To become invariant w.r.t. the number-of-trials, we train the net with varying number of trials for each parameter setting. As it is difficult to handle tensors of varying lengths in the SBI training loop, we construct a training data set in which \"unobserved\" trials are mask by NaNs (and ignore the resulting SBI warning about NaNs in the training data).\n",
+    "To become invariant w.r.t. the number-of-trials, we train the net with varying number of trials for each parameter setting. This means that, unlike for (S)NLE and (S)NRE, (S)NPE requires to run the simulator multiple times for individual parameter sets to generate the training data.\n",
+    "\n",
+    "In order to implement this in `sbi`, \"unobserved\" trials in the training dataset have to be masked by NaNs (and ignore the resulting SBI warning about NaNs in the training data).\n",
     "\n",
     "### Construct training data set."
    ]
diff --git a/tutorials/17_vi_posteriors.ipynb b/tutorials/17_vi_posteriors.ipynb
deleted file mode 100644
index 6cdf94304..000000000
--- a/tutorials/17_vi_posteriors.ipynb
+++ /dev/null
@@ -1,361 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "source": [
-    "# Using Variational Inference for Building Posteriors"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "In the previous tutorial, we saw how to build the posterior and how to specialize on one specific observation `x_o`. If one uses SNPE, then the posterior can be sampled from directly, yet this comes at the expense of necessary correction terms during training, since the samples are obtained from the \"wrong\" prior for `num_rounds > 1`. For SNLE or SNRE, MCMC sampling is required, which is computationally expensive. With SNVI (sequential neural variational inference), it is possible to directly sample from the posterior without any corrections during training or without expensive MCMC for sampling. This is possible by learning the posterior with variational inference techniques. For this, an additional network (one for the likelihood or likelihood-to-evidence-ratio) must be trained first."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "## Main syntax"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "inference = SNLE(prior)\n",
-    "\n",
-    "for _ in range(num_rounds):\n",
-    "    theta, x = simulate_for_sbi(simulator, proposal, num_simulations=500)\n",
-    "\n",
-    "    # In `SNLE` and `SNRE`, you should not pass the `proposal` to `\n",
-    "    # .append_simulations()`.\n",
-    "    likelihood_estimator = inference.append_simulations(\n",
-    "        theta, x,\n",
-    "    ).train()\n",
-    "\n",
-    "    # Obtain potential (learned likelihood * prior) and theta transformation.\n",
-    "    potential_fn, theta_transform = likelihood_estimator_based_potential(\n",
-    "        likelihood_estimator, prior, x_o\n",
-    "    )\n",
-    "\n",
-    "    # Build posterior via variational inference.\n",
-    "    posterior = VIPosterior(\n",
-    "        potential_fn, prior, \"maf\", theta_transform, vi_method=\"fKL\",\n",
-    "    ).train()\n",
-    "    proposal = posterior"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "## Linear Gaussian example"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Below, we give a full example of inferring the posterior distribution with SNVI over multiple rounds. For this, we take the same example as in the previous tutorial."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "\n",
-    "from sbi.inference import (\n",
-    "    likelihood_estimator_based_potential,\n",
-    "    SNLE,\n",
-    "    prepare_for_sbi,\n",
-    "    simulate_for_sbi,\n",
-    "    VIPosterior,\n",
-    ")\n",
-    "from sbi import utils as utils\n",
-    "from sbi import analysis as analysis\n",
-    "\n",
-    "_ = torch.manual_seed(0)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-06-02T18:48:02.227633Z",
-     "end_time": "2023-06-02T18:48:02.229979Z"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "outputs": [],
-   "source": [
-    "num_dim = 3\n",
-    "prior = utils.BoxUniform(low=-2 * torch.ones(num_dim), high=2 * torch.ones(num_dim))"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-06-02T18:48:06.740402Z",
-     "end_time": "2023-06-02T18:48:06.787281Z"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "outputs": [],
-   "source": [
-    "def linear_gaussian(theta):\n",
-    "    return theta + 1.0 + torch.randn_like(theta) * 0.1"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-06-02T18:48:08.596906Z",
-     "end_time": "2023-06-02T18:48:08.600407Z"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "outputs": [],
-   "source": [
-    "simulator, prior = prepare_for_sbi(linear_gaussian, prior)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-06-02T18:48:10.364984Z",
-     "end_time": "2023-06-02T18:48:10.368047Z"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Here, we decide to learn the likelihood directly, but learning the likelihood-to-evidence ratio would also be a viable option."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "outputs": [],
-   "source": [
-    "inference = SNLE(prior=prior)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-06-02T18:48:11.598504Z",
-     "end_time": "2023-06-02T18:48:11.603085Z"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Now we can run inference, where we first learn the likelihood, which is then in turn used to learn a posterior through variational inference."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "Running 500 simulations.:   0%|          | 0/500 [00:00<?, ?it/s]",
-      "application/vnd.jupyter.widget-view+json": {
-       "version_major": 2,
-       "version_minor": 0,
-       "model_id": "782648b65c1c4e9ab4f09617acfa8fab"
-      }
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Neural network successfully converged after 50 epochs."
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "  0%|          | 0/2000 [00:00<?, ?it/s]",
-      "application/vnd.jupyter.widget-view+json": {
-       "version_major": 2,
-       "version_minor": 0,
-       "model_id": "fdf802e069d641c19eb51a7200dc9c0e"
-      }
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Converged with loss: -4.23\n",
-      "Quality Score: -0.218 \t Good: Smaller than 0.5  Bad: Larger than 1.0 \t         NOTE: Less sensitive to mode collapse.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "Running 500 simulations.:   0%|          | 0/500 [00:00<?, ?it/s]",
-      "application/vnd.jupyter.widget-view+json": {
-       "version_major": 2,
-       "version_minor": 0,
-       "model_id": "4bebed20a87e461db83a0fc364902faa"
-      }
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Neural network successfully converged after 47 epochs."
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "  0%|          | 0/2000 [00:00<?, ?it/s]",
-      "application/vnd.jupyter.widget-view+json": {
-       "version_major": 2,
-       "version_minor": 0,
-       "model_id": "a23843b29c1f4cadba0919bd2f635d96"
-      }
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Converged with loss: -4.2\n",
-      "Quality Score: 0.025 \t Good: Smaller than 0.5  Bad: Larger than 1.0 \t         NOTE: Less sensitive to mode collapse.\n"
-     ]
-    }
-   ],
-   "source": [
-    "num_rounds = 2\n",
-    "x_o = torch.zeros(3,)\n",
-    "\n",
-    "posteriors = []\n",
-    "proposal = prior\n",
-    "\n",
-    "for _ in range(num_rounds):\n",
-    "    theta, x = simulate_for_sbi(simulator, proposal, num_simulations=500)\n",
-    "    likelihood_estimator = inference.append_simulations(\n",
-    "        theta, x,\n",
-    "    ).train()\n",
-    "    potential_fn, theta_transform = likelihood_estimator_based_potential(\n",
-    "        likelihood_estimator, prior, x_o\n",
-    "    )\n",
-    "\n",
-    "    posterior = VIPosterior(\n",
-    "        potential_fn, prior, \"maf\", theta_transform, vi_method=\"fKL\",\n",
-    "    ).train()\n",
-    "    posteriors.append(posterior)\n",
-    "    proposal = posterior"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-06-02T18:49:18.959131Z",
-     "end_time": "2023-06-02T18:49:50.587676Z"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "After having learned the posterior, we use `.pairplot()` to visualize the samples from the learned posterior."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "<Figure size 500x500 with 9 Axes>",
-      "image/png": "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"
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "posterior_samples = posterior.sample((10000,), x=x_o)\n",
-    "\n",
-    "# Plot posterior samples.\n",
-    "_ = analysis.pairplot(\n",
-    "    posterior_samples, limits=[[-2, 2], [-2, 2], [-2, 2]], figsize=(5, 5)\n",
-    ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-06-02T18:52:02.958771Z",
-     "end_time": "2023-06-02T18:52:03.456234Z"
-    }
-   }
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 2
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}