example/1_minimal_code_example.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "  from utils import install_packages\n",
    "except:\n",
    "  # Colab\n",
    "  !git clone https://github.com/mackelab/simformer.git\n",
    "  from simformer.example.utils import install_packages\n",
    "  from google.colab import output\n",
    "  output.enable_custom_widget_manager()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This can run for 4 min if nothing is installed/has to be down/upgraded\n",
    "install_packages() # install required packages if necessary, might requires restarting the kernel/colab runtime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NVIDIA GeForce RTX 3050 Laptop GPU\n"
     ]
    }
   ],
   "source": [
    "import jax\n",
    "import jax.numpy as jnp\n",
    "import jax.random as jrandom\n",
    "from jax.random import PRNGKey\n",
    "from jax import Array\n",
    "import os\n",
    "jax.devices() # Should be cuda\n",
    "_ = os.system(\"nvidia-smi  --query-gpu=name --format=csv,noheader\") # Should show GPU info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "\n",
    "from functools import partial\n",
    "from typing import Tuple, List, Optional\n",
    "\n",
    "import haiku as hk # Neural network library\n",
    "import optax # Gradient-based optimization in JAX\n",
    "\n",
    "# Some small helper functions\n",
    "from probjax.nn.transformers import Transformer\n",
    "from probjax.nn.helpers import GaussianFourierEmbedding\n",
    "from probjax.nn.loss_fn import denoising_score_matching_loss\n",
    "from probjax.distributions.sde import VESDE\n",
    "from probjax.distributions import Empirical, Independent\n",
    "\n",
    "from scoresbibm.utils.plot import use_style\n",
    "\n",
    "from sbi.analysis import pairplot\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set random key\n",
    "key = jax.random.PRNGKey(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 1) Setting up a toy problem\n",
    "\n",
    "This is a simple toy problem to test the functionality of the `Simformer` method.\n",
    "$$ \\theta \\sim \\mathcal{N}(\\theta; 0, 3^2) \\qquad \\qquad  x_1 \\sim \\mathcal{N}(x_1; 2\\cdot\\sin(\\theta), 0.5^2)  \\qquad \\qquad   x_2 \\sim \\mathcal{N}(x_2;0.1\\cdot \\theta^2,  (0.5\\cdot |x_1|)^2)$$\n",
    "\n",
    "Here we have 3 nonlinear related Gaussian variables. The associated joint distirbution is visualized below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def generate_data(key: PRNGKey, n:int):\n",
    "    key1, key2, key3 = jrandom.split(key,3)\n",
    "    theta1 = jrandom.normal(key1, (n, 1))  * 3 # Some prior on a parameter\n",
    "    x1 = 2*jnp.sin(theta1) + jrandom.normal(key2, (n, 1)) * 0.5 # Some data generated from the parameter \n",
    "    x2 = 0.1*theta1**2 + 0.5*jnp.abs(x1)*jrandom.normal(key3, (n, 1)) # Some data generated from the parameter\n",
    "    return jnp.concatenate([theta1,x1, x2], axis=1).reshape(n, -1, 1)\n",
    "\n",
    "def log_potential(theta1: Array, x1: Array, x2: Array, sigma_x1:float=0.5, sigma_x2:float=0.5, mean_loc:float=0.0, mean_scale:float=3.0 ):\n",
    "    log_prob_theta = jax.scipy.stats.norm.logpdf(theta1, mean_loc, mean_scale)\n",
    "    if x1 is not None:\n",
    "        log_prob_x1 = jax.scipy.stats.norm.logpdf(x1, 2*jnp.sin(theta1), sigma_x1)\n",
    "    else:\n",
    "        log_prob_x1 = 0\n",
    "    if x2 is not None:\n",
    "        log_prob_x2 = jax.scipy.stats.norm.logpdf(x2, 0.1*theta1**2,  sigma_x2*jnp.abs(x1))\n",
    "    else:\n",
    "        log_prob_x2 = 0\n",
    "    \n",
    "    return log_prob_theta + log_prob_x1 + log_prob_x2\n",
    "    \n",
    "\n",
    "data = generate_data(jrandom.PRNGKey(1), 10000)  # Shape: (n, nodes, dim) here dim = 1\n",
    "nodes_max = data.shape[1]\n",
    "node_ids = jnp.arange(nodes_max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hideCode": true,
    "hidePrompt": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = pairplot(np.array(data[...,0]), labels=[\"theta\", \"x1\", \"x2\"], figsize=(5,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 2) Setting up the diffusion process\n",
    "\n",
    "We will use the VESDE i.e. the variance exploding stochastic differential equation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "# VESDE \n",
    "T = 1.\n",
    "T_min = 1e-2\n",
    "sigma_min = 1e-3\n",
    "sigma_max = 15.\n",
    "\n",
    "p0 = Independent(Empirical(data), 1) # Empirical distribution of the data\n",
    "sde = VESDE(p0, sigma_min=sigma_min , sigma_max=sigma_max)\n",
    "\n",
    "# Scaling fn for the output of the score model\n",
    "def output_scale_fn(t, x):\n",
    "    scale = jnp.clip(sde.marginal_stddev(t, jnp.ones_like(x)), 1e-2, None)\n",
    "    return (1/scale * x).reshape(x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3) Building the Simformer\n",
    "\n",
    "This can be divided into two parts, each offering various choices:\n",
    "\n",
    "* **Tokenizer**: \n",
    "This component jointly embeds 'x', 'node_ids', and the 'condition_mask' into a unified \n",
    "vector known as a token.\n",
    "    * **Value Embedding**: Embeds the value of the variable.\n",
    "    * **Node Embedding**: Embeds the node ID.\n",
    "    * **Condition Embedding**: Embeds the condition mask.\n",
    "* **Transformer**: This is a transformer model that takes tokens as input and generates scores for each node.\n",
    "    * **Num_heads**: Specifies the number of heads in the multi-head attention mechanism.\n",
    "    * **Attn_size**: Determines the size of attention, i.e., the dimensions to which query and key are projected.\n",
    "    * **Num_layers**: Sets the number of layers in the transformer.\n",
    "    * **Widening_factor**: Specifies the factor by which the hidden size of the MLP is increased in each layer.\n",
    "\n",
    "In this example, we construct a compact Simformer with 2 layers and 2 heads.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "dim_value = 20      # Size of the value embedding\n",
    "dim_id = 20         # Size of the node id embedding\n",
    "dim_condition = 10  # Size of the condition embedding\n",
    "\n",
    "\n",
    "def model(t: Array, x: Array, node_ids: Array, condition_mask:Array, edge_mask: Optional[Array]=None):\n",
    "    \"\"\"Simplified Simformer model.\n",
    "\n",
    "    Args:\n",
    "        t (Array): Diffusion time\n",
    "        x (Array): Value of the nodes\n",
    "        node_ids (Array): Id of the nodes\n",
    "        condition_mask (Array): Condition state of the nodes\n",
    "        edge_mask (Array, optional): Edge mask. Defaults to None.\n",
    "\n",
    "    Returns:\n",
    "        Array: Score estimate of p(x_t)\n",
    "    \"\"\"\n",
    "    batch_size, seq_len, _ = x.shape\n",
    "    condition_mask = condition_mask.astype(jnp.bool_).reshape(-1,seq_len, 1)\n",
    "    node_ids = node_ids.reshape(-1,seq_len)\n",
    "    t = t.reshape(-1,1, 1)\n",
    "    \n",
    "    # Diffusion time embedding net (here we use a Gaussian Fourier embedding)\n",
    "    embedding_time = GaussianFourierEmbedding(64)  # Time embedding method\n",
    "    time_embeddings = embedding_time(t)\n",
    "    \n",
    "    # Tokinization part --------------------------------------------------------------------------------\n",
    "\n",
    "    embedding_net_value = lambda x: jnp.repeat(x, dim_value, axis=-1)    # Value embedding net (here we just repeat the value)\n",
    "    embedding_net_id = hk.Embed(nodes_max, dim_id, w_init=hk.initializers.RandomNormal(stddev=3.))   # Node id embedding nets (here we use a learnable random embedding vector)\n",
    "    condition_embedding = hk.get_parameter(\"condition_embedding\", shape=(1,1,dim_condition), init=hk.initializers.RandomNormal(stddev=0.5)) # Condition embedding (here we use a learnable random embedding vector)\n",
    "    condition_embedding = condition_embedding * condition_mask # If condition_mask is 0, then the embedding is 0, otherwise it is the condition_embedding vector\n",
    "    condition_embedding = jnp.broadcast_to(condition_embedding, (batch_size, seq_len, dim_condition))\n",
    "    \n",
    "    # Embed inputs and broadcast\n",
    "    value_embeddings = embedding_net_value(x)\n",
    "    id_embeddings = embedding_net_id(node_ids)\n",
    "    value_embeddings, id_embeddings = jnp.broadcast_arrays(value_embeddings, id_embeddings)\n",
    "    \n",
    "    # Concatenate embeddings (alternatively you can also add instead of concatenating)\n",
    "    x_encoded = jnp.concatenate([value_embeddings, id_embeddings, condition_embedding], axis=-1)\n",
    "    \n",
    "    # Transformer part --------------------------------------------------------------------------------\n",
    "    model = Transformer(num_heads=2, num_layers=2, attn_size=10, widening_factor=3) \n",
    "    \n",
    "    # Encode - here we just use a transformer to transform the tokenized inputs into a latent representation\n",
    "    h = model(x_encoded, context=time_embeddings, mask=edge_mask)\n",
    "\n",
    "    # Decode - here we just use a linear layer to get the score estimate (we scale the output by the marginal std dev)\n",
    "    out = hk.Linear(1)(h)\n",
    "    out = output_scale_fn(t, out) # SDE dependent output scaling\n",
    "    return out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# In Haiku, we need to initialize the model first, before we can use it.\n",
    "init, model_fn = hk.without_apply_rng(hk.transform(model)) # Init function initializes the parameters of the model, model_fn is the actual model function (which takes the parameters as first argument, hence is a \"pure function\")\n",
    "params = init(key, jnp.ones(data.shape[0]), data, node_ids, jnp.zeros_like(node_ids))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of parameters:  45774\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'embed': {'embeddings': (3, 20)},\n",
       " 'gaussian_fourier_embedding': {'B': (33, 1)},\n",
       " 'linear': {'b': (1,), 'w': (50, 1)},\n",
       " 'transformer/layer_norm': {'offset': (50,), 'scale': (50,)},\n",
       " 'transformer/layer_norm_1': {'offset': (50,), 'scale': (50,)},\n",
       " 'transformer/layer_norm_2': {'offset': (50,), 'scale': (50,)},\n",
       " 'transformer/layer_norm_3': {'offset': (50,), 'scale': (50,)},\n",
       " 'transformer/layer_norm_4': {'offset': (50,), 'scale': (50,)},\n",
       " 'transformer/linear': {'b': (150,), 'w': (50, 150)},\n",
       " 'transformer/linear_1': {'b': (50,), 'w': (150, 50)},\n",
       " 'transformer/linear_2': {'b': (50,), 'w': (64, 50)},\n",
       " 'transformer/linear_3': {'b': (150,), 'w': (50, 150)},\n",
       " 'transformer/linear_4': {'b': (50,), 'w': (150, 50)},\n",
       " 'transformer/linear_5': {'b': (50,), 'w': (64, 50)},\n",
       " 'transformer/multi_head_attention/key': {'b': (20,), 'w': (50, 20)},\n",
       " 'transformer/multi_head_attention/linear': {'b': (50,), 'w': (20, 50)},\n",
       " 'transformer/multi_head_attention/query': {'b': (20,), 'w': (50, 20)},\n",
       " 'transformer/multi_head_attention/value': {'b': (20,), 'w': (50, 20)},\n",
       " 'transformer/multi_head_attention_1/key': {'b': (20,), 'w': (50, 20)},\n",
       " 'transformer/multi_head_attention_1/linear': {'b': (50,), 'w': (20, 50)},\n",
       " 'transformer/multi_head_attention_1/query': {'b': (20,), 'w': (50, 20)},\n",
       " 'transformer/multi_head_attention_1/value': {'b': (20,), 'w': (50, 20)},\n",
       " '~': {'condition_embedding': (1, 1, 10)}}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here we can see the total number of parameters and their shapes\n",
    "print(\"Total number of parameters: \", jax.tree_util.tree_reduce(lambda x,y: x+y, jax.tree_map(lambda x: x.size, params)))\n",
    "jax.tree_util.tree_map(lambda x: x.shape, params) # Here we can see the shapes of the parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 4) The loss\n",
    "Here we will show the variant which targets to learn:\n",
    "\n",
    "* Correct joint $p(\\theta,x_1, x_2)$\n",
    "* Correct conditionals $p(\\theta|x), p(x|\\theta), ...$\n",
    "* Correct marginals $p(\\theta), p(x), ...$\n",
    "    \n",
    "Base loss is an **denoising score matching objective**:\n",
    "$$ \\mathcal{L}(\\phi) = \\mathbb{E}_{t \\sim Unif(0,1)} \\left[ \\lambda(t) \\mathbb{E}_{x_0, x_t \\sim p(x_0)p(x_t|x_0)}\\left[ || s_\\phi(x_t, t) - \\nabla_{x_t} \\log p(x_t|x_0)||_2^2 \\right] \\right] $$\n",
    "all the different *targets* will be implemented through masking out different things."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def weight_fn(t:Array):\n",
    "    # MLE weighting\n",
    "    return jnp.clip(sde.diffusion(t, jnp.ones((1,1,1)))**2, 1e-4)\n",
    "\n",
    "def marginalize(rng: PRNGKey, edge_mask: Array):\n",
    "    # Simple function that marginializes out a single node from a adjacency matrix of a graph.\n",
    "    idx = jax.random.choice(rng, jnp.arange(edge_mask.shape[0]), shape=(1,), replace=False)\n",
    "    edge_mask = edge_mask.at[idx, :].set(False)\n",
    "    edge_mask = edge_mask.at[:, idx].set(False)\n",
    "    edge_mask = edge_mask.at[idx, idx].set(True)\n",
    "    return edge_mask\n",
    "\n",
    "def loss_fn(params: dict, key: PRNGKey, batch_size:int= 1024):\n",
    "\n",
    "    rng_time, rng_sample, rng_data, rng_condition, rng_edge_mask1, rng_edge_mask2 = jax.random.split(key, 6)\n",
    "    \n",
    "    # Generate data and random times\n",
    "    times = jax.random.uniform(rng_time, (batch_size, 1, 1), minval=T_min, maxval=1.0)\n",
    "    batch_xs = generate_data(rng_data, batch_size) # n, T_max, 1\n",
    "\n",
    "    # Node ids (can be subsampled but here we use all nodes)\n",
    "    ids = node_ids\n",
    "    \n",
    "\n",
    "    # Condition mask -> randomly condition on some data.\n",
    "    condition_mask = jax.random.bernoulli(rng_condition, 0.333, shape=(batch_xs.shape[0], batch_xs.shape[1]))\n",
    "    condition_mask_all_one = jnp.all(condition_mask, axis=-1, keepdims=True)\n",
    "    condition_mask *= condition_mask_all_one # Avoid conditioning on all nodes -> nothing to train...\n",
    "    condition_mask = condition_mask[..., None]\n",
    "    # Alternatively you can also set the condition mask manually to specific conditional distributions.\n",
    "    # condition_mask = jnp.zeros((3,), dtype=jnp.bool_)  # Joint mask\n",
    "    # condition_mask = jnp.array([False, True, True], dtype=jnp.bool_)  # Posterior mask\n",
    "    # condition_mask = jnp.array([True, False, False], dtype=jnp.bool_)  # Likelihod mask\n",
    "    \n",
    "    # You can also structure the base mask!\n",
    "    edge_mask = jnp.ones((4*batch_size//5, batch_xs.shape[1],batch_xs.shape[1]), dtype=jnp.bool_) # Dense default mask \n",
    "    \n",
    "    # Optional: Include marginal consistency\n",
    "    marginal_mask = jax.vmap(marginalize, in_axes=(0,None))(jax.random.split(rng_edge_mask1, (batch_size//5,)), edge_mask[0])\n",
    "    edge_masks = jnp.concatenate([edge_mask, marginal_mask], axis=0)\n",
    "    edge_masks = jax.random.choice(rng_edge_mask2, edge_masks, shape=(batch_size,), axis=0) # Randomly choose between dense and marginal mask\n",
    "    \n",
    "\n",
    "    # Forward diffusion, do not perturb conditioned data\n",
    "    # Will use the condition mask to mask to prevent adding noise for nodes that are conditioned.\n",
    "    loss = denoising_score_matching_loss(params, rng_sample, times, batch_xs, condition_mask, model_fn= model_fn, mean_fn=sde.marginal_mean, std_fn = sde.marginal_stddev, weight_fn=weight_fn,node_ids=ids, condition_mask=condition_mask, edge_mask=edge_masks)\n",
    "    \n",
    "    return loss\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 5) Training\n",
    "\n",
    "Simple training loop (compatible with multiple GPUs, TPUs). Here simpy optimizing with Adam for a fixed amount of steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "optimizer = optax.adam(1e-3)\n",
    "opt_state = optimizer.init(params)\n",
    "\n",
    "@partial(jax.pmap, axis_name=\"num_devices\")\n",
    "def update(params, rng, opt_state):\n",
    "    loss, grads = jax.value_and_grad(loss_fn)(params, rng)\n",
    "    \n",
    "    loss = jax.lax.pmean(loss, axis_name=\"num_devices\")\n",
    "    grads = jax.lax.pmean(grads, axis_name=\"num_devices\")\n",
    "    \n",
    "    updates, opt_state = optimizer.update(grads, opt_state, params=params)\n",
    "    params = optax.apply_updates(params, updates)\n",
    "    return loss, params, opt_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "n_devices = jax.local_device_count()\n",
    "replicated_params = jax.tree_map(lambda x: jnp.array([x] * n_devices), params)\n",
    "replicated_opt_state = jax.tree_map(lambda x: jnp.array([x] * n_devices), opt_state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46.13004\n",
      "45.541588\n",
      "45.425938\n",
      "45.380486\n",
      "45.31089\n",
      "45.284744\n",
      "45.28235\n",
      "45.246407\n",
      "45.24479\n",
      "45.29022\n",
      "45.2673\n",
      "45.219772\n",
      "45.262814\n",
      "45.195946\n",
      "45.20421\n"
     ]
    }
   ],
   "source": [
    "key = jrandom.PRNGKey(0)\n",
    "for _ in range(15):\n",
    "    l = 0\n",
    "    for i in range(5000):\n",
    "        key, subkey = jrandom.split(key)\n",
    "        loss, replicated_params, replicated_opt_state = update(replicated_params, jax.random.split(subkey, (n_devices,)), replicated_opt_state)\n",
    "        l += loss[0] /5000\n",
    "    print(l)\n",
    "params = jax.tree_map(lambda x: x[0], replicated_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = jax.tree_map(lambda x: x[0], replicated_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 6) Sampling from the joint and the marginals\n",
    "\n",
    "For this we will implement a simple SDE-based sampler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "from probjax.utils.sdeint import sdeint\n",
    "\n",
    "condition_mask = jnp.zeros((nodes_max,))\n",
    "condition_value = jnp.zeros((nodes_max,))\n",
    "\n",
    "# Reverse SDE drift\n",
    "def drift_backward(t, x, node_ids=node_ids, condition_mask=condition_mask, edge_mask=None, score_fn = model_fn, replace_conditioned=True):\n",
    "    score = score_fn(params, t.reshape(-1, 1, 1), x.reshape(-1, len(node_ids), 1), node_ids,condition_mask[:len(node_ids)], edge_mask=edge_mask)\n",
    "    score = score.reshape(x.shape)\n",
    "\n",
    "    f =  sde.drift(t,x) - sde.diffusion(t,x)**2 * score\n",
    "    if replace_conditioned:\n",
    "        f = f * (1-condition_mask[:len(node_ids)])\n",
    "    \n",
    "    return f\n",
    "\n",
    "# Reverse SDE diffusion\n",
    "def diffusion_backward(t,x, node_ids=node_ids,condition_mask=condition_mask, replace_conditioned=True):\n",
    "    b =  sde.diffusion(t,x) \n",
    "    if replace_conditioned:\n",
    "        b = b * (1-condition_mask[:len(node_ids)])\n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "end_std = jnp.squeeze(sde.marginal_stddev(jnp.ones(1)))\n",
    "end_mean = jnp.squeeze(sde.marginal_mean(jnp.ones(1)))\n",
    "\n",
    "@partial(jax.jit, static_argnums=(1,3,7,8))\n",
    "def sample_fn(key, shape, node_ids=node_ids, time_steps=500, condition_mask=jnp.zeros((nodes_max,), dtype=int), condition_value=jnp.zeros((nodes_max,)), edge_mask=None, score_fn = model_fn, replace_conditioned=True):\n",
    "    condition_mask = condition_mask[:len(node_ids)]\n",
    "    key1, key2 = jrandom.split(key, 2)\n",
    "    # Sample from noise distribution at time 1\n",
    "    x_T = jax.random.normal(key1, shape + (len(node_ids),)) * end_std[node_ids] + end_mean[node_ids]\n",
    "    \n",
    "    if replace_conditioned:\n",
    "        x_T = x_T * (1-condition_mask) + condition_value * condition_mask\n",
    "    # Sove backward sde\n",
    "    keys = jrandom.split(key2, shape)\n",
    "    ys = jax.vmap(lambda *args: sdeint(*args, noise_type=\"diagonal\"), in_axes= (0, None, None, 0, None), out_axes=0)(keys, lambda t, x: drift_backward(t, x, node_ids, condition_mask, edge_mask=edge_mask, score_fn=score_fn, replace_conditioned=replace_conditioned), lambda t, x: diffusion_backward(t, x, node_ids, condition_mask, replace_conditioned=replace_conditioned), x_T, jnp.linspace(1.,T_min, time_steps))\n",
    "    return ys\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Full joint estimation\n",
    "samples = sample_fn(jrandom.PRNGKey(0), (10000,), node_ids, condition_mask=jnp.zeros((nodes_max,), dtype=int), condition_value=jnp.zeros((nodes_max,)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with use_style(\"pyloric\"):\n",
    "    fig,axes = pairplot(np.array(samples[:,-1,:]), figsize=(5,5), labels=[\"$\\\\theta_1$\", \"$x_1$\", \"$x_2$\"], diag_kind=\"kde\", color=\"black\", linewidth=2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Marginal estimation alone (if you leave out marginal consitstency in the loss, this will fail but the above will still work!)\n",
    "marginal_samples1  = sample_fn(jrandom.PRNGKey(0), (10000,), jnp.array([0,]), condition_mask=jnp.zeros((1,), dtype=int), condition_value=jnp.zeros((1,)))\n",
    "marginal_samples2  = sample_fn(jrandom.PRNGKey(0), (10000,), jnp.array([1,]), condition_mask=jnp.zeros((1,), dtype=int), condition_value=jnp.zeros((1,)))\n",
    "marginal_samples3 = sample_fn(jrandom.PRNGKey(0), (10000,), jnp.array([2,]), condition_mask=jnp.zeros((1,), dtype=int), condition_value=jnp.zeros((1,)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x200 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with use_style(\"pyloric\"):\n",
    "    fig, ax = plt.subplots(1,3, figsize=(5,2))\n",
    "    sns.histplot(marginal_samples1[:, -1, 0], bins=50, ax=ax[0], stat=\"density\")\n",
    "    sns.histplot(marginal_samples2[:, -1, 0], bins=50, ax=ax[1], stat=\"density\")\n",
    "    sns.histplot(marginal_samples3[:, -1, 0], bins=50, ax=ax[2], stat=\"density\")\n",
    "    sns.kdeplot(data[:, 0, 0], ax=ax[0], color=\"black\", linewidth=2)\n",
    "    sns.kdeplot(data[:, 1, 0], ax=ax[1], color=\"black\", linewidth=2)\n",
    "    sns.kdeplot(data[:, 2, 0], ax=ax[2], color=\"black\", linewidth=2)\n",
    "    \n",
    "    ax[0].set_xlim(-10,10)\n",
    "    ax[1].set_xlim(-5,5)\n",
    "    ax[2].set_xlim(-5,5)\n",
    "    fig.suptitle(\"Correct individual marginal estimation\")\n",
    "    for ax in ax:\n",
    "        ax.yaxis.set_visible(False)\n",
    "        # remove y spines\n",
    "        ax.spines['left'].set_visible(False)\n",
    "        \n",
    "\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7) Arbitrary conditional distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def true_posterior(theta, x1=None, x2=None):\n",
    "    potential_theta = partial(log_potential, x1=x1, x2=x2)\n",
    "    potential_post = potential_theta(theta)\n",
    "    potential_post = potential_post - potential_post.max()\n",
    "    potential_post = jnp.exp(potential_post)\n",
    "    potential_post = potential_post / jnp.trapz(potential_post, x=theta)\n",
    "    return potential_post"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_22157/519212729.py:6: DeprecationWarning: jax.numpy.trapz is deprecated. Use jax.scipy.integrate.trapezoid instead.\n",
      "  potential_post = potential_post / jnp.trapz(potential_post, x=theta)\n"
     ]
    }
   ],
   "source": [
    "# Full conditional estimation\n",
    "theta = jnp.linspace(-10, 10, 1000)\n",
    "x_o = data[4,:,0]\n",
    "true_post = true_posterior(theta, x_o[1], x_o[2])\n",
    "samples = sample_fn(jrandom.PRNGKey(0), (10000,), node_ids, condition_mask=jnp.array([0,1,1], dtype=jnp.bool_), condition_value=x_o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "samples_theta = samples[...,-1, 0]\n",
    "with use_style(\"pyloric\"):\n",
    "    fig = plt.figure(figsize=(5, 2))\n",
    "    sns.histplot(samples_theta, bins=50, stat=\"density\")\n",
    "    plt.plot(theta, true_post, color=\"black\", label=\"True posterior\")\n",
    "    exact_patch = mpatches.Patch(color='black', label='Exact')\n",
    "    approx_patch = mpatches.Patch(color='C0', label='Approx.')\n",
    "    plt.legend(handles=[exact_patch, approx_patch])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_22157/519212729.py:6: DeprecationWarning: jax.numpy.trapz is deprecated. Use jax.scipy.integrate.trapezoid instead.\n",
      "  potential_post = potential_post / jnp.trapz(potential_post, x=theta)\n"
     ]
    }
   ],
   "source": [
    "# Partial conditional estimation\n",
    "theta = jnp.linspace(-10, 10, 1000)\n",
    "x_o = data[4,:,0]\n",
    "true_post = true_posterior(theta, x_o[1], None)\n",
    "samples = sample_fn(jrandom.PRNGKey(0), (10000,), node_ids, condition_mask=jnp.array([0,1,0], dtype=int), condition_value=x_o, time_steps=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "import matplotlib.patches as mpatches\n",
    "samples_theta = samples[...,-1, 0]\n",
    "with use_style(\"pyloric\"):\n",
    "    fig = plt.figure(figsize=(5, 2))\n",
    "    sns.histplot(samples_theta, bins=80, stat=\"density\")\n",
    "    plt.plot(theta, true_post, color=\"black\", label=\"True posterior\")\n",
    "    exact_patch = mpatches.Patch(color='black', label='Exact')\n",
    "    approx_patch = mpatches.Patch(color='C0', label='Approx.')\n",
    "    plt.legend(handles=[exact_patch, approx_patch])\n",
    "    plt.xlim(-10, 10)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8) Arbitrary constraints\n",
    "\n",
    "Here a simplified version constraint conditioning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simplified sampling with guidance...\n",
    "\n",
    "def s(t):\n",
    "    # Some scaling function\n",
    "    t = jnp.atleast_1d(t)\n",
    "    return jnp.exp(-t**2*5)*100\n",
    "\n",
    "def log_step_fun(t,x,a,b):\n",
    "    # Step_fn constraint -> Intervals\n",
    "    scale = s(t)\n",
    "    x1 = jax.nn.log_sigmoid(jnp.sum(scale * (x - a), axis=-1))\n",
    "    x2 = jax.nn.log_sigmoid(jnp.sum(-scale * (x - b), axis=-1))\n",
    "\n",
    "    return x1 + x2\n",
    "\n",
    "def log_linear_fn_approximation(t,x, a):\n",
    "    # Linear constrait <s,a> = 0.\n",
    "    scale = s(t)\n",
    "    a = a.reshape(-1,x.shape[1],1)\n",
    "    x1 = jax.nn.log_sigmoid(scale *jnp.sum((x * a), axis=1))\n",
    "    x2 = jax.nn.log_sigmoid(-scale *jnp.sum((x * a), axis=1))\n",
    "    return x1 + x2\n",
    "\n",
    "def log_polytope_fn_approximation(t,x, A):\n",
    "    # Polytope constraint \n",
    "    scale = s(t)\n",
    "    a = x.reshape(-1, x.shape[1])\n",
    "    constraint = jax.nn.relu(scale * (jnp.matmul(a, A.T) - 1.)).max(axis=-1)\n",
    "    constraint = jax.nn.log_sigmoid(-constraint) \n",
    "    return constraint\n",
    "\n",
    "\n",
    "\n",
    "step_fn_score = jax.grad(lambda *args: log_step_fun(*args).sum(), argnums=1)\n",
    "linear_fn_score = jax.grad(lambda *args: log_linear_fn_approximation(*args).sum(), argnums=1)\n",
    "polytope_fn_score = jax.grad(lambda *args: log_polytope_fn_approximation(*args).sum(), argnums=1)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wappers around score functions to include the constraints\n",
    "\n",
    "def interval_score(params, t, x, node_ids, condition_mask, edge_mask, a,b):\n",
    "    condition_mask = condition_mask[:len(node_ids)].reshape(-1,len(node_ids), 1)\n",
    "    score = model_fn(params,t, x, node_ids=node_ids, condition_mask=jnp.zeros_like(condition_mask), edge_mask=edge_mask)\n",
    "    tweedies_x0_estimator = (x + sde.marginal_stddev(t, jnp.array([1.]))**2 * score)/sde.marginal_mean(t, jnp.array([1.])) # Predict x0\n",
    "    interval_score_est = step_fn_score(t,tweedies_x0_estimator,a,b).reshape(-1, len(node_ids), 1) * condition_mask.reshape(-1, len(node_ids), 1)\n",
    "    return score + interval_score_est\n",
    "\n",
    "def linear_score(params, t, x, node_ids, condition_mask, edge_mask, a):\n",
    "    condition_mask = condition_mask[:len(node_ids)].reshape(-1,len(node_ids), 1)\n",
    "    score = model_fn(params,t, x, node_ids=node_ids, condition_mask=jnp.zeros_like(condition_mask), edge_mask=edge_mask)\n",
    "    tweedies_x0_estimator = (x + sde.marginal_stddev(t, jnp.array([1.]))**2 * score)/sde.marginal_mean(t, jnp.array([1.])) # Predict x0\n",
    "    linear_score_est = linear_fn_score(t,tweedies_x0_estimator,a) * condition_mask.reshape(-1, len(node_ids), 1)\n",
    "    return score + linear_score_est\n",
    "\n",
    "def polytope_score(params, t, x,  node_ids, condition_mask, edge_mask, A):\n",
    "    condition_mask = condition_mask[:len(node_ids)].reshape(-1,len(node_ids), 1)\n",
    "    score = model_fn(params,t, x, node_ids=node_ids, condition_mask=jnp.zeros_like(condition_mask), edge_mask=edge_mask)\n",
    "    tweedies_x0_estimator = (x + sde.marginal_stddev(t, jnp.array([1.]))**2 * score)/sde.marginal_mean(t, jnp.array([1.])) # Predict x0\n",
    "    polytope_score_est = polytope_fn_score(t,tweedies_x0_estimator,A) #* condition_mask.reshape(-1, len(node_ids), 1)\n",
    "    return score + polytope_score_est\n",
    "\n",
    "score_fn1 = partial(interval_score, a=2.*jnp.ones(1), b=jnp.ones(1)*3)\n",
    "score_fn3 = partial(linear_score, a=jnp.array([1., 5.]))\n",
    "score_fn4 = partial(polytope_score, A=0.3*jax.random.normal(jrandom.PRNGKey(0), (8,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "samples1 = sample_fn(jrandom.PRNGKey(0), (1000,), time_steps=1000, node_ids=jnp.array([0,1]), condition_mask=jnp.array([0,1], dtype=int), score_fn=score_fn1, replace_conditioned=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "samples2 = sample_fn(jrandom.PRNGKey(0), (1000,), time_steps=1000, node_ids=jnp.array([0,1]), condition_mask=jnp.array([1,1], dtype=int), score_fn=score_fn3, replace_conditioned=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples3 = sample_fn(jrandom.PRNGKey(0), (1000,), time_steps=1000, node_ids=jnp.array([0,1]), condition_mask=jnp.array([1,1], dtype=int), score_fn=score_fn4, replace_conditioned=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Auxiliarly for plotting\n",
    "with jax.default_device(jax.devices(\"cpu\")[0]):\n",
    "    def pot(x):\n",
    "        return jnp.exp(log_polytope_fn_approximation(0.001, x, 0.3*jax.random.normal(jrandom.PRNGKey(0), (8,2))))\n",
    "\n",
    "\n",
    "    potential_fn = jax.vmap(jax.scipy.stats.gaussian_kde(data[:,[0,1], 0].T, bw_method=\"silverman\"))\n",
    "    x = jnp.linspace(data[:, 0, 0].min(), data[:, 0, 0].max(), 200)\n",
    "    y = jnp.linspace(data[:, 1, 0].min(), data[:, 1, 0].max(), 200)\n",
    "    X, Y = jnp.meshgrid(x, y)\n",
    "    pos = jnp.dstack((X, Y))\n",
    "    Z_true = potential_fn(pos.reshape(-1,2)).reshape(200,200)\n",
    "    Z = pot(pos.reshape(-1,2)).reshape(200,200)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x450 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# from scoresbibm.plot import use_style\n",
    "with use_style(\"pyloric\"):\n",
    "\n",
    "    fig, axs = plt.subplots(2, 1, figsize=(4., 4.5), gridspec_kw={'height_ratios': [1, 3]})\n",
    "\n",
    "    # 2D scatter plot\n",
    "    l = axs[1].contour(X, Y, Z,colors=\"tab:red\", levels=[0.4], alpha=0.5, linewidths=3)\n",
    "    axs[1].contourf(X, Y, Z_true, cmap=\"Greys\", levels=200, vmin=0, alpha=0.9)\n",
    "    axs[1].scatter(samples1[:, -1, 0], samples1[:, -1, 1], s=1, alpha=0.2, color=\"tab:green\")\n",
    "    axs[1].scatter(samples2[:, -1, 0], samples2[:, -1, 1], s=1, alpha=0.05, color=\"tab:blue\")\n",
    "    axs[1].scatter(samples3[:, -1, 0], samples3[:, -1, 1], s=1, alpha=0.2, color=\"tab:red\")\n",
    "    axs[1].set_xlim(-10, 10)\n",
    "    axs[1].set_ylim(-5, 5)\n",
    "    axs[1].set_xlabel(r\"$\\theta$\")\n",
    "    axs[1].set_ylabel(r\"$x_1$\")\n",
    "\n",
    "    # 1D marginal plot\n",
    "    _ = sns.histplot(samples1[:, -1, 0], ax=axs[0], bins=20, color=\"tab:green\", stat=\"density\")\n",
    "    _ = sns.histplot(samples2[:, -1, 0], ax=axs[0], bins=20,color=\"tab:blue\", stat=\"density\")\n",
    "    _ = sns.histplot(samples3[:, -1, 0], ax=axs[0],bins=20, color=\"tab:red\", stat=\"density\")\n",
    "    axs[0].set_xlim(-10, 10)\n",
    "    axs[0].set_xticklabels([])\n",
    "    axs[0].set_yticklabels([])\n",
    "    axs[0].set_ylabel(\"\")\n",
    "    axs[0].yaxis.set_visible(False)\n",
    "    axs[1].set_xticks([-10,0,10])\n",
    "    axs[1].set_yticks([-5,0,5])\n",
    "    \n",
    "    axs[0].legend([r\"$p(\\theta|x_1 \\in [2,3])$\", r\"$p(\\theta|x_1 + \\theta = 0)$\", r\"$p(\\theta|(x_1,\\theta)\\in S)$\"], ncol=3, loc=\"upper center\", bbox_to_anchor=(0.5, 1.5),columnspacing=0.7)\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9) Change priors or likelihoods\n",
    "\n",
    "\n",
    "$$ p(\\theta) \\propto \\exp\\left(-\\frac{(\\theta - \\mu)^2}{2\\sigma^2}\\right) $$\n",
    "$$ \\nabla_\\theta \\log p(\\theta) = \\frac{\\theta - \\mu}{\\sigma^2} $$\n",
    "\n",
    "In training we have $\\sigma^2 = 9$.\n",
    "Now for any $\\alpha$ we have\n",
    "$$ p(\\theta)^\\alpha = \\exp\\left(-\\frac{\\alpha(\\theta - \\mu)^2}{2\\sigma^2}\\right) = \\exp\\left(-\\frac{(\\theta - \\mu)^2}{2\\sigma^2/\\alpha}\\right) $$\n",
    "\n",
    "So if we want a certain variance $\\sigma_0^2$. All we have to do is to multiply the score by $\\alpha = \\sigma^2/\\sigma_0^2$.\n",
    "\n",
    "If we want to change the mean then we have to add $\\mu_0 - \\mu / \\sigma^2$ to the score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Score function wrappers with manipulations\n",
    "def score_prior_change(params, t, x, node_ids, condition_mask, edge_mask, node_ids_to_change, scale=1., shift=0.):\n",
    "\n",
    "    index = jnp.searchsorted(node_ids,node_ids_to_change)    \n",
    "    score_unconditioned = model_fn(params, t, x[:,index], node_ids=node_ids_to_change, condition_mask=jnp.zeros_like(node_ids_to_change))\n",
    "\n",
    "    score_conditional = model_fn(params, t, x, node_ids=node_ids, condition_mask=condition_mask, edge_mask=edge_mask)\n",
    "    score_conditional = score_conditional.at[:,index].set(scale * (score_unconditioned - shift) + (score_conditional[:,index] - score_unconditioned))\n",
    "    \n",
    "    return score_conditional\n",
    "\n",
    "def score_likelihood_change(params, t, x, node_ids, condition_mask, edge_mask, node_ids_to_change, scale=1., shift=0.):\n",
    "\n",
    "    index = jnp.searchsorted(node_ids,node_ids_to_change)    \n",
    "    score_unconditioned = model_fn(params, t, x[:,index], node_ids=node_ids_to_change, condition_mask=jnp.zeros_like(node_ids_to_change))\n",
    "\n",
    "    score_conditional = model_fn(params, t, x, node_ids=node_ids, condition_mask=condition_mask, edge_mask=edge_mask)\n",
    "    score_conditional =  score_conditional.at[:,index].set(score_unconditioned + (scale*(score_conditional[:,index] - score_unconditioned)) - shift)\n",
    "    \n",
    "    return score_conditional\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_22157/2674575355.py:6: DeprecationWarning: jax.numpy.trapz is deprecated. Use jax.scipy.integrate.trapezoid instead.\n",
      "  potential_post = potential_post / jnp.trapz(potential_post, x=x)\n"
     ]
    }
   ],
   "source": [
    "x = jnp.linspace(-10, 10, 1000)\n",
    "potential_theta = partial(log_potential, x1=jnp.zeros((1,)), x2=None, mean_scale=jnp.sqrt(12.))\n",
    "potential_post = potential_theta(x)\n",
    "potential_post = potential_post - potential_post.max()\n",
    "potential_post = jnp.exp(potential_post)\n",
    "potential_post = potential_post / jnp.trapz(potential_post, x=x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Change to N(0, 2) prior -> shift = 9/4\n",
    "score_fn_prior_change = partial(score_prior_change, scale=9/12., shift=0., node_ids_to_change=jnp.array([0]))\n",
    "samples = sample_fn(jrandom.PRNGKey(0), (5000,), time_steps=500, node_ids=jnp.array([0,1]), condition_mask=jnp.array([0,1], dtype=int), condition_value=jnp.zeros((2,)),  edge_mask=None, score_fn =score_fn_prior_change)\n",
    "with use_style(\"pyloric\"):\n",
    "    fig = plt.figure(figsize=(3, 2))\n",
    "    ax = plt.gca()\n",
    "    sns.histplot(samples[:, -1, 0], bins=100, stat=\"density\", label= \"Approx.\")\n",
    "    plt.plot(x, jax.scipy.stats.norm.pdf(x, 0, 2), color=\"black\", linestyle=\"--\", label=\"Prior\")\n",
    "    plt.plot(x, potential_post, color=\"black\", label=\"Exact\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "    plt.xlabel(r\"$\\theta$\")\n",
    "    ax.yaxis.set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.set_xticks([-10,0,10])   \n",
    "    ax.set_xlim(-10,10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_22157/586400139.py:6: DeprecationWarning: jax.numpy.trapz is deprecated. Use jax.scipy.integrate.trapezoid instead.\n",
      "  potential_post = potential_post / jnp.trapz(potential_post, x=x)\n"
     ]
    }
   ],
   "source": [
    "x = jnp.linspace(-10, 10, 1000)\n",
    "potential_theta = partial(log_potential, x1=jnp.zeros((1,)), x2=None, mean_scale=1, mean_loc=2)\n",
    "potential_post = potential_theta(x)\n",
    "potential_post = potential_post - potential_post.max()\n",
    "potential_post = jnp.exp(potential_post)\n",
    "potential_post = potential_post / jnp.trapz(potential_post, x=x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Change to N(2, 1) prior -> shift = 9/2, loc = 2/9\n",
    "score_fn_prior_change = partial(score_prior_change, scale=9/2, shift=-2/9, node_ids_to_change=jnp.array([0]))\n",
    "samples = sample_fn(jrandom.PRNGKey(0), (2000,), time_steps=500, node_ids=jnp.array([0,1]), condition_mask=jnp.array([0,1], dtype=int), condition_value=jnp.zeros((2,)),  edge_mask=None, score_fn =score_fn_prior_change)\n",
    "\n",
    "with use_style(\"pyloric\"):\n",
    "    fig = plt.figure(figsize=(3, 2))\n",
    "    ax = plt.gca()\n",
    "    sns.histplot(samples[:, -1, 0], bins=50, stat=\"density\", label= \"Approx.\")\n",
    "    plt.plot(x, jax.scipy.stats.norm.pdf(x, 2., np.sqrt(2.)), color=\"black\", linestyle=\"--\", label=\"Prior\")\n",
    "    plt.plot(x, potential_post, color=\"black\", label=\"Exact\")\n",
    "    plt.legend()\n",
    "    ax.yaxis.set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.set_xticks([-10,0,10])   \n",
    "    plt.xlabel(r\"$\\theta$\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_22157/3693902762.py:6: DeprecationWarning: jax.numpy.trapz is deprecated. Use jax.scipy.integrate.trapezoid instead.\n",
      "  potential_post = potential_post / jnp.trapz(potential_post, x=x)\n"
     ]
    }
   ],
   "source": [
    "x = jnp.linspace(-10, 10, 1000)\n",
    "potential_theta = partial(log_potential, x1=jnp.zeros((1,)), x2=None, sigma_x1=jnp.sqrt(0.05))\n",
    "potential_post = potential_theta(x)\n",
    "potential_post = potential_post - potential_post.max()\n",
    "potential_post = jnp.exp(potential_post)\n",
    "potential_post = potential_post / jnp.trapz(potential_post, x=x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Likelihood very certain\n",
    "score_fn_likelihood_change = partial(score_likelihood_change, scale=0.5**2/0.05, shift=0., node_ids_to_change=jnp.array([0]))\n",
    "samples = sample_fn(jrandom.PRNGKey(0), (2000,), time_steps=500, node_ids=jnp.array([0,1]), condition_mask=jnp.array([0,1], dtype=int), condition_value=jnp.zeros((2,)),  edge_mask=None, score_fn =score_fn_likelihood_change)\n",
    "\n",
    "with use_style(\"pyloric\"):\n",
    "    fig = plt.figure(figsize=(3, 2))\n",
    "    ax = plt.gca()\n",
    "    sns.histplot(samples[:, -1, 0], bins=200, stat=\"density\")\n",
    "    plt.plot(x, potential_post, color=\"black\")\n",
    "    plt.legend([\"exact\", \"approx.\"], loc=\"upper left\")\n",
    "    plt.xlim(-10,10)\n",
    "    ax.yaxis.set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.set_xticks([-10,0,10])   \n",
    "    plt.xlabel(r\"$\\theta$\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_22157/4120217402.py:6: DeprecationWarning: jax.numpy.trapz is deprecated. Use jax.scipy.integrate.trapezoid instead.\n",
      "  potential_post = potential_post / jnp.trapz(potential_post, x=x)\n"
     ]
    }
   ],
   "source": [
    "x = jnp.linspace(-10, 10, 1000)\n",
    "potential_theta = partial(log_potential, x1=jnp.zeros((1,)), x2=None, sigma_x1=2.)\n",
    "potential_post = potential_theta(x)\n",
    "potential_post = potential_post - potential_post.max()\n",
    "potential_post = jnp.exp(potential_post)\n",
    "potential_post = potential_post / jnp.trapz(potential_post, x=x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Likelihood very certain\n",
    "score_fn_likelihood_change = partial(score_likelihood_change, scale=0.5**2/4., shift=0., node_ids_to_change=jnp.array([0]))\n",
    "samples = sample_fn(jrandom.PRNGKey(0), (10000,), time_steps=500, node_ids=jnp.array([0,1]), condition_mask=jnp.array([0,1], dtype=int), condition_value=jnp.zeros((2,)),  edge_mask=None, score_fn =score_fn_likelihood_change)\n",
    "\n",
    "with use_style(\"pyloric\"):\n",
    "    fig = plt.figure(figsize=(3, 2))\n",
    "    ax = plt.gca()\n",
    "    sns.histplot(samples[:, -1, 0], bins=100, stat=\"density\")\n",
    "    plt.plot(x, potential_post, color=\"black\")\n",
    "    plt.legend([\"exact\", \"approx.\"], loc=\"upper left\")\n",
    "    plt.xlim(-10,10)\n",
    "    ax.yaxis.set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.set_xticks([-10,0,10])   \n",
    "    plt.xlabel(r\"$\\theta$\")"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Hide code",
  "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.10.14"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}