notebooks/train_spike_history_monkey.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import os\n",
    "import sys\n",
    "\n",
    "# append parent directory to path (../notebooks -> ..)\n",
    "sys.path.append(os.path.dirname(os.getcwd()))\n",
    "os.chdir(os.path.dirname(os.getcwd()))\n",
    "\n",
    "import pickle\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from einops import rearrange\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "\n",
    "matplotlib.rc_file(\"../matplotlibrc\")\n",
    "\n",
    "from ldns.utils.eval_utils import (\n",
    "    get_temp_corr_summary,\n",
    "    group_neurons_temp_corr,\n",
    ")\n",
    "from ldns.utils.plotting_utils import (\n",
    "    cm2inch,\n",
    "    plot_cross_corr_summary,\n",
    "    get_group_colors,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = \"exp/stored_spike_samples/\"\n",
    "save_path = \"exp/monkey_spike_history/\"\n",
    "os.makedirs(save_path, exist_ok=True)\n",
    "\n",
    "# ------------------------- choose model -------------------------\n",
    "model_name = \"ldns\"  # \"lfads\"\n",
    "# ----------------------------------------------------------------\n",
    "\n",
    "if model_name == \"ldns\":\n",
    "    with open(data_path + \"train_data_dict.pkl\", \"rb\") as f:\n",
    "        rec_dict_numpy_train = pickle.load(f)\n",
    "elif model_name == \"lfads\":\n",
    "    with open(data_path + \"inferred_data_dict.pkl\", \"rb\") as f:\n",
    "        lfads_recons = pickle.load(f)\n",
    "    with open(data_path + \"lfads_samples.pkl\", \"rb\") as f:\n",
    "        lfads_samples = pickle.load(f)\n",
    "    # bring into the same format as the ldns data\n",
    "    rec_dict_numpy_train = {}\n",
    "    rec_dict_numpy_train[\"gt_spikes\"] = lfads_recons[\"gt_spikes\"]\n",
    "    rec_dict_numpy_train[\"ae_rates\"] = lfads_recons[\"inferred_rates\"]\n",
    "    rec_dict_numpy_train[\"ae_latents\"] = lfads_recons[\"inferred_factors\"]\n",
    "    rec_dict_numpy_train[\"diffusion_rates\"] = lfads_samples[\"model_rates\"]\n",
    "    rec_dict_numpy_train[\"diffusion_latents\"] = lfads_samples[\"model_latents\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2008, 182, 140])\n",
      "torch.Size([2008, 182, 140])\n",
      "torch.Size([2008, 182, 140])\n",
      "torch.Size([2008, 182, 140])\n"
     ]
    }
   ],
   "source": [
    "# core functions for spike history modeling and sampling\n",
    "\n",
    "\n",
    "def extract_timewise_histories(spikes, rates, history_length):\n",
    "    \"\"\"Extract spike history and rates for each time step in the data.\n",
    "\n",
    "    Args:\n",
    "        spikes: Tensor of shape (num_trials, num_neurons, num_timesteps) containing spike counts\n",
    "        rates: Tensor of shape (num_trials, num_neurons, num_timesteps) containing firing rates\n",
    "        history_length: Number of previous time steps to use as history\n",
    "\n",
    "    Returns:\n",
    "        combine_flat: Tensor of shape (num_trials*num_timesteps, num_neurons, history_length+2) containing\n",
    "            concatenated spike history, rates and offset for each neuron\n",
    "        target_flat: Tensor of shape (num_trials*num_timesteps, num_neurons) containing target spikes\n",
    "    \"\"\"\n",
    "    _num_trials, _num_neurons, num_timesteps = spikes.shape\n",
    "\n",
    "    target_ls = []\n",
    "    spike_history_ls = []\n",
    "    rates_ls = []\n",
    "    for i in range(history_length, num_timesteps):\n",
    "        target_ls.append(spikes[:, :, [i]])\n",
    "        spike_history_ls.append(spikes[:, :, i - history_length : i])\n",
    "        rates_ls.append(rates[:, :, [i]])\n",
    "\n",
    "    target = torch.stack(target_ls, dim=2)\n",
    "    spike_history = torch.stack(spike_history_ls, dim=2)\n",
    "    rates = torch.stack(rates_ls, dim=2)\n",
    "    offset = torch.ones_like(rates)\n",
    "\n",
    "    combine = torch.cat([spike_history, rates, offset], dim=3)\n",
    "    target_flat = rearrange(target, \"b n t d -> (b t d) n\")\n",
    "    combine_flat = rearrange(combine, \"b n t d -> (b t) n d\")\n",
    "\n",
    "    return combine_flat, target_flat\n",
    "\n",
    "\n",
    "class CombinedLogisiticRegression(nn.Module):\n",
    "    \"\"\"Combined logistic regression model for spike prediction.\n",
    "\n",
    "    Args:\n",
    "        num_regs: Number of neurons/regressors\n",
    "        dim: Input dimension (history_length + 2)\n",
    "        nonlin: Nonlinearity to use ('softplus', 'sigmoid', or 'exp')\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, num_regs, dim, nonlin=\"softplus\"):\n",
    "        super(CombinedLogisiticRegression, self).__init__()\n",
    "        self.linear = nn.Parameter(torch.randn(num_regs, dim))\n",
    "        self.nonlin = F.softplus\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.nonlin(torch.sum(torch.mul(x, self.linear), dim=-1))\n",
    "\n",
    "\n",
    "def sample_from_rates_zero_start(log_rates, model, history_length, max_spikes=3):\n",
    "    \"\"\"Sample spikes from rates using trained model with zero initial history.\n",
    "\n",
    "    Args:\n",
    "        log_rates: Log firing rates tensor of shape (num_trials, num_neurons, num_timesteps)\n",
    "        model: Trained CombinedLogisticRegression model\n",
    "        history_length: Number of previous timesteps to use as history\n",
    "        max_spikes: Maximum number of spikes allowed per bin\n",
    "\n",
    "    Returns:\n",
    "        Sampled spike tensor of shape (num_trials, num_neurons, num_timesteps)\n",
    "    \"\"\"\n",
    "    num_trials, num_neurons, num_timesteps = log_rates.shape\n",
    "    spikes = torch.zeros(num_trials, num_neurons, num_timesteps + history_length)\n",
    "\n",
    "    for i in range(history_length, num_timesteps + history_length):\n",
    "        reg_input = torch.cat(\n",
    "            [\n",
    "                spikes[:, :, i - history_length : i],\n",
    "                log_rates[:, :, [i - history_length]],\n",
    "                torch.ones_like(log_rates[:, :, [i - history_length]]),\n",
    "            ],\n",
    "            dim=2,\n",
    "        )\n",
    "        with torch.no_grad():\n",
    "            p = model.forward(reg_input)\n",
    "        if max_spikes == 1:\n",
    "            spikes[:, :, i] = torch.bernoulli(p)\n",
    "        else:\n",
    "            spikes[:, :, i] = torch.min(torch.poisson(p), torch.ones_like(p) * max_spikes)\n",
    "\n",
    "    return spikes[:, :, history_length:]\n",
    "\n",
    "\n",
    "# model parameters\n",
    "num_neurons = 182\n",
    "ts_length = 140\n",
    "history_length = 20\n",
    "max_spikes = 5\n",
    "\n",
    "# prepare training data\n",
    "train_spikes = torch.from_numpy(np.float32(rec_dict_numpy_train[\"gt_spikes\"]))\n",
    "train_spikes = torch.min(train_spikes, max_spikes * torch.ones_like(train_spikes))\n",
    "test_spikes = torch.from_numpy(np.float32(rec_dict_numpy_train[\"gt_spikes\"]))\n",
    "test_spikes = torch.min(test_spikes, max_spikes * torch.ones_like(test_spikes))\n",
    "\n",
    "# use autoencoder rates for training, diffusion rates for evaluation\n",
    "train_log_rates = torch.from_numpy(np.log(np.float32(rec_dict_numpy_train[\"ae_rates\"])))\n",
    "test_log_rates = torch.from_numpy(np.log(np.float32(rec_dict_numpy_train[\"diffusion_rates\"])))\n",
    "\n",
    "# transpose to (trials, neurons, timesteps)\n",
    "train_spikes = torch.transpose(train_spikes, 2, 1)\n",
    "test_spikes = torch.transpose(test_spikes, 2, 1)\n",
    "train_log_rates = torch.transpose(train_log_rates, 2, 1)\n",
    "test_log_rates = torch.transpose(test_log_rates, 2, 1)\n",
    "\n",
    "print(train_spikes.shape)\n",
    "print(train_log_rates.shape)\n",
    "print(test_spikes.shape)\n",
    "print(test_log_rates.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extract training data with spike histories\n",
    "X_train, y_train = extract_timewise_histories(train_spikes, train_log_rates, history_length)\n",
    "\n",
    "# initialize model with input size = history length + bias + rate terms\n",
    "model = CombinedLogisiticRegression(num_neurons, history_length + 2)\n",
    "\n",
    "# define poisson negative log likelihood loss\n",
    "criterion = nn.PoissonNLLLoss(log_input=False, full=True)\n",
    "\n",
    "# initialize optimizer with learning rate and weight decay\n",
    "# note: lr=0.1, weight_decay=0.01 gives good results for poisson\n",
    "optimizer = optim.AdamW(model.parameters(), lr=0.1, weight_decay=0.01)\n",
    "\n",
    "# move model and data to gpu if available\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model.to(device)\n",
    "X_train = X_train.to(device)\n",
    "y_train = y_train.to(device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: train loss: 2.0188992023468018\n",
      "Epoch 100: train loss: 0.0838230699300766\n",
      "Epoch 200: train loss: 0.08239946514368057\n",
      "Epoch 300: train loss: 0.08219365775585175\n",
      "Epoch 400: train loss: 0.08213771879673004\n",
      "Epoch 500: train loss: 0.08210327476263046\n",
      "Epoch 600: train loss: 0.0820770412683487\n",
      "Epoch 700: train loss: 0.08205695450305939\n",
      "Epoch 800: train loss: 0.08204136788845062\n",
      "Epoch 900: train loss: 0.08202902227640152\n",
      "Epoch 1000: train loss: 0.08201905339956284\n",
      "Epoch 1100: train loss: 0.08201086521148682\n",
      "Epoch 1200: train loss: 0.08200402557849884\n",
      "Epoch 1300: train loss: 0.08199848979711533\n",
      "Epoch 1400: train loss: 0.08199328929185867\n",
      "Epoch 1500: train loss: 0.08198953419923782\n",
      "Epoch 1600: train loss: 0.08198526501655579\n",
      "Epoch 1700: train loss: 0.08198193460702896\n",
      "Epoch 1800: train loss: 0.08197960257530212\n",
      "Epoch 1900: train loss: 0.0819764956831932\n",
      "Epoch 2000: train loss: 0.0819738581776619\n",
      "Epoch 2100: train loss: 0.08197180926799774\n",
      "Epoch 2200: train loss: 0.0819697305560112\n",
      "Epoch 2300: train loss: 0.0819678008556366\n",
      "Epoch 2400: train loss: 0.08196611702442169\n",
      "Epoch 2500: train loss: 0.08196454495191574\n",
      "Epoch 2600: train loss: 0.08196334540843964\n",
      "Epoch 2700: train loss: 0.08196188509464264\n",
      "Epoch 2800: train loss: 0.08196105808019638\n",
      "Epoch 2900: train loss: 0.08195968717336655\n"
     ]
    }
   ],
   "source": [
    "# train model for 3000 epochs, storing losses for plotting\n",
    "store_losses = []\n",
    "for epoch in range(3000):\n",
    "    model.train()\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    y_pred = model(X_train)\n",
    "    loss = criterion(y_pred.squeeze(), y_train.float())\n",
    "\n",
    "    if epoch % 100 == 0:\n",
    "        print(\"Epoch {}: train loss: {}\".format(epoch, loss.item()))\n",
    "    store_losses.append(loss.item())\n",
    "    loss.backward()\n",
    "    optimizer.step()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n",
      "5.0\n",
      "5.0\n"
     ]
    }
   ],
   "source": [
    "# move model to cpu for sampling\n",
    "model = model.cpu()\n",
    "\n",
    "# generate spike samples using history-dependent model\n",
    "hist_spikes = sample_from_rates_zero_start(\n",
    "    test_log_rates,\n",
    "    model,\n",
    "    history_length,\n",
    "    max_spikes=max_spikes,\n",
    ")\n",
    "\n",
    "# convert test spikes to numpy\n",
    "test_spikes_numpy = test_spikes.numpy()\n",
    "\n",
    "# generate poisson spike samples with rate capping\n",
    "pois_spikes_numpy = torch.min(\n",
    "    torch.poisson(torch.exp(test_log_rates)),\n",
    "    torch.ones_like(test_log_rates) * max_spikes,\n",
    ").numpy()\n",
    "\n",
    "# convert history-dependent samples to numpy\n",
    "hist_spikes_numpy = hist_spikes.numpy()\n",
    "\n",
    "# print max spike counts to verify capping worked\n",
    "print(np.max(test_spikes_numpy))\n",
    "print(np.max(pois_spikes_numpy))\n",
    "print(np.max(hist_spikes_numpy))\n",
    "\n",
    "# transpose arrays to (batch, neuron, time) format for correlation analysis\n",
    "test_spikes_numpy = test_spikes_numpy.transpose(0, 2, 1)\n",
    "pois_spikes_numpy = pois_spikes_numpy.transpose(0, 2, 1)\n",
    "hist_spikes_numpy = hist_spikes_numpy.transpose(0, 2, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute the auto and cross correlations (5 min run time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# group neurons based on temporal correlations into 4 groups\n",
    "groups = group_neurons_temp_corr(test_spikes_numpy.transpose(1, 0, 2), num_groups=4)\n",
    "\n",
    "# compute cross and auto correlations for test data\n",
    "cross_corr_groups_test, auto_corr_groups_test = get_temp_corr_summary(\n",
    "    test_spikes_numpy.transpose(1, 0, 2),\n",
    "    groups,\n",
    "    nlags=30,\n",
    "    mode=\"biased\",\n",
    "    batch_first=False,\n",
    ")\n",
    "\n",
    "# compute cross and auto correlations for poisson samples\n",
    "cross_corr_groups_pois, auto_corr_groups_pois = get_temp_corr_summary(\n",
    "    pois_spikes_numpy.transpose(1, 0, 2),\n",
    "    groups,\n",
    "    nlags=30,\n",
    "    mode=\"biased\",\n",
    "    batch_first=False,\n",
    ")\n",
    "\n",
    "# compute cross and auto correlations for history-dependent samples\n",
    "cross_corr_groups_hist, auto_corr_groups_hist = get_temp_corr_summary(\n",
    "    hist_spikes_numpy.transpose(1, 0, 2),\n",
    "    groups,\n",
    "    nlags=30,\n",
    "    mode=\"biased\",\n",
    "    batch_first=False,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def history_plot_cross_corr_summary(\n",
    "    cross_corr_groups,\n",
    "    binWidth=None,\n",
    "    cmap=\"Reds\",\n",
    "    figsize=(6, 4),\n",
    "    linestyle=\"-\",\n",
    "    ax_corr=None,\n",
    "    labels=\"group\",\n",
    "    title=\"cross-corr\",\n",
    "    xlabel=\"lag\",\n",
    "    ms=2,\n",
    "    lw=1.5,\n",
    "):\n",
    "    \"\"\"Plot cross-correlation summary for multiple groups.\n",
    "\n",
    "    Args:\n",
    "        cross_corr_groups: List of cross-correlation arrays for each group\n",
    "        binWidth: Width of time bins for x-axis scaling\n",
    "        cmap: Colormap name for group colors\n",
    "        figsize: Figure size in inches\n",
    "        linestyle: Line style for plots\n",
    "        ax_corr: Existing axes to plot on (creates new if None)\n",
    "        labels: Prefix for group labels in legend\n",
    "        title: Plot title\n",
    "        xlabel: x-axis label\n",
    "        ms: Marker size\n",
    "        lw: Line width\n",
    "\n",
    "    Returns:\n",
    "        matplotlib axes object with plotted correlations\n",
    "    \"\"\"\n",
    "    # get number of groups and corresponding colors\n",
    "    num_groups = len(cross_corr_groups)\n",
    "    g_colors = get_group_colors(num_groups, cmap)\n",
    "\n",
    "    # create new axes if not provided\n",
    "    if ax_corr is None:\n",
    "        fig_corr, ax_corr = plt.subplots(figsize=figsize)\n",
    "    ax_corr.set_title(title)\n",
    "\n",
    "    # calculate x-axis ticks based on lags\n",
    "    nlag = int((len(cross_corr_groups[0]) - 1) / 2)\n",
    "    x_ticks = np.arange(-nlag, nlag + 1, 1)\n",
    "\n",
    "    # scale x-ticks by bin width if provided\n",
    "    if binWidth is not None:\n",
    "        x_ticks = x_ticks * binWidth\n",
    "\n",
    "    # plot correlation for each group\n",
    "    for ind in range(num_groups):\n",
    "        # set center lag to nan to avoid self-correlation spike\n",
    "        cross_corr_groups[ind][nlag] = np.nan\n",
    "        ax_corr.plot(\n",
    "            x_ticks,\n",
    "            cross_corr_groups[ind],\n",
    "            linestyle,\n",
    "            lw=lw,\n",
    "            ms=ms,\n",
    "            color=g_colors[num_groups - ind - 1],\n",
    "            label=f\"{labels} {ind + 1}\",\n",
    "            solid_capstyle=\"round\",\n",
    "        )\n",
    "    ax_corr.set_xlabel(xlabel)\n",
    "\n",
    "    return ax_corr\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fa8381d65b0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1003.94x295.276 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot autocorrelation comparison between ground truth, history-based and poisson models\n",
    "fig, ax = plt.subplots(1, 2, figsize=cm2inch(8.5, 2.5))\n",
    "\n",
    "# left subplot: ground truth vs poisson model\n",
    "history_plot_cross_corr_summary(\n",
    "    auto_corr_groups_test[:2],\n",
    "    figsize=cm2inch(5, 3),\n",
    "    cmap=\"Greys\",\n",
    "    ax_corr=ax[0],\n",
    "    labels=\"gt \",\n",
    ")\n",
    "history_plot_cross_corr_summary(\n",
    "    auto_corr_groups_pois[:2],\n",
    "    figsize=cm2inch(5, 3),\n",
    "    cmap=\"Reds\" if model_name == \"ldns\" else \"Purples\",\n",
    "    ax_corr=ax[0],\n",
    "    labels=\"diff \",\n",
    "    title=f\"{model_name} Poisson\",\n",
    ")\n",
    "\n",
    "# right subplot: ground truth vs history-based model\n",
    "history_plot_cross_corr_summary(\n",
    "    auto_corr_groups_test[:2],\n",
    "    figsize=cm2inch(5, 3),\n",
    "    cmap=\"Greys\",\n",
    "    ax_corr=ax[1],\n",
    "    labels=\"gt \",\n",
    ")\n",
    "history_plot_cross_corr_summary(\n",
    "    auto_corr_groups_hist[:2],\n",
    "    figsize=cm2inch(5, 3),\n",
    "    cmap=\"Greens\" if model_name == \"ldns\" else \"RdPu\",\n",
    "    ax_corr=ax[1],\n",
    "    labels=\"diff \",\n",
    "    title=f\"{model_name} with spike history\",\n",
    ")\n",
    "\n",
    "# format axes\n",
    "ax[1].set_yticklabels([])\n",
    "ax[0].set_ylabel(\"auto-corr\")\n",
    "ax[0].legend(fontsize=4, loc=\"lower right\")\n",
    "ax[1].legend(fontsize=4, loc=\"lower right\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sample spikes multiple times from history-based model\n",
    "history_spikes = []\n",
    "\n",
    "# generate 5 different samples using the history-based model\n",
    "for i in range(5):\n",
    "    # sample spikes using history-based model\n",
    "    hist_spikes = sample_from_rates_zero_start(\n",
    "        test_log_rates,\n",
    "        model,\n",
    "        history_length,\n",
    "        max_spikes=max_spikes,\n",
    "    )\n",
    "\n",
    "    # convert all spike arrays to numpy and transpose to (batch, time, neurons)\n",
    "    test_spikes_numpy = test_spikes.numpy().transpose(0, 2, 1)\n",
    "    hist_spikes_numpy = hist_spikes.numpy().transpose(0, 2, 1)\n",
    "    pois_spikes_numpy = (\n",
    "        torch.min(\n",
    "            torch.poisson(torch.exp(test_log_rates)),\n",
    "            torch.ones_like(test_log_rates) * max_spikes,\n",
    "        )\n",
    "        .numpy()\n",
    "        .transpose(0, 2, 1)\n",
    "    )\n",
    "\n",
    "    history_spikes.append(hist_spikes_numpy)\n",
    "\n",
    "# create dictionary with ground truth, poisson samples, rates and history samples\n",
    "history_sampled_dict = {\n",
    "    \"gt\": test_spikes_numpy,\n",
    "    \"pois\": pois_spikes_numpy,\n",
    "    \"rate\": torch.exp(test_log_rates).numpy().transpose(0, 2, 1),\n",
    "    \"hist\": history_spikes,\n",
    "}\n",
    "\n",
    "# save results to pickle file\n",
    "with open(data_path + f\"history_sampled_dict_{model_name}_{max_spikes}.pkl\", \"wb\") as f:\n",
    "    pickle.dump(history_sampled_dict, f)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use these saved files in the comparisons notebook\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ldiff",
   "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.9.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}