{ "cells": [ { "cell_type": "markdown", "id": "c651fabf-bccd-42eb-87fd-6ad774b0b937", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "(learning)=\n", "# Deep Bayesian predictive coding" ] }, { "cell_type": "markdown", "id": "fe6b34cf-2de5-4763-af6a-785b2930e679", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ComputationalPsychiatry/pyhgf/blob/master/docs/source/notebooks/0.5-Learning.ipynb)" ] }, { "cell_type": "code", "execution_count": 1, "id": "31b80846", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "import sys\n", "\n", "from IPython.utils import io\n", "\n", "if \"google.colab\" in sys.modules:\n", " with io.capture_output() as captured:\n", " ! pip uninstall -y jax jaxlib\n", " ! pip install pyhgf watermark jax[cuda12]==0.4.31" ] }, { "cell_type": "code", "execution_count": 2, "id": "6e337fd3-5a3e-4e0f-ab4f-e055cebfb7ff", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" ] } ], "source": [ "import jax\n", "import jax.numpy as jnp\n", "import matplotlib.animation as animation\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import optax\n", "import seaborn as sns\n", "import treescope\n", "from IPython.display import HTML\n", "from jax.nn import leaky_relu\n", "\n", "from pyhgf.model import DeepNetwork\n", "from pyhgf.plots.graphviz.plot_network import plot_deep_network\n", "\n", "np.random.seed(123)\n", "plt.rcParams[\"figure.constrained_layout.use\"] = True\n", "\n", "treescope.basic_interactive_setup(autovisualize_arrays=True)" ] }, { "cell_type": "markdown", "id": "d5341c9b-cbd3-4125-933f-52af82a18ee9", "metadata": {}, "source": [ "```{warning}\n", "The features exposed here are still a work in progress.\n", "```" ] }, { "cell_type": "markdown", "id": "94cee49c-4e25-48b9-9fe6-57e4a31fbf6b", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "The hierarchical Gaussian filter is built on top of a generative model that is governed by Gaussian random walks, which is best used to model the time-resolved evolution of beliefs in volatile environments. But the framework can easily extend to traditional applications of predictive coding, such as deep neural networks, where the variational message passing replaces the use of iterative gradient descent during inference.\n", "\n", "In this notebook, we show that the **prospective configuration** in predictive coding networks can be performed by one-shot variational updates, removing the need for gradient descent over the energy function, while learning expected precision in the hidden layers, which is often fixed in other approaches. We illustrate this with the \"bear example\" from {cite:p}`Song2024` and on a classification task with deep networks.\n", "\n", "```{figure} https://media.springernature.com/full/springer-static/image/art%3A10.1038%2Fs41593-023-01514-1/MediaObjects/41593_2023_1514_Fig1_HTML.png?as=webp\n", "---\n", "name: learning-prospective-config-task\n", "---\n", "Learning with prospective configuration.\n", "\n", "```" ] }, { "cell_type": "markdown", "id": "f6c811a5", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "## Learning in deep networks\n", "\n", "### Prospective configuration" ] }, { "cell_type": "markdown", "id": "3a858473", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "In standard backpropagation, weights are updated using gradients computed from a fixed forward pass. The network's activations are \"frozen\" while the error signal propagates backward. **Prospective configuration** {cite:p}`Song2024` takes a different approach: before any weight change, the network first *infers* the most likely activations at every layer by settling prediction errors across the whole hierarchy. Only once this inference step has converged are the weights updated. This two-phase process (infer activations, then update weights) prevents the catastrophic interference that arises when a local weight change inadvertently distorts representations elsewhere in the network.\n", "\n", "In `pyhgf`, this is implemented naturally through the belief propagation cycle. At each observation:\n", "\n", "1. **Prediction**: predictors ($x$) are provided in the leaf nodes. Each node generates a top-down prediction for its children via a nonlinear coupling function $g(\\cdot)$.\n", "2. **Observation & prediction errors**: the observed values ($y$) are compared with predictions, and precision-weighted prediction errors propagate upward through the hierarchy.\n", "3. **Posterior update**: node activations (means and precisions) are updated to minimise free energy, settling the network into a new equilibrium. This is comparable to the *prospective configuration* step.\n", "4. **Weight update**: only after the activations have settled are the coupling strengths (weights) adjusted using the prediction errors and the inferred activations.\n", "\n", "We illustrate this using the \"bear\" example network from {cite:t}`Song2024`." ] }, { "cell_type": "code", "execution_count": 3, "id": "96755731-c897-4776-b571-03bd76a8f533", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "# here x represents the visual input (River / No River)\n", "x = np.array([1.0, 1.0] * 120)\n", "x += np.random.normal(size=x.shape) / 100\n", "\n", "# y represents the auditory and olfactory stimuli\n", "y = np.array([\n", " x,\n", " np.concat([\n", " np.array([1.0, 1.0] * 40),\n", " np.array([-1.0, -1.0] * 40),\n", " np.array([1.0, 1.0] * 40),\n", " ])\n", " + np.random.normal(size=x.shape) / 100,\n", "]).T" ] }, { "cell_type": "code", "execution_count": 4, "id": "e25492c8-0fb1-489b-a286-f9854f6706ef", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "deep-network\n", "\n", "\n", "\n", "layer_0\n", "\n", "Prediction Layer (X)\n", "(1 units)\n", "\n", "\n", "\n", "layer_1\n", "\n", "Hidden Layer 1\n", "(1 units)\n", "\n", "\n", "\n", "layer_0->layer_1\n", "\n", "\n", "linear\n", "\n", "\n", "\n", "layer_2\n", "\n", "Outcome Layer (Y) \n", "(2 units)\n", "\n", "\n", "\n", "layer_1->layer_2\n", "\n", "\n", "linear\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# We start by defining a simple two-branch deep network.\n", "# The output layer (leaves) receives the outcomes ``y``; the top layer\n", "# receives the predictor ``x``, with a shared latent layer in between.\n", "network = (\n", " DeepNetwork()\n", " .add_layer(size=2, precision=2.0, expected_precision=2.0) # outcomes (y)\n", " .add_layer(size=1, tonic_volatility=-4.0) # shared latent\n", " .add_layer(size=1, precision=1.0, expected_precision=1.0) # predictor (x)\n", ")\n", "plot_deep_network(network)" ] }, { "cell_type": "markdown", "id": "d5dff455-f8d3-4b36-b36e-b6ce74fc6f5d", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "Deep networks trained for classification purposes differ from other predictive coding networks as both roots and leaves should receive inputs (predictors and outcomes, respectively)." ] }, { "cell_type": "code", "execution_count": 5, "id": "40c554b5-b869-498d-bca9-0e62d27673f2", "metadata": { "editable": true, "scrolled": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "network.fit(\n", " x=x.reshape(-1, 1),\n", " y=y,\n", " optimizer=optax.sgd(0.2),\n", " learning_kind=\"standard\",\n", " record=(\"expected_mean\",),\n", " time_step=1.0,\n", ");" ] }, { "cell_type": "code", "execution_count": 6, "id": "5396f0c3-d38b-45e9-a12d-d75b468712e8", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "hide-input" ] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Expected mean of the shared latent layer (1) and the outcome layer (0).\n", "network.plot_layers(\n", " layers=[1, 0],\n", " variables=(\"expected_mean\",),\n", " figsize=(9, 5),\n", ")\n", "sns.despine();" ] }, { "cell_type": "markdown", "id": "46ec8259-272c-4164-bd7c-3cf3da08b016", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "This example illustrates the effectiveness of the variational update to replace the prospective configuration step based on gradient descent. As new observations contradict the expected outcomes (i.e., observing the river without hearing the water, from trials 40 to 80 in the bottom panel), the network efficiently reorganizes without interfering with other predictions (i.e,. still expecting smelling the salmon while seeing the water, top panel, trials 40 to 80)." ] }, { "cell_type": "markdown", "id": "7bcd2bcc-ca33-4190-9dee-953b20ea90ed", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "```{hint} Volatile state nodes\n", "In a predictive coding network, two types of state nodes can be used to build the hierarchy. Continuous-state nodes are the standard HGF nodes: their precision is controlled by external volatility parents connected through dedicated volatility edges, and their mean persists across time steps by default (`autoconnection_strength`=1.0). This makes them well-suited for tracking slowly drifting quantities or serving as input/output layers that receive observations. Volatile-state nodes bundle a value level and an internal volatility level into a single node, removing the need for separate volatility parents. Their mean resets at each time step by default (`autoconnection_strength`=0.0), making them behave like stateless hidden units whose activation is determined entirely by incoming predictions. In practice, volatile-state nodes are the natural building block for hidden layers in deep predictive coding networks; they are more parameter-efficient than continuous-state nodes because the volatility coupling is handled internally, and their stateless default mirrors the feedforward activations of a conventional neural network.\n", "```" ] }, { "cell_type": "markdown", "id": "e95d1b33", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "### Weight update\n", "\n", "Once the network has settled into its new posterior (the prospective configuration step), the coupling strengths $w_i$ between a child node and its value parents are updated. Let $\\text{PE}$ denote the value prediction error at the child node, $\\pi_{\\text{child}}$ its posterior precision, and $g(\\mu_i)$ the activation of parent $i$ passed through the coupling function $g$.\n", "\n", "**Fixed learning rate.** With a constant step size $\\eta$:\n", "\n", "$$\n", "\\Delta w_i \\;=\\; \\eta \\;\\cdot\\; \\text{PE} \\;\\cdot\\; \\pi_{\\text{child}} \\;\\cdot\\; g(\\mu_i)\n", "$$\n", "\n", "**Dynamic (precision-weighted) learning rate.** When no fixed rate is specified, the update uses a Kalman-gain-like rule that automatically scales the step size by the relative precision of parent and child:\n", "\n", "$$\n", "K_i = \\frac{\\pi_{\\text{parent}_i}}{\\pi_{\\text{parent}_i} + \\pi_{\\text{child}}}\n", "$$\n", "\n", "$$\n", "\\Delta w_i \\;=\\; K_i \\;\\cdot\\; \\text{PE} \\;\\cdot\\; g(\\mu_i)\n", "$$\n", "\n", "In the dynamic case, precise parents exert a larger influence on the weight update while uncertain parents are updated more cautiously. This same precision weighting governs how far each clamped signal propagates through the hierarchy — the depth-dependent effect explored interactively in the next section." ] }, { "cell_type": "markdown", "id": "5b595219", "metadata": {}, "source": [ "### Input precision controls the depth of weight updates\n", "\n", "One natural consequence that emerges from this framework is that neural activations are defined by their precision, and as a result, the precision of the inputs (both predictors and outcomes) controls the strengths of prediction errors and the amplitude of weight updates in the vicinity of information flows. For example, more precise outcomes will guide weight updates to be larger at the nodes close to the inputs, and a more precise predictor will guide weight updates to be larger close to the internal representation.\n", "\n", "The widget below makes this explicit. We stack **eight** continuous-state value-parent layers through linear coupling and clamp the two ends: the **root** (layer 0) to an outcome $y = 1$ and the **leaf** (top layer) to an input $X = 0$. The sliders set the *expected precision* of these clamped ends and the *tonic volatility* of the interior (hidden) layers; every other prior is held fixed. Ten belief-propagation iterations are then run with the weights **frozen**, so only the means and precisions move — letting us watch how far each clamp's influence reaches across the stack.\n", "\n", "- **Left** — activations per layer. The ✕ markers are the prediction $\\hat\\mu$ after the first iteration; the ``Greys``-coloured polylines trace the posterior $\\mu$ across layers at each iteration (light = early, dark = late).\n", "- **Middle / Right** — predicted $\\mathcal{N}(\\hat\\mu,\\ 1/\\hat\\pi)$ and posterior $\\mathcal{N}(\\mu,\\ 1/\\pi)$ belief ridges at the final iteration.\n", "\n", "Every panel auto-zooms to the currently selected state.\n", "\n", "```{note}\n", "The published page has no live Python kernel, so the figure is **pre-computed** on a grid of root/leaf precisions $\\in \\{0.1, 0.5, 1, 5, 10, 100, 500, 1000\\}$ and hidden-layer tonic volatilities $\\in \\{-8, -7, -6, -5, -4, -3, -2, -1, 0\\}$ ($8 \\times 8 \\times 9 = 576$ states) and embedded as a self-contained Bokeh (HTML + JS) widget. The sliders snap to those grid values; move any of them to see the belief propagation re-equilibrate.\n", "```" ] }, { "cell_type": "code", "execution_count": 7, "id": "388b6faa", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "hide-input" ] }, "outputs": [ { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "import optax\n", "import seaborn as sns\n", "from bokeh.embed import file_html\n", "from bokeh.layouts import column, row\n", "from bokeh.models import (\n", " ColorBar,\n", " ColumnDataSource,\n", " CustomJS,\n", " CustomJSTickFormatter,\n", " DataRange1d,\n", " Label,\n", " LinearColorMapper,\n", " Slider,\n", " Span,\n", ")\n", "from bokeh.plotting import figure\n", "from bokeh.resources import CDN\n", "from IPython.display import HTML\n", "\n", "from pyhgf.model import DeepNetwork\n", "\n", "# --- Static grid the sliders snap to (the built page has no live kernel, so\n", "# every (root, leaf, tonic) combination below is computed once, here, at build\n", "# time and embedded into the widget). ---\n", "N_LAYERS, N_ITER, RIDGE_H, N_GRID = 8, 10, 0.7, 400\n", "ROOT_VALS = [0.1, 0.5, 1.0, 5.0, 10.0, 100.0, 500.0, 1000.0]\n", "LEAF_VALS = [0.1, 0.5, 1.0, 5.0, 10.0, 100.0, 500.0, 1000.0]\n", "TONIC_VALS = [-8.0, -7.0, -6.0, -5.0, -4.0, -3.0, -2.0, -1.0, 0.0]\n", "DEFAULT_ROOT_IDX = DEFAULT_LEAF_IDX = 4 # 10.0 / 10.0\n", "DEFAULT_TONIC_IDX = 0 # TONIC_VALS[0]\n", "\n", "\n", "def _linear(x):\n", " return x\n", "\n", "\n", "# ``run_scan`` is ``eqx.filter_jit``-ed with the optimizer as a *static* cache\n", "# key, so reuse one instance across the grid (a fresh ``optax.sgd`` per state\n", "# would recompile and cache an executable for every state).\n", "_OPT = optax.sgd(0.0)\n", "\n", "\n", "def _run(root_prec, leaf_prec, tonic):\n", " \"\"\"Clamp y=1 at the root and X=0 at the leaf, then settle for N_ITER steps.\"\"\"\n", " # ``_linear`` is a single shared object: ``coupling_fn`` is a static field,\n", " # so reusing it lets JAX compile ``run_scan`` once and reuse it across the\n", " # whole grid (a fresh ``lambda`` per call would recompile for every state).\n", " net = DeepNetwork(coupling_fn=_linear, volatility_updates=\"standard\")\n", " for i in range(N_LAYERS):\n", " prec = root_prec if i == 0 else leaf_prec if i == N_LAYERS - 1 else 100.0\n", " # The slider drives the tonic volatility of the interior (hidden) layers\n", " # only; the clamped root and leaf keep a fixed, very low tonic volatility.\n", " tv = -20.0 if i in (0, N_LAYERS - 1) else tonic\n", " net.add_layer(\n", " size=1,\n", " add_constant_input=False,\n", " tonic_volatility=tv,\n", " volatility_parent=False,\n", " precision=prec,\n", " expected_precision=prec,\n", " )\n", " net.fit(\n", " np.zeros((N_ITER, 1)),\n", " np.ones((N_ITER, 1)),\n", " optimizer=_OPT, # weights frozen below; this is inert\n", " weight_update=False,\n", " record=(\"mean\", \"precision\", \"expected_mean\", \"expected_precision\"),\n", " time_step=1.0,\n", " )\n", " t = net.trajectories\n", " stack = lambda f: np.stack([np.asarray(t[f][L]).ravel() for L in range(N_LAYERS)])\n", " return (\n", " stack(\"mean\"),\n", " stack(\"precision\"),\n", " stack(\"expected_mean\"),\n", " stack(\"expected_precision\"),\n", " )\n", "\n", "\n", "# --- Pre-compute every grid point: state index s = ti*(NR*NL) + ri*NL + li ---\n", "EF, SNAP, MFIN, SPOST, MPRED, SPRED, DS, XLO, XHI = ([] for _ in range(9))\n", "for tonic in TONIC_VALS:\n", " for root in ROOT_VALS:\n", " for leaf in LEAF_VALS:\n", " means, precs, emeans, eprecs = _run(root, leaf, tonic)\n", " sig_post = 1.0 / np.sqrt(np.clip(precs[:, -1], 1e-12, None))\n", " sig_pred = 1.0 / np.sqrt(np.clip(eprecs[:, -1], 1e-12, None))\n", " EF.append(emeans[:, 0].tolist())\n", " SNAP.append(means.tolist()) # (L, T)\n", " MFIN.append(means[:, -1].tolist())\n", " SPOST.append(sig_post.tolist())\n", " MPRED.append(emeans[:, -1].tolist())\n", " SPRED.append(sig_pred.tolist())\n", " # Per-state density scale: the tallest Gaussian *in this state*\n", " # (across both ridge panels) fills exactly one ridge slot, so the\n", " # y-axis always fits the tallest distribution as the sliders move.\n", " # Heights stay true densities within a view (taller + narrower =\n", " # more precise); only the absolute scale is re-fit per state.\n", " peak = max(\n", " float(1.0 / (sig_post.min() * np.sqrt(2 * np.pi))),\n", " float(1.0 / (sig_pred.min() * np.sqrt(2 * np.pi))),\n", " )\n", " DS.append(RIDGE_H / peak)\n", " # Per-state x extent for the ridge panels (capped padding) so each\n", " # panel's DataRange1d zooms to the beliefs of the selected state.\n", " sc = min(2.0, max(sig_post.max(), sig_pred.max()))\n", " lo = min(means[:, -1].min(), emeans[:, -1].min()) - 3 * sc\n", " hi = max(means[:, -1].max(), emeans[:, -1].max()) + 3 * sc\n", " XLO.append(float(min(lo, 0.0)))\n", " XHI.append(float(max(hi, 1.0)))\n", "\n", "LAYER_COLORS = sns.color_palette(\"rocket\", N_LAYERS).as_hex()\n", "# Greys, darker for later iterations; drop the two lightest so early lines stay\n", "# visible on the white background.\n", "ITER_COLORS = sns.color_palette(\"Greys\", N_ITER + 2).as_hex()[2:]\n", "layer_idx = list(range(N_LAYERS))\n", "s0 = (\n", " DEFAULT_TONIC_IDX * (len(ROOT_VALS) * len(LEAF_VALS))\n", " + DEFAULT_ROOT_IDX * len(LEAF_VALS)\n", " + DEFAULT_LEAF_IDX\n", ")\n", "\n", "\n", "def _ridges(mfin, sfin, ds, xlo, xhi):\n", " # True Gaussian density scaled by the per-state ``ds``: a more precise layer\n", " # is both taller and narrower, and the tallest fills one ridge slot.\n", " grid = np.linspace(xlo, xhi, N_GRID)\n", " xs, ys, mx, my1 = [], [], [], []\n", " for i in range(N_LAYERS):\n", " ridge = (\n", " ds\n", " * (1.0 / (sfin[i] * np.sqrt(2 * np.pi)))\n", " * np.exp(-0.5 * ((grid - mfin[i]) / sfin[i]) ** 2)\n", " )\n", " xs.append(grid.tolist() + grid[::-1].tolist())\n", " ys.append((i + ridge).tolist() + [i] * N_GRID)\n", " mx.append(mfin[i])\n", " my1.append(i + float(ridge.max()))\n", " return xs, ys, mx, my1\n", "\n", "\n", "src_pred = ColumnDataSource(dict(x=EF[s0], y=layer_idx, color=LAYER_COLORS))\n", "snap0 = np.array(SNAP[s0])\n", "src_lines = ColumnDataSource(\n", " dict(\n", " xs=[snap0[:, t].tolist() for t in range(N_ITER)],\n", " ys=[layer_idx for _ in range(N_ITER)],\n", " color=ITER_COLORS,\n", " )\n", ")\n", "xp, yp, mxp, myp = _ridges(MPRED[s0], SPRED[s0], DS[s0], XLO[s0], XHI[s0])\n", "xq, yq, mxq, myq = _ridges(MFIN[s0], SPOST[s0], DS[s0], XLO[s0], XHI[s0])\n", "src_rpred = ColumnDataSource(dict(xs=xp, ys=yp, color=LAYER_COLORS))\n", "src_rpost = ColumnDataSource(dict(xs=xq, ys=yq, color=LAYER_COLORS))\n", "src_mpred = ColumnDataSource(\n", " dict(x0=mxp, x1=mxp, y0=layer_idx, y1=myp, color=LAYER_COLORS)\n", ")\n", "src_mpost = ColumnDataSource(\n", " dict(x0=mxq, x1=mxq, y0=layer_idx, y1=myq, color=LAYER_COLORS)\n", ")\n", "\n", "# DataRange1d so every panel auto-zooms to the currently displayed state. The\n", "# y-axis (layers) is shared across panels; the ridge panels share their x-axis.\n", "y_shared = DataRange1d()\n", "x_ridge = DataRange1d()\n", "p0 = figure(\n", " width=380,\n", " height=480,\n", " x_range=DataRange1d(),\n", " y_range=y_shared,\n", " title=\"Activations\",\n", " x_axis_label=\"activation\",\n", " y_axis_label=\"layer (0 = root, top = leaf)\",\n", ")\n", "p0.multi_line(\n", " \"xs\", \"ys\", line_color=\"color\", line_width=1.4, alpha=0.9, source=src_lines\n", ")\n", "p0.scatter(\n", " \"x\",\n", " \"y\",\n", " source=src_pred,\n", " size=12,\n", " marker=\"x\",\n", " line_color=\"color\",\n", " line_width=2.5,\n", " legend_label=\"prediction μ̂ (iter 1)\",\n", ")\n", "p0.add_layout(\n", " Span(location=0.0, dimension=\"height\", line_color=\"gray\", line_dash=\"dotted\")\n", ")\n", "p0.add_layout(\n", " Span(location=1.0, dimension=\"height\", line_color=\"gray\", line_dash=\"dotted\")\n", ")\n", "p0.add_layout(\n", " Label(\n", " x=0.0, y=N_LAYERS - 0.4, text=\"X = 0\", text_color=\"gray\", text_font_size=\"9pt\"\n", " )\n", ")\n", "p0.add_layout(\n", " Label(x=1.0, y=-0.8, text=\"y = 1\", text_color=\"gray\", text_font_size=\"9pt\")\n", ")\n", "p0.legend.location, p0.legend.label_text_font_size = \"top_left\", \"8pt\"\n", "p0.add_layout(\n", " ColorBar(\n", " color_mapper=LinearColorMapper(palette=ITER_COLORS, low=1, high=N_ITER),\n", " title=\"iteration\",\n", " height=8,\n", " ),\n", " \"below\",\n", ")\n", "p1 = figure(\n", " width=360,\n", " height=480,\n", " x_range=x_ridge,\n", " y_range=y_shared,\n", " title=\"Expected mean and precision\",\n", " x_axis_label=\"activation\",\n", ")\n", "p1.patches(\n", " \"xs\",\n", " \"ys\",\n", " source=src_rpred,\n", " fill_color=\"color\",\n", " fill_alpha=0.35,\n", " line_color=\"color\",\n", ")\n", "p1.segment(\n", " \"x0\", \"y0\", \"x1\", \"y1\", source=src_mpred, line_color=\"color\", line_dash=\"dotted\"\n", ")\n", "p2 = figure(\n", " width=360,\n", " height=480,\n", " x_range=x_ridge,\n", " y_range=y_shared,\n", " title=\"Posterior mean and precision\",\n", " x_axis_label=\"activation\",\n", ")\n", "p2.patches(\n", " \"xs\",\n", " \"ys\",\n", " source=src_rpost,\n", " fill_color=\"color\",\n", " fill_alpha=0.35,\n", " line_color=\"color\",\n", ")\n", "p2.segment(\n", " \"x0\", \"y0\", \"x1\", \"y1\", source=src_mpost, line_color=\"color\", line_dash=\"dotted\"\n", ")\n", "\n", "fmt_root = CustomJSTickFormatter(\n", " args=dict(v=ROOT_VALS), code=\"return v[tick].toString();\"\n", ")\n", "fmt_leaf = CustomJSTickFormatter(\n", " args=dict(v=LEAF_VALS), code=\"return v[tick].toString();\"\n", ")\n", "fmt_tonic = CustomJSTickFormatter(\n", " args=dict(v=TONIC_VALS), code=\"return v[tick].toString();\"\n", ")\n", "s_root = Slider(\n", " start=0,\n", " end=len(ROOT_VALS) - 1,\n", " step=1,\n", " value=DEFAULT_ROOT_IDX,\n", " title=\"Root precision\",\n", " format=fmt_root,\n", " width=420,\n", ")\n", "s_leaf = Slider(\n", " start=0,\n", " end=len(LEAF_VALS) - 1,\n", " step=1,\n", " value=DEFAULT_LEAF_IDX,\n", " title=\"Leaf precision\",\n", " format=fmt_leaf,\n", " width=420,\n", ")\n", "s_tonic = Slider(\n", " start=0,\n", " end=len(TONIC_VALS) - 1,\n", " step=1,\n", " value=DEFAULT_TONIC_IDX,\n", " title=\"Hidden-layer tonic volatility\",\n", " format=fmt_tonic,\n", " width=420,\n", ")\n", "cb = CustomJS(\n", " args=dict(\n", " src_pred=src_pred,\n", " src_lines=src_lines,\n", " src_rpred=src_rpred,\n", " src_rpost=src_rpost,\n", " src_mpred=src_mpred,\n", " src_mpost=src_mpost,\n", " s_root=s_root,\n", " s_leaf=s_leaf,\n", " s_tonic=s_tonic,\n", " EF=EF,\n", " SNAP=SNAP,\n", " MFIN=MFIN,\n", " SPOST=SPOST,\n", " MPRED=MPRED,\n", " SPRED=SPRED,\n", " XLO=XLO,\n", " XHI=XHI,\n", " DS=DS,\n", " NL=N_LAYERS,\n", " NT=N_ITER,\n", " NG=N_GRID,\n", " NR=len(ROOT_VALS),\n", " NLEAF=len(LEAF_VALS),\n", " ),\n", " code=\"\"\"\n", " const s = s_tonic.value * (NR * NLEAF) + s_root.value * NLEAF + s_leaf.value;\n", " src_pred.data['x'] = EF[s];\n", " const xs = [];\n", " for (let t = 0; t < NT; t++) { const r = []; for (let L = 0; L < NL; L++) r.push(SNAP[s][L][t]); xs.push(r); }\n", " src_lines.data['xs'] = xs;\n", " const xlo = XLO[s], xhi = XHI[s], SQ2PI = Math.sqrt(2 * Math.PI), ds = DS[s];\n", " const grid = []; for (let k = 0; k < NG; k++) grid.push(xlo + (xhi - xlo) * k / (NG - 1));\n", " // True Gaussian density scaled by the per-state ds (the tallest Gaussian in\n", " // the state fills one slot): a more precise layer is both taller and narrower.\n", " function ridges(mfin, sfin) {\n", " const Xs = [], Ys = [], x0 = [], y1 = [];\n", " for (let i = 0; i < NL; i++) {\n", " const top = [], mu = mfin[i], sig = sfin[i]; let rmax = 0;\n", " for (let k = 0; k < NG; k++) {\n", " const d = ds * (1.0 / (sig * SQ2PI)) * Math.exp(-0.5 * Math.pow((grid[k] - mu) / sig, 2));\n", " top.push(i + d); if (d > rmax) rmax = d;\n", " }\n", " const base = []; for (let k = 0; k < NG; k++) base.push(i);\n", " Xs.push(grid.concat(grid.slice().reverse())); Ys.push(top.concat(base));\n", " x0.push(mu); y1.push(i + rmax);\n", " }\n", " return [Xs, Ys, x0, y1];\n", " }\n", " let r = ridges(MPRED[s], SPRED[s]);\n", " src_rpred.data['xs'] = r[0]; src_rpred.data['ys'] = r[1];\n", " src_mpred.data['x0'] = r[2]; src_mpred.data['x1'] = r[2]; src_mpred.data['y1'] = r[3];\n", " r = ridges(MFIN[s], SPOST[s]);\n", " src_rpost.data['xs'] = r[0]; src_rpost.data['ys'] = r[1];\n", " src_mpost.data['x0'] = r[2]; src_mpost.data['x1'] = r[2]; src_mpost.data['y1'] = r[3];\n", " for (const src of [src_pred, src_lines, src_rpred, src_rpost, src_mpred, src_mpost]) src.change.emit();\n", " \"\"\",\n", ")\n", "for sld in (s_root, s_leaf, s_tonic):\n", " sld.js_on_change(\"value\", cb)\n", "\n", "layout = column(row(p0, p1, p2), s_root, s_leaf, s_tonic)\n", "html = file_html(layout, CDN, \"Reactive value-parent stack\")\n", "# Isolate the standalone document in an iframe so its BokehJS