diff --git a/bayesflow/networks/__init__.py b/bayesflow/networks/__init__.py
index 858cfbf13..7ae8ff93f 100644
--- a/bayesflow/networks/__init__.py
+++ b/bayesflow/networks/__init__.py
@@ -1,5 +1,5 @@
 from .cif import CIF
-from .consistency_models import ConsistencyModel
+from .consistency_models import ConsistencyModel, ContinuousConsistencyModel
 from .coupling_flow import CouplingFlow
 from .deep_set import DeepSet
 from .flow_matching import FlowMatching
diff --git a/bayesflow/networks/consistency_models/__init__.py b/bayesflow/networks/consistency_models/__init__.py
index b40725ced..33592d62b 100644
--- a/bayesflow/networks/consistency_models/__init__.py
+++ b/bayesflow/networks/consistency_models/__init__.py
@@ -1 +1,2 @@
 from .consistency_model import ConsistencyModel
+from .continuous_consistency_model import ContinuousConsistencyModel
diff --git a/bayesflow/networks/consistency_models/continuous_consistency_model.py b/bayesflow/networks/consistency_models/continuous_consistency_model.py
new file mode 100644
index 000000000..43c11b84b
--- /dev/null
+++ b/bayesflow/networks/consistency_models/continuous_consistency_model.py
@@ -0,0 +1,294 @@
+import keras
+from keras import ops
+from keras.saving import (
+    register_keras_serializable,
+)
+
+import numpy as np
+
+from bayesflow.types import Tensor
+from bayesflow.utils import find_network, keras_kwargs, expand_right_as, expand_right_to
+
+
+from ..inference_network import InferenceNetwork
+from ..embeddings import GaussianFourierEmbedding
+
+
+@register_keras_serializable(package="bayesflow.networks")
+class ContinuousConsistencyModel(InferenceNetwork):
+    """Implements an sCM (simple, stable, and scalable Consistency Model)
+    with continous-time Consistency Training (CT) as described in [1].
+    The sampling procedure is taken from [2].
+
+    [1] Lu, C., & Song, Y. (2024).
+    Simplifying, Stabilizing and Scaling Continuous-Time Consistency Models
+    arXiv preprint arXiv:2410.11081
+
+    [2] Song, Y., Dhariwal, P., Chen, M. & Sutskever, I. (2023).
+    Consistency Models.
+    arXiv preprint arXiv:2303.01469
+    """
+
+    def __init__(
+        self,
+        subnet: str | type = "mlp",
+        sigma_data: float = 1.0,
+        time_emb_dim: int = 20,
+        **kwargs,
+    ):
+        """Creates an instance of an sCM to be used for consistency training (CT).
+
+        Parameters:
+        -----------
+        subnet      : str or type, optional, default: "mlp"
+            A neural network type for the consistency model, will be
+            instantiated using subnet_kwargs.
+        sigma_data      : float, optional, default: 1.0
+            Standard deviation of the target distribution
+        time_emb_dim  : int, optional, default: 20
+            Dimensionality of a time embedding. The embedding will
+            be concatenated to the time, so the total time embedding
+            will have size `time_emb_dim + 1`
+        **kwargs    : dict, optional, default: {}
+            Additional keyword arguments
+        """
+        # Normal is the only supported base distribution for CMs
+        super().__init__(base_distribution="normal", **keras_kwargs(kwargs))
+
+        self.subnet = find_network(subnet, **kwargs.get("subnet_kwargs", {}))
+        self.subnet_projector = keras.layers.Dense(units=None, bias_initializer="zeros", kernel_initializer="zeros")
+
+        self.weight_fn = find_network("mlp", widths=(256,), dropout=0.0)
+        self.weight_fn_projector = keras.layers.Dense(units=1, bias_initializer="zeros", kernel_initializer="zeros")
+
+        self.time_emb_dim = time_emb_dim
+        self.time_emb = GaussianFourierEmbedding(self.time_emb_dim, scale=1.0, include_identity=True)
+
+        self.sigma_data = sigma_data
+
+        self.seed_generator = keras.random.SeedGenerator()
+
+    def _discretize_time(self, num_steps, min_noise=0.001, max_noise=80.0, rho=7.0):
+        """Function for obtaining the discretized time for multi-step sampling
+        according to [2], Section 2, bottom of page 2.
+        Subsequent transformation to time space following [1].
+        """
+
+        N = num_steps + 1
+        indices = ops.arange(1, N + 1, dtype="float32")
+        one_over_rho = 1.0 / rho
+        discretized_time = (
+            min_noise**one_over_rho
+            + (indices - 1.0) / (ops.cast(N, "float32") - 1.0) * (max_noise**one_over_rho - min_noise**one_over_rho)
+        ) ** rho
+        time = ops.arctan(discretized_time / self.sigma_data)
+        return time
+
+    def build(self, xz_shape, conditions_shape=None):
+        super().build(xz_shape)
+        self.subnet_projector.units = xz_shape[-1]
+
+        # construct input shape for subnet and subnet projector
+        input_shape = list(xz_shape)
+
+        # time vector
+        input_shape[-1] += self.time_emb_dim + 1
+
+        if conditions_shape is not None:
+            input_shape[-1] += conditions_shape[-1]
+
+        input_shape = tuple(input_shape)
+
+        self.subnet.build(input_shape)
+
+        input_shape = self.subnet.compute_output_shape(input_shape)
+        self.subnet_projector.build(input_shape)
+
+        # input shape for time embedding
+        self.time_emb.build((xz_shape[0], 1))
+
+        # input shape for weight function and projector
+        input_shape = (xz_shape[0], 1)
+        self.weight_fn.build(input_shape)
+        input_shape = self.weight_fn.compute_output_shape(input_shape)
+        self.weight_fn_projector.build(input_shape)
+
+    def call(
+        self,
+        xz: Tensor,
+        conditions: Tensor = None,
+        inverse: bool = False,
+        **kwargs,
+    ):
+        if inverse:
+            return self._inverse(xz, conditions=conditions, **kwargs)
+        return self._forward(xz, conditions=conditions, **kwargs)
+
+    def _forward(self, x: Tensor, conditions: Tensor = None, **kwargs) -> Tensor:
+        # Consistency Models only learn the direction from noise distribution
+        # to target distribution, so we cannot implement this function.
+        raise NotImplementedError("Consistency Models are not invertible")
+
+    def _inverse(self, z: Tensor, conditions: Tensor = None, **kwargs) -> Tensor:
+        """Generate random draws from the approximate target distribution
+        using the multistep sampling algorithm from [2], Algorithm 1.
+
+        Parameters
+        ----------
+        z           : Tensor
+            Samples from a standard normal distribution
+        conditions  : Tensor, optional, default: None
+            Conditions for a approximate conditional distribution
+        **kwargs    : dict, optional, default: {}
+            Additional keyword arguments. Include `steps` (default: 30) to
+            adjust the number of sampling steps.
+
+        Returns
+        -------
+        x            : Tensor
+            The approximate samples
+        """
+        steps = kwargs.get("steps", 30)
+        max_noise = kwargs.get("max_noise", 80.0)
+        min_noise = kwargs.get("min_noise", 1e-4)
+        rho = kwargs.get("rho", 7.0)
+
+        # noise distribution has variance sigma_data
+        x = keras.ops.copy(z) * self.sigma_data
+        discretized_time = keras.ops.flip(
+            self._discretize_time(steps, max_noise=max_noise, min_noise=min_noise, rho=rho), axis=-1
+        )
+        t = keras.ops.full((*keras.ops.shape(x)[:-1], 1), np.pi / 2, dtype=x.dtype)
+        x = self.consistency_function(x, t, conditions=conditions)
+        for n in range(1, steps):
+            noise = keras.random.normal(keras.ops.shape(x), dtype=keras.ops.dtype(x), seed=self.seed_generator)
+            x_n = ops.cos(t) * x + ops.sin(t) * noise
+            t = keras.ops.full_like(t, discretized_time[n])
+            x = self.consistency_function(x_n, t, conditions=conditions)
+        return x
+
+    def consistency_function(self, x: Tensor, t: Tensor, conditions: Tensor = None, **kwargs) -> Tensor:
+        """Compute consistency function.
+
+        Parameters
+        ----------
+        x           : Tensor
+            Input vector
+        t           : Tensor
+            Vector of time samples in [0, pi/2]
+        conditions  : Tensor
+            The conditioning vector
+        **kwargs    : dict, optional, default: {}
+            Additional keyword arguments passed to the network.
+        """
+
+        if conditions is not None:
+            xtc = ops.concatenate([x / self.sigma_data, self.time_emb(t), conditions], axis=-1)
+        else:
+            xtc = ops.concatenate([x / self.sigma_data, self.time_emb(t)], axis=-1)
+
+        f = self.subnet_projector(self.subnet(xtc, **kwargs))
+
+        out = ops.cos(t) * x - ops.sin(t) * self.sigma_data * f
+        return out
+
+    def compute_metrics(self, x: Tensor, conditions: Tensor = None, stage: str = "training") -> dict[str, Tensor]:
+        base_metrics = super().compute_metrics(x, conditions=conditions, stage=stage)
+
+        # $# Implements Algorithm 1 from [1]
+
+        # training parameters
+        p_mean = -1.0
+        p_std = 1.6
+
+        c = 0.1
+
+        # generate noise vector
+        z = (
+            keras.random.normal(keras.ops.shape(x), dtype=keras.ops.dtype(x), seed=self.seed_generator)
+            * self.sigma_data
+        )
+
+        # sample time
+        tau = (
+            keras.random.normal(keras.ops.shape(x)[:1], dtype=keras.ops.dtype(x), seed=self.seed_generator) * p_std
+            + p_mean
+        )
+        t_ = ops.arctan(ops.exp(tau) / self.sigma_data)
+        t = expand_right_as(t_, x)
+
+        # generate noisy sample
+        xt = ops.cos(t) * x + ops.sin(t) * z
+
+        # calculate estimator for dx_t/dt
+        dxtdt = ops.cos(t) * z - ops.sin(t) * x
+
+        r = 1.0  # TODO: if consistency distillation training (not supported yet) is unstable, add schedule here
+
+        # calculate rearranged JVP
+        if conditions is not None:
+
+            def f_teacher(x, t):
+                return self.subnet_projector(self.subnet(ops.concatenate([x, self.time_emb(t), conditions], axis=-1)))
+        else:
+
+            def f_teacher(x, t):
+                return self.subnet_projector(self.subnet(ops.concatenate([x, self.time_emb(t)], axis=-1)))
+
+        primals = (xt / self.sigma_data, t)
+        tangents = (
+            ops.cos(t) * ops.sin(t) * dxtdt,
+            ops.cos(t) * ops.sin(t) * self.sigma_data,
+        )
+        match keras.backend.backend():
+            case "torch":
+                import torch
+
+                teacher_output, cos_sin_dFdt = torch.autograd.functional.jvp(f_teacher, primals, tangents)
+            case "tensorflow":
+                import tensorflow as tf
+
+                with tf.autodiff.ForwardAccumulator(primals=primals, tangents=tangents) as acc:
+                    teacher_output = f_teacher(xt / self.sigma_data, t)
+                cos_sin_dFdt = acc.jvp(teacher_output)
+            case "jax":
+                import jax
+
+                teacher_output, cos_sin_dFdt = jax.jvp(
+                    f_teacher,
+                    primals,
+                    tangents,
+                )
+            case _:
+                raise NotImplementedError(f"JVP not implemented for backend {keras.backend.backend()}")
+        teacher_output = ops.stop_gradient(teacher_output)
+        cos_sin_dFdt = ops.stop_gradient(cos_sin_dFdt)
+
+        # calculate output of the network
+        if conditions is not None:
+            xtc = ops.concatenate([xt / self.sigma_data, self.time_emb(t), conditions], axis=-1)
+        else:
+            xtc = ops.concatenate([xt / self.sigma_data, self.time_emb(t)], axis=-1)
+        student_out = self.subnet_projector(self.subnet(xtc, training=stage == "training"))
+
+        # calculate the tangent
+        g = -(ops.cos(t) ** 2) * (self.sigma_data * teacher_output - dxtdt) - r * ops.cos(t) * ops.sin(t) * (
+            xt + self.sigma_data * cos_sin_dFdt
+        )
+
+        # apply normalization to stabilize training
+        g = g / (ops.norm(g, axis=-1, keepdims=True) + c)
+
+        # compute adaptive weights
+        w = self.weight_fn_projector(self.weight_fn(expand_right_to(t_, 2)))
+        # calculate loss
+        D = ops.shape(x)[-1]
+        loss = ops.mean(
+            (ops.exp(w) / D)
+            * ops.mean(
+                ops.reshape(((student_out - teacher_output - g) ** 2), (ops.shape(teacher_output)[0], -1)), axis=-1
+            )
+            - w
+        )
+
+        return base_metrics | {"loss": loss}
diff --git a/bayesflow/networks/embeddings/__init__.py b/bayesflow/networks/embeddings/__init__.py
new file mode 100644
index 000000000..f833f2ddd
--- /dev/null
+++ b/bayesflow/networks/embeddings/__init__.py
@@ -0,0 +1 @@
+from .time_embeddings import GaussianFourierEmbedding
diff --git a/bayesflow/networks/embeddings/time_embeddings.py b/bayesflow/networks/embeddings/time_embeddings.py
new file mode 100644
index 000000000..ff0cf71a8
--- /dev/null
+++ b/bayesflow/networks/embeddings/time_embeddings.py
@@ -0,0 +1,45 @@
+import keras
+from keras import ops
+
+import numpy as np
+
+
+class GaussianFourierEmbedding(keras.layers.Layer):
+    """Fourier projection with normally distributed frequencies"""
+
+    def __init__(self, fourier_emb_dim, scale=1.0, include_identity=True):
+        """Create an instance of a fourier projection with normally
+        distributed frequencies.
+        Parameters:
+        -----------
+        fourier_emb_dim   : int (even)
+            Dimensionality of the fourier projection. The complete embedding has
+            dimensionality `fourier_embed_dim + 1` if the identity mapping is
+            added as well.
+
+        """
+        super().__init__()
+        assert fourier_emb_dim % 2 == 0, f"Embedding dimension must be even, was {fourier_emb_dim}."
+        self.w = self.add_weight(initializer="random_normal", shape=(fourier_emb_dim // 2,), trainable=False)
+        self.scale = scale
+        self.include_identity = include_identity
+
+    def call(self, t):
+        """
+        Parameters:
+        -----------
+        t   : Tensor of shape (batch_size, 1)
+            vector of times
+
+        Returns:
+        --------
+        emb : Tensor
+            Embedding of shape (batch_size, fourier_emb_dim) if `include_identity`
+            is False, else (batch_size, fourier_emb_dim+1)
+        """
+        proj = t * self.w[None, :] * 2 * np.pi * self.scale
+        if self.include_identity:
+            emb = ops.concatenate([t, ops.sin(proj), ops.cos(proj)], axis=-1)
+        else:
+            emb = ops.concatenate([ops.sin(proj), ops.cos(proj)], axis=-1)
+        return emb
diff --git a/examples/Continuous_Consistency_Model_Playground.ipynb b/examples/Continuous_Consistency_Model_Playground.ipynb
new file mode 100644
index 000000000..879f6186c
--- /dev/null
+++ b/examples/Continuous_Consistency_Model_Playground.ipynb
@@ -0,0 +1,618 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d5f88a59",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-24T08:36:22.149034Z",
+     "start_time": "2024-10-24T08:36:20.807192Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "\n",
+    "# Ensure the backend is set\n",
+    "import os\n",
+    "if \"KERAS_BACKEND\" not in os.environ:\n",
+    "    # set this to \"torch\", \"tensorflow\", or \"jax\"\n",
+    "    os.environ[\"KERAS_BACKEND\"] = \"jax\"\n",
+    "\n",
+    "import keras\n",
+    "\n",
+    "# For BayesFlow devs: this ensures that the latest dev version can be found\n",
+    "import sys\n",
+    "sys.path.append('../')\n",
+    "\n",
+    "import bayesflow as bf"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "315dcf39-c29f-40dc-ad52-69252f9514e4",
+   "metadata": {},
+   "source": [
+    "This notebook serves as a playground for testing continuous-time consistency models. Later on, it will probably evolve into a full tutorial notebook. For now, please refer to the starter notebook if you encounter concepts that are not explained."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2425f2a2-5aec-4eca-882e-4d93bc82a80c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "simulator = bf.simulators.TwoMoons()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6e1eb5777c59eba",
+   "metadata": {},
+   "source": [
+    "Let's generate some data to see what the simulator does:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "e6218e61d529e357",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-24T08:36:22.350483Z",
+     "start_time": "2024-10-24T08:36:22.345161Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# generate 3 random draws from the joint distribution p(r, alpha, theta, x)\n",
+    "sample_data = simulator.sample((20,))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "46174ccb0167026c",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-24T08:36:22.470435Z",
+     "start_time": "2024-10-24T08:36:22.464836Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Type of sample_data:\n",
+      "\t <class 'dict'>\n",
+      "Keys of sample_data:\n",
+      "\t dict_keys(['r', 'alpha', 'theta', 'x'])\n",
+      "Types of sample_data values:\n",
+      "\t {'r': <class 'numpy.ndarray'>, 'alpha': <class 'numpy.ndarray'>, 'theta': <class 'numpy.ndarray'>, 'x': <class 'numpy.ndarray'>}\n",
+      "Shapes of sample_data values:\n",
+      "\t {'r': (20, 1), 'alpha': (20, 1), 'theta': (20, 2), 'x': (20, 2)}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Type of sample_data:\\n\\t\", type(sample_data))\n",
+    "print(\"Keys of sample_data:\\n\\t\", sample_data.keys())\n",
+    "print(\"Types of sample_data values:\\n\\t\", {k: type(v) for k, v in sample_data.items()})\n",
+    "print(\"Shapes of sample_data values:\\n\\t\", {k: v.shape for k, v in sample_data.items()})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "5c9c2dc70f53d103",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-24T08:36:26.618926Z",
+     "start_time": "2024-10-24T08:36:26.614443Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Adapter([Keep(['theta', 'x']) -> ToArray -> ConvertDType -> Standardize -> Rename('theta' -> 'inference_variables') -> Rename('x' -> 'inference_conditions')])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adapter = (\n",
+    "    bf.adapters.Adapter()\n",
+    "\n",
+    "    # drop data that we do not need\n",
+    "    .keep((\"theta\", \"x\"))\n",
+    "    \n",
+    "    # convert any non-arrays to numpy arrays\n",
+    "    .to_array()\n",
+    "    \n",
+    "    # convert from numpy's default float64 to deep learning friendly float32\n",
+    "    .convert_dtype(\"float64\", \"float32\")\n",
+    "    \n",
+    "    # standardize all variables to zero mean and unit variance\n",
+    "    .standardize(momentum=None)  # standardization with momentum is currently not working\n",
+    "    \n",
+    "    # rename the variables to match the required approximator inputs\n",
+    "    .rename(\"theta\", \"inference_variables\")\n",
+    "    .rename(\"x\", \"inference_conditions\")\n",
+    ")\n",
+    "adapter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "254e287b2bccdad",
+   "metadata": {},
+   "source": [
+    "## Dataset\n",
+    "\n",
+    "For this example, we will sample our training data ahead of time and use offline training with a `bf.datasets.OfflineDataset`.\n",
+    "\n",
+    "This makes the training process faster, since we avoid repeated sampling. If you want to use online training, you can use an `OnlineDataset` analogously, or just pass your simulator directly to `approximator.fit()`!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "39cb5a1c9824246f",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-09-23T14:39:46.950573Z",
+     "start_time": "2024-09-23T14:39:46.948624Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "num_training_batches = 512\n",
+    "num_validation_batches = 128\n",
+    "batch_size = 64\n",
+    "epochs = 30\n",
+    "total_steps = num_training_batches * epochs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9dee7252ef99affa",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-09-23T14:39:53.268860Z",
+     "start_time": "2024-09-23T14:39:46.994697Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "training_samples = simulator.sample((num_training_batches * batch_size,))\n",
+    "validation_samples = simulator.sample((num_validation_batches * batch_size,))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "51045bbed88cb5c2",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-09-23T14:39:53.281170Z",
+     "start_time": "2024-09-23T14:39:53.275921Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "training_dataset = bf.datasets.OfflineDataset(\n",
+    "    data=training_samples, \n",
+    "    batch_size=batch_size, \n",
+    "    adapter=adapter\n",
+    ")\n",
+    "\n",
+    "validation_dataset = bf.datasets.OfflineDataset(\n",
+    "    data=validation_samples, \n",
+    "    batch_size=batch_size, \n",
+    "    adapter=adapter\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d4c6eb0",
+   "metadata": {},
+   "source": [
+    "## Training a neural network to approximate all posteriors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "09206e6f",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-09-23T14:39:53.339590Z",
+     "start_time": "2024-09-23T14:39:53.319852Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "inference_network = bf.networks.ContinuousConsistencyModel(\n",
+    "    subnet=\"mlp\",\n",
+    "    sigma_data=1.0,  # as we have standardized our parameters, the standard deviation is 1.0\n",
+    "    time_emb_dim=2,  # it is unclear whether the time embedding is necessary for smaller problems, here we include it\n",
+    "    subnet_kwargs={\"widths\": (256,)*6, \"dropout\": 0.0, } # use an inner network with 6 hidden layers of 256 units\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "851e522f",
+   "metadata": {},
+   "source": [
+    "This inference network is just a general Flow Matching backbone, not yet adapted to the specific inference task at hand (i.e., posterior appproximation). To achieve this adaptation, we combine the network with our data adapter, which together form an `approximator`. In this case, we need a `ContinuousApproximator` since the target we want to approximate is the posterior of the *continuous* parameter vector $\\theta$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "96ca6ffa",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-09-23T14:39:53.371691Z",
+     "start_time": "2024-09-23T14:39:53.369375Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "cm_approximator = bf.ContinuousApproximator(\n",
+    "    inference_network=inference_network,\n",
+    "    adapter=adapter,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "566264eadc76c2c",
+   "metadata": {},
+   "source": [
+    "### Optimizer and Learning Rate\n",
+    "We find learning rate schedules, such as [cosine decay](https://keras.io/api/optimizers/learning_rate_schedules/cosine_decay/), work well for a wide variety of approximation tasks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e8d7e053",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-09-23T14:39:53.433012Z",
+     "start_time": "2024-09-23T14:39:53.415903Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "initial_learning_rate = 5e-4\n",
+    "scheduled_lr = keras.optimizers.schedules.CosineDecay(\n",
+    "    initial_learning_rate=initial_learning_rate,\n",
+    "    decay_steps=total_steps,\n",
+    "    alpha=1e-8\n",
+    ")\n",
+    "\n",
+    "optimizer = keras.optimizers.Adam(learning_rate=scheduled_lr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "51808fcd560489ac",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-09-23T14:39:53.476089Z",
+     "start_time": "2024-09-23T14:39:53.466001Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "cm_approximator.compile(optimizer=optimizer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "708b1303",
+   "metadata": {},
+   "source": [
+    "### Training\n",
+    "\n",
+    "We are ready to train our deep posterior approximator on the two moons example. We pass the dataset object to the `fit` method and watch as Bayesflow trains."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "0f496bda",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-09-23T14:42:36.067393Z",
+     "start_time": "2024-09-23T14:39:53.513436Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:bayesflow:Fitting on dataset instance of OfflineDataset.\n",
+      "INFO:bayesflow:Building on a test batch.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/30\n",
+      "512/512 - 4s - 7ms/step - loss: -1.0279e+00 - loss/inference_loss: -1.0279e+00 - val_loss: -9.6216e-01 - val_loss/inference_loss: -9.6216e-01\n",
+      "Epoch 2/30\n",
+      "512/512 - 3s - 5ms/step - loss: -9.7354e-01 - loss/inference_loss: -9.7354e-01 - val_loss: -9.5650e-01 - val_loss/inference_loss: -9.5650e-01\n",
+      "Epoch 3/30\n",
+      "512/512 - 3s - 5ms/step - loss: -9.4395e-01 - loss/inference_loss: -9.4395e-01 - val_loss: -9.3536e-01 - val_loss/inference_loss: -9.3536e-01\n",
+      "Epoch 4/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.0092e+00 - loss/inference_loss: -1.0092e+00 - val_loss: -1.0678e+00 - val_loss/inference_loss: -1.0678e+00\n",
+      "Epoch 5/30\n",
+      "512/512 - 3s - 5ms/step - loss: -1.1402e+00 - loss/inference_loss: -1.1402e+00 - val_loss: -1.0080e+00 - val_loss/inference_loss: -1.0080e+00\n",
+      "Epoch 6/30\n",
+      "512/512 - 3s - 5ms/step - loss: -1.0724e+00 - loss/inference_loss: -1.0724e+00 - val_loss: -1.0851e+00 - val_loss/inference_loss: -1.0851e+00\n",
+      "Epoch 7/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.0140e+00 - loss/inference_loss: -1.0140e+00 - val_loss: -9.9220e-01 - val_loss/inference_loss: -9.9220e-01\n",
+      "Epoch 8/30\n",
+      "512/512 - 4s - 7ms/step - loss: -1.0621e+00 - loss/inference_loss: -1.0621e+00 - val_loss: -1.0030e+00 - val_loss/inference_loss: -1.0030e+00\n",
+      "Epoch 9/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.0857e+00 - loss/inference_loss: -1.0857e+00 - val_loss: -1.1162e+00 - val_loss/inference_loss: -1.1162e+00\n",
+      "Epoch 10/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.1778e+00 - loss/inference_loss: -1.1778e+00 - val_loss: -1.0207e+00 - val_loss/inference_loss: -1.0207e+00\n",
+      "Epoch 11/30\n",
+      "512/512 - 3s - 7ms/step - loss: -1.0808e+00 - loss/inference_loss: -1.0808e+00 - val_loss: -1.0699e+00 - val_loss/inference_loss: -1.0699e+00\n",
+      "Epoch 12/30\n",
+      "512/512 - 3s - 7ms/step - loss: -1.1341e+00 - loss/inference_loss: -1.1341e+00 - val_loss: -1.0815e+00 - val_loss/inference_loss: -1.0815e+00\n",
+      "Epoch 13/30\n",
+      "512/512 - 4s - 7ms/step - loss: -1.1515e+00 - loss/inference_loss: -1.1515e+00 - val_loss: -1.0921e+00 - val_loss/inference_loss: -1.0921e+00\n",
+      "Epoch 14/30\n",
+      "512/512 - 3s - 7ms/step - loss: -1.1115e+00 - loss/inference_loss: -1.1115e+00 - val_loss: -1.1272e+00 - val_loss/inference_loss: -1.1272e+00\n",
+      "Epoch 15/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.1285e+00 - loss/inference_loss: -1.1285e+00 - val_loss: -1.0442e+00 - val_loss/inference_loss: -1.0442e+00\n",
+      "Epoch 16/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.0617e+00 - loss/inference_loss: -1.0617e+00 - val_loss: -1.0296e+00 - val_loss/inference_loss: -1.0296e+00\n",
+      "Epoch 17/30\n",
+      "512/512 - 4s - 7ms/step - loss: -1.1782e+00 - loss/inference_loss: -1.1782e+00 - val_loss: -1.2119e+00 - val_loss/inference_loss: -1.2119e+00\n",
+      "Epoch 18/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.0224e+00 - loss/inference_loss: -1.0224e+00 - val_loss: -9.9562e-01 - val_loss/inference_loss: -9.9562e-01\n",
+      "Epoch 19/30\n",
+      "512/512 - 3s - 6ms/step - loss: -9.1202e-01 - loss/inference_loss: -9.1202e-01 - val_loss: -1.1774e+00 - val_loss/inference_loss: -1.1774e+00\n",
+      "Epoch 20/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.1323e+00 - loss/inference_loss: -1.1323e+00 - val_loss: -1.1545e+00 - val_loss/inference_loss: -1.1545e+00\n",
+      "Epoch 21/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.0544e+00 - loss/inference_loss: -1.0544e+00 - val_loss: -1.0233e+00 - val_loss/inference_loss: -1.0233e+00\n",
+      "Epoch 22/30\n",
+      "512/512 - 3s - 5ms/step - loss: -1.1578e+00 - loss/inference_loss: -1.1578e+00 - val_loss: -1.0618e+00 - val_loss/inference_loss: -1.0618e+00\n",
+      "Epoch 23/30\n",
+      "512/512 - 3s - 5ms/step - loss: -1.1281e+00 - loss/inference_loss: -1.1281e+00 - val_loss: -1.1387e+00 - val_loss/inference_loss: -1.1387e+00\n",
+      "Epoch 24/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.0522e+00 - loss/inference_loss: -1.0522e+00 - val_loss: -1.1058e+00 - val_loss/inference_loss: -1.1058e+00\n",
+      "Epoch 25/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.1983e+00 - loss/inference_loss: -1.1983e+00 - val_loss: -1.1391e+00 - val_loss/inference_loss: -1.1391e+00\n",
+      "Epoch 26/30\n",
+      "512/512 - 3s - 6ms/step - loss: -1.0646e+00 - loss/inference_loss: -1.0646e+00 - val_loss: -1.0889e+00 - val_loss/inference_loss: -1.0889e+00\n",
+      "Epoch 27/30\n",
+      "512/512 - 3s - 7ms/step - loss: -1.1386e+00 - loss/inference_loss: -1.1386e+00 - val_loss: -1.0125e+00 - val_loss/inference_loss: -1.0125e+00\n",
+      "Epoch 28/30\n",
+      "512/512 - 3s - 5ms/step - loss: -1.0298e+00 - loss/inference_loss: -1.0298e+00 - val_loss: -9.9288e-01 - val_loss/inference_loss: -9.9288e-01\n",
+      "Epoch 29/30\n",
+      "512/512 - 3s - 5ms/step - loss: -1.1113e+00 - loss/inference_loss: -1.1113e+00 - val_loss: -1.1550e+00 - val_loss/inference_loss: -1.1550e+00\n",
+      "Epoch 30/30\n",
+      "512/512 - 3s - 5ms/step - loss: -1.1117e+00 - loss/inference_loss: -1.1117e+00 - val_loss: -1.2102e+00 - val_loss/inference_loss: -1.2102e+00\n",
+      "CPU times: user 3min 15s, sys: 12.9 s, total: 3min 28s\n",
+      "Wall time: 1min 32s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "fm_history = cm_approximator.fit(\n",
+    "    epochs=epochs,\n",
+    "    dataset=training_dataset,\n",
+    "    validation_data=validation_dataset,\n",
+    "    verbose=2,  # set verbose=2 to avoid flooding the notebook\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4785f35-794e-40c7-b863-f5100a90ef13",
+   "metadata": {},
+   "source": [
+    "Note that after a certain time, the loss is no longer indicative of training performance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "209e4bbd-9d4e-4639-82b7-0e974f7258ca",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Set the number of posterior draws you want to get\n",
+    "num_samples = 3000\n",
+    "\n",
+    "# Obtain samples from amortized posterior\n",
+    "\n",
+    "# conditions = {\"x\": np.array([[0.0, 0.0]]).astype(\"float32\")}\n",
+    "# samples_0 = cm_approximator.sample(conditions=conditions, batch_size=1, num_samples=num_samples)[\"theta\"][0]\n",
+    "\n",
+    "# manually sample using _inverse to have access to sampling parameters\n",
+    "# (will not be necessary anymore when .sample forwards those arguments.\n",
+    "# Take care to correctly apply the data adapter.\n",
+    "samples_0 = adapter.inverse({\n",
+    "    \"inference_variables\": keras.ops.convert_to_numpy(\n",
+    "        cm_approximator.inference_network._inverse(\n",
+    "            keras.random.normal((num_samples, 2)),\n",
+    "            conditions=adapter.forward({\"x\": np.zeros((num_samples, 2))}, strict=False)[\"inference_conditions\"],\n",
+    "            steps=30, max_noise=10.0, rho=7.0)\n",
+    "    ),\n",
+    "}, strict=False)[\"theta\"]\n",
+    "\n",
+    "# Prepare figure\n",
+    "f, axes = plt.subplots(1, 2, figsize=(12, 6))\n",
+    "\n",
+    "# Plot samples (once without limits to see outliers/problems\n",
+    "samples = [samples_0, samples_0]\n",
+    "names = [\"Continuous-time CM\", \"Without Axis Limits\"]\n",
+    "colors = [\"#153c7a\", \"#7a1515\"]\n",
+    "\n",
+    "for ax, thetas, name, color in zip(axes, samples, names, colors):\n",
+    "\n",
+    "    # Plot samples\n",
+    "    ax.scatter(thetas[:, 0], thetas[:, 1], color=color, alpha=0.75, s=0.5)\n",
+    "    sns.despine(ax=ax)\n",
+    "    ax.set_title(f\"{name}\", fontsize=16)\n",
+    "    ax.grid(alpha=0.3)\n",
+    "    ax.set_aspect(\"equal\", adjustable=\"box\")\n",
+    "    if not name.lower().startswith(\"without\"):\n",
+    "        ax.set_xlim([-0.5, 0.5])\n",
+    "        ax.set_ylim([-0.5, 0.5])\n",
+    "    ax.set_xlabel(r\"$\\theta_1$\", fontsize=15)\n",
+    "    ax.set_ylabel(r\"$\\theta_2$\", fontsize=15)\n",
+    "\n",
+    "f.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f8532f2-bbe1-4690-b74f-285d94960ab5",
+   "metadata": {},
+   "source": [
+    "Plot the time embedding:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "ffbecec3-b297-48db-b99d-9095b3e9f7a9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "t = keras.ops.linspace(0.001, np.pi/2, 500)[:, None]\n",
+    "emb = inference_network.time_emb(t)\n",
+    "plt.plot(keras.ops.convert_to_numpy(t)[:,0], keras.ops.convert_to_numpy(emb))\n",
+    "plt.ylabel(\"emb(t)\")\n",
+    "plt.xlabel(\"t\")\n",
+    "plt.xticks([0.0, np.pi/4, np.pi/2], labels=[\"0\", \"$\\pi/4$\", \"$\\pi/2$\"])\n",
+    "_ = plt.title(\"Time embedding\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "acce03bb-a802-40a9-ab4f-4a2c3cc0f3de",
+   "metadata": {},
+   "source": [
+    "Plot the learned adaptive weighting function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "e233f634-3f34-4f0e-baa8-6204f41de971",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(t, inference_network.weight_fn_projector(inference_network.weight_fn(t)))\n",
+    "plt.plot(t, 1/(inference_network.sigma_data*np.tan(t)))\n",
+    "plt.plot(t, inference_network.weight_fn_projector(inference_network.weight_fn(t))/(inference_network.sigma_data*np.tan(t)))\n",
+    "plt.ylabel(\"$w_\\phi(t)$\")\n",
+    "plt.xlabel(\"t\")\n",
+    "plt.yscale(\"log\")\n",
+    "plt.xticks([0.0, np.pi/4, np.pi/2], labels=[\"0\", \"$\\pi/4$\", \"$\\pi/2$\"])\n",
+    "_ = plt.title(\"Learned adaptive weighting function\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.10"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": true,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": true,
+   "toc_position": {
+    "height": "calc(100% - 180px)",
+    "left": "10px",
+    "top": "150px",
+    "width": "165px"
+   },
+   "toc_section_display": true,
+   "toc_window_display": true
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}