tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook demonstrates how to use our model by applying it to a toy dataset.\n",
    "\n",
    "The input data are divided into three parts:\n",
    "- **spikeTrain**: A list of spikes observed at each probe. Each spike is a 2D array with shape `(n, 1 + n_kappa)`, where `n` is the number of spikes and `n_kappa` is the dimension of the spike feature. The first column represents the spike time, and the remaining columns correspond to the spike features.\n",
    "- **stim**: A covariate array with shape `(num_steps, 1 + n_y)`, where `num_steps` is the number of time steps, and `n_y` is the dimension of the covariate feature. The first column represents the time, and the remaining columns correspond to the covaraite values. \n",
    "- **sep**: An observation time interval $[T_1, T_2]$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Generating toy data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assume that there is $x_t$, which determines the firing rate of the neurons, defined as \n",
    "$$\n",
    "x_t = \\begin{bmatrix} \\cos\\left(\\frac{2 \\pi f t}{T}\\right) \\\\ \\sin\\left(\\frac{2 \\pi f t}{T}\\right) \\end{bmatrix}, \\quad t \\in [0, T],\n",
    "$$  \n",
    "where $f = 5$ and $T = 100$.\n",
    "\n",
    "Consider that there are three probes, and each probe measures the firing activities of five neurons. The joint mark intensity at probe $i$ is defined as  \n",
    "$$\n",
    "\\lambda_{i}(x_t, \\kappa) = \\sum_{j=1}^5 \\exp\\left(\\alpha + \\beta \\mu_{ij}^T x_t\\right) \\, \\mathrm{N} \\left(\\kappa \\mid \\mu_{ij}, \\sigma^2 I\\right), \\quad i = 1, \\dots, 3,\n",
    "$$  \n",
    "where $ \\mu_{ij} $ is the parameter of the $j$-th neuron at probe $i$, generated from a uniform distribution on the unit circle. The parameters $ \\alpha $, $ \\beta $, and $ \\sigma $ are shared across probes.\n",
    "\n",
    "The observed covariate $y_t$ is defined as  \n",
    "$$\n",
    "y_t = x_t.\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-03 11:29:52.724938: I tensorflow/core/util/port.cc:110] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2025-01-03 11:29:52.747619: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "Matplotlib created a temporary config/cache directory at /tmp/matplotlib-hj74_cc1 because the default path (/.config/matplotlib) is not a writable directory; it is highly recommended to set the MPLCONFIGDIR environment variable to a writable directory, in particular to speed up the import of Matplotlib and to better support multiprocessing.\n"
     ]
    }
   ],
   "source": [
    "ROOTDIR = '/tf/workspace/MPPVAE' # Change this to the path of the repository\n",
    "import os\n",
    "os.chdir(ROOTDIR)\n",
    "import numpy as np\n",
    "np.set_printoptions(suppress = True)\n",
    "import tensorflow as tf\n",
    "from tqdm import tqdm\n",
    "import time\n",
    "from util import *\n",
    "from model_JVAE import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = 100\n",
    "dt = 0.01\n",
    "sep = [0, T]\n",
    "num_steps = int(T / dt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts = np.linspace(0, T, num_steps)\n",
    "ys = np.stack([np.cos(2 * np.pi * 5 * ts / T), np.sin(2 * np.pi * 5 * ts / T)]).T\n",
    "stim = np.concatenate([ts[:, None], ys], axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_probes = 3\n",
    "n_neurons = 5\n",
    "mus = np.random.normal(0, 1, (n_probes, n_neurons, 2))\n",
    "mus /= np.linalg.norm(mus, axis=-1, keepdims=True)\n",
    "\n",
    "alpha, beta = 1., 1.\n",
    "intensity_max = np.exp(alpha + beta)\n",
    "ns = np.random.poisson(intensity_max * T, (n_probes, n_neurons))\n",
    "\n",
    "spikeTrain = []\n",
    "\n",
    "for i in range(n_probes):\n",
    "    \n",
    "    spikes_from_probe = []\n",
    "\n",
    "    for j in range(n_neurons):\n",
    "        tis = np.random.uniform(0, T, ns[i, j])\n",
    "        xis = np.stack([np.cos(2 * np.pi * 5 * tis / T), np.sin(2 * np.pi * 5 * tis / T)]).T\n",
    "\n",
    "        accept_ratio = np.exp(alpha + beta * (xis * mus[i, j]).sum(axis=-1)) / intensity_max\n",
    "        mask = np.random.uniform(size=accept_ratio.shape) < accept_ratio\n",
    "\n",
    "        tis = tis[mask]\n",
    "        kappais = np.random.normal(mus[i, j], 0.1, (tis.shape[0], 2))\n",
    "        spikes_from_neuron = np.concatenate([tis[:, None], kappais], axis=-1)\n",
    "        \n",
    "        spikes_from_probe.append(spikes_from_neuron)\n",
    "\n",
    "    spikes_from_probe = np.concatenate(spikes_from_probe, axis=0)\n",
    "    spikes_from_probe = spikes_from_probe[np.argsort(spikes_from_probe[:, 0])]\n",
    "    spikeTrain.append(spikes_from_probe)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1702, 3), (1652, 3), (1748, 3)]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[spike.shape for spike in spikeTrain]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10000, 3)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stim.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 100]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sep"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Training model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "portion = [8, 1, 1]\n",
    "perm = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "n_batch = 80\n",
    "n_compile = 4\n",
    "n_jackknife = 2\n",
    "n_repeat = 10\n",
    "learning_rate = 0.001\n",
    "alpha_1, alpha_2 = 0., 2.\n",
    "\n",
    "training_epochs = 200\n",
    "eval_step = 50\n",
    "\n",
    "n_monte = 10\n",
    "n_monte_eval = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_params = {'n_site': len(spikeTrain), 'n_y': stim.shape[1] - 1, 'n_kappa': [spike.shape[1] - 1 for spike in spikeTrain]}\n",
    "\n",
    "n_params.update({'n_recog': [50, 50, 50, 50], 'n_recog_g': [50, 50, 50, 50], 'n_gener_x': [50, 50, 50, 50], 'n_gener_kappa': [50, 50, 50, 50],\n",
    "                 'n_recog_y': [50, 50, 50, 50], 'n_gener_y': [50, 50, 50, 50], 'n_recog_kappa': [50, 50, 50, 50],\n",
    "                 'n_z': 10, 'n_x': 10})\n",
    "\n",
    "n_params.update({'n_batch': n_batch})\n",
    "n_params.update({'alpha_1': alpha_1, 'alpha_2': alpha_2})\n",
    "n_params.update({'learning_rate': learning_rate})\n",
    "n_params.update({'n_compile': n_compile})\n",
    "n_params.update({'n_jackknife': n_jackknife})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-03 11:29:53.973485: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2025-01-03 11:29:53.976378: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2025-01-03 11:29:53.976461: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2025-01-03 11:29:53.977330: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2025-01-03 11:29:53.977395: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2025-01-03 11:29:53.977501: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2025-01-03 11:29:54.007452: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2025-01-03 11:29:54.007528: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2025-01-03 11:29:54.007574: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2025-01-03 11:29:54.007619: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 21677 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:01:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "spikeTrain, stim, stim_mean, stim_cov = normalize(spikeTrain, stim, sep)\n",
    "\n",
    "dataSet = makeDataSet(spikeTrain, stim)\n",
    "\n",
    "trainDataSet, trainStimSet, trainSepSet, log_scale_train, valDataSet, valStimSet, valSepSet, log_scale_val, testDataSet, testStimSet, testSepSet, log_scale_test = splitDataSet(dataSet, stim, sep, portion, perm)\n",
    "\n",
    "batch_ts_train, batch_inds_train, batch_kappas_train, batch_ttildes_train, batch_ys_train, batch_seps_train = splitDataBatch(trainDataSet, trainStimSet, trainSepSet, n_batch, n_params)\n",
    "batch_ts_val, batch_inds_val, batch_kappas_val, batch_ttildes_val, batch_ys_val, batch_seps_val = splitDataBatch(valDataSet, valStimSet, valSepSet, 1, n_params)\n",
    "batch_ts_test, batch_inds_test, batch_kappas_test, batch_ttildes_test, batch_ys_test, batch_seps_test = splitDataBatch(testDataSet, testStimSet, testSepSet, 1,  n_params)\n",
    "\n",
    "batch_ts_padded_train, batch_kappas_padded_train, batch_masks_train, batch_ttildes_padded_train, batch_ys_padded_train = padDataBatch(batch_ts_train, batch_inds_train, batch_kappas_train, batch_ttildes_train, batch_ys_train)\n",
    "batch_ts_padded_val, batch_kappas_padded_val, batch_masks_val, batch_ttildes_padded_val, batch_ys_padded_val = padDataBatch(batch_ts_val, batch_inds_val, batch_kappas_val, batch_ttildes_val, batch_ys_val)\n",
    "batch_ts_padded_test, batch_kappas_padded_test, batch_masks_test, batch_ttildes_padded_test, batch_ys_padded_test = padDataBatch(batch_ts_test, batch_inds_test, batch_kappas_test, batch_ttildes_test, batch_ys_test)\n",
    "\n",
    "del trainDataSet, trainStimSet, valDataSet, valStimSet, testDataSet, testStimSet, dataSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.8/dist-packages/keras/initializers/initializers.py:120: UserWarning: The initializer HeUniform is unseeded and being called multiple times, which will return identical values each time (even if the initializer is unseeded). Please update your code to provide a seed to the initializer, or avoid using the same initalizer instance more than once.\n",
      "  warnings.warn(\n",
      "/usr/local/lib/python3.8/dist-packages/keras/initializers/initializers.py:120: UserWarning: The initializer GlorotUniform is unseeded and being called multiple times, which will return identical values each time (even if the initializer is unseeded). Please update your code to provide a seed to the initializer, or avoid using the same initalizer instance more than once.\n",
      "  warnings.warn(\n",
      "2025-01-03 11:29:56.277378: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'scan/while/random_normal/shape/strided_slice' with dtype int32\n",
      "\t [[{{node scan/while/random_normal/shape/strided_slice}}]]\n",
      "2025-01-03 11:29:57.259983: I tensorflow/compiler/xla/service/service.cc:169] XLA service 0xc253250 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2025-01-03 11:29:57.260025: I tensorflow/compiler/xla/service/service.cc:177]   StreamExecutor device (0): NVIDIA GeForce RTX 3090, Compute Capability 8.6\n",
      "2025-01-03 11:29:57.275068: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "2025-01-03 11:29:57.329116: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:424] Loaded cuDNN version 8600\n",
      "2025-01-03 11:29:57.655069: I ./tensorflow/compiler/jit/device_compiler.h:180] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n",
      "2025-01-03 11:29:57.689596: I tensorflow/compiler/xla/service/service.cc:169] XLA service 0x7a338c621c80 initialized for platform Host (this does not guarantee that XLA will be used). Devices:\n",
      "2025-01-03 11:29:57.689618: I tensorflow/compiler/xla/service/service.cc:177]   StreamExecutor device (0): Host, Default Version\n",
      "2025-01-03 11:29:58.267201: I tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:637] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n"
     ]
    }
   ],
   "source": [
    "vae = JVAE(n_params)\n",
    "vae.assign_log_lambda(batch_kappas_padded_train, batch_masks_train, batch_ys_padded_train, n_monte)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                                                                                                                                                                         | 0/200 [00:00<?, ?it/s]2025-01-03 11:30:07.169632: I tensorflow/compiler/xla/stream_executor/gpu/asm_compiler.cc:328] ptxas warning : Registers are spilled to local memory in function 'fusion_218', 64 bytes spill stores, 64 bytes spill loads\n",
      "\n",
      "2025-01-03 11:30:19.337481: I tensorflow/compiler/xla/stream_executor/gpu/asm_compiler.cc:328] ptxas warning : Registers are spilled to local memory in function 'fusion_218', 64 bytes spill stores, 64 bytes spill loads\n",
      "\n",
      "2025-01-03 11:30:24.356414: I tensorflow/compiler/xla/stream_executor/gpu/asm_compiler.cc:328] ptxas warning : Registers are spilled to local memory in function 'fusion_218', 64 bytes spill stores, 64 bytes spill loads\n",
      "\n",
      "2025-01-03 11:30:29.500526: I tensorflow/compiler/xla/stream_executor/gpu/asm_compiler.cc:328] ptxas warning : Registers are spilled to local memory in function 'fusion_218', 64 bytes spill stores, 64 bytes spill loads\n",
      "\n",
      " 25%|████████████████████████████████████████████████                                                                                                                                                | 50/200 [01:11<02:02,  1.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0050 | lambda_cost: 159.206\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|███████████████████████████████████████████████████████████████████████████████████████████████▌                                                                                               | 100/200 [01:52<01:20,  1.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0100 | lambda_cost: -42.754\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎                                               | 150/200 [02:32<00:40,  1.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0150 | lambda_cost: -81.792\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 200/200 [03:12<00:00,  1.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0200 | lambda_cost: -123.683\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "avg_cost = 0.\n",
    "\n",
    "for epoch in tqdm(range(training_epochs)):\n",
    "\n",
    "    shuffle_ind = tf.random.shuffle(tf.range(n_batch))\n",
    "    batch_kappas_padded_train, batch_masks_train, batch_ys_padded_train = tf.gather(batch_kappas_padded_train, shuffle_ind), tf.gather(batch_masks_train, shuffle_ind), tf.gather(batch_ys_padded_train, shuffle_ind)\n",
    "    avg_cost_epoch = vae.train(batch_kappas_padded_train, batch_masks_train, batch_ys_padded_train, n_monte)\n",
    "    avg_cost += avg_cost_epoch\n",
    "\n",
    "    if (epoch + 1) % eval_step == 0:\n",
    "\n",
    "        avg_cost = avg_cost / eval_step\n",
    "        print('Epoch:', '%04d' % (epoch + 1), '|', 'lambda_cost:', '{:.3f}'.format(avg_cost))\n",
    "        avg_cost = 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Decoding covariate from spike trains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-03 11:33:12.903437: I tensorflow/core/util/cuda_solvers.cc:179] Creating GpuSolver handles for stream 0x81401e0\n"
     ]
    }
   ],
   "source": [
    "sep, kappas, masks, ttilde, y = batch_seps_test[0], batch_kappas_padded_test[0], batch_masks_test[0], batch_ttildes_padded_test[0], batch_ys_padded_test[0]\n",
    "y_smoothed_means, y_smoothed_covs, x_smoothed_means, x_smoothed_covs = vae.decode(kappas, masks, log_scale_train, log_scale_test, n_monte_eval, 5, 100)\n",
    "y, y_smoothed_means, y_smoothed_covs = denormalize(y, y_smoothed_means, y_smoothed_covs, stim_mean, stim_cov)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The figure below shows the true and decoded covariates. The blue and orange solid lines represent each coordinate of the true covariate, while the blue and orange bands represent the two-sigma prediction intervals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, '$y$')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(ttilde, y[:, 0, 0])\n",
    "plt.fill_between(ttilde[:, 0], y_smoothed_means[:, 0, 0] - 2 * np.sqrt(y_smoothed_covs[:, 0, 0]), y_smoothed_means[:, 0, 0] + 2 * np.sqrt(y_smoothed_covs[:, 0, 0]), alpha=0.5)\n",
    "\n",
    "plt.plot(ttilde, y[:, 0, 1])\n",
    "plt.fill_between(ttilde[:, 0], y_smoothed_means[:, 0, 1] - 2 * np.sqrt(y_smoothed_covs[:, 1, 1]), y_smoothed_means[:, 0, 1] + 2 * np.sqrt(y_smoothed_covs[:, 1, 1]), alpha=0.5)\n",
    "\n",
    "plt.xlim(sep[0], sep[1])\n",
    "\n",
    "plt.xlabel(r'$t$')\n",
    "plt.ylabel(r'$y$')"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}