Demo_decoding.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decoding from a CEBRA embedding\n",
    "\n",
    "In this notebook, we show how to:\n",
    "\n",
    "- decode labels from a CEBRA embedding.\n",
    "- evaluate and compare the decoding performances for embeddings obtained from different hypotheses.\n",
    "\n",
    "It is based on what was presented in [Figure 2.d.](https://cebra.ai/docs/cebra-figures/figures/Figure2.html) of Schneider, Lee, Mathis."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Install note**\n",
    "- Be sure you have cebra, and the demo dependencies, installed to use this notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install --pre 'cebra[datasets,demos]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import cebra\n",
    "import cebra.datasets\n",
    "from cebra import CEBRA"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the data"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The data will be automatically downloaded into a `/data` folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10.0M/10.0M [00:01<00:00, 7.68MB/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Download complete. Dataset saved in 'data/rat_hippocampus/achilles.jl'\n"
     ]
    }
   ],
   "source": [
    "hippocampus_pos = cebra.datasets.init('rat-hippocampus-single-achilles')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**------------------- BEGINNING OF TRAINING SECTION -------------------**\n",
    "\n",
    "## Train the models\n",
    "\n",
    "*[This can be skipped if you already saved the models].*"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- For a quick CPU run-time demo, you can drop `max_iterations` to 100-500; otherwise set to 5000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_iterations = 10000 #default is 5000.\n",
    "output_dimension = 32 #here, we set as a variable for hypothesis testing below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_data(data, test_ratio):\n",
    "\n",
    "    split_idx = int(len(data)* (1-test_ratio))\n",
    "    neural_train = data.neural[:split_idx]\n",
    "    neural_test = data.neural[split_idx:]\n",
    "    label_train = data.continuous_index[:split_idx]\n",
    "    label_test = data.continuous_index[split_idx:]\n",
    "    \n",
    "    return neural_train.numpy(), neural_test.numpy(), label_train.numpy(), label_test.numpy()\n",
    "\n",
    "neural_train, neural_test, label_train, label_test = split_data(hippocampus_pos, 0.2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train CEBRA-Behavior with position, or direction, and/or both variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cebra_posdir_model = CEBRA(model_architecture='offset10-model',\n",
    "                        batch_size=512,\n",
    "                        learning_rate=3e-4,\n",
    "                        temperature=1,\n",
    "                        output_dimension=output_dimension,\n",
    "                        max_iterations=max_iterations,\n",
    "                        distance='cosine',\n",
    "                        conditional='time_delta',\n",
    "                        device='cuda_if_available',\n",
    "                        verbose=True,\n",
    "                        time_offsets=10)\n",
    "\n",
    "cebra_pos_model = CEBRA(model_architecture='offset10-model',\n",
    "                        batch_size=512,\n",
    "                        learning_rate=3e-4,\n",
    "                        temperature=1,\n",
    "                        output_dimension=output_dimension,\n",
    "                        max_iterations=max_iterations,\n",
    "                        distance='cosine',\n",
    "                        conditional='time_delta',\n",
    "                        device='cuda_if_available',\n",
    "                        verbose=True,\n",
    "                        time_offsets=10)\n",
    "\n",
    "cebra_dir_model = CEBRA(model_architecture='offset10-model',\n",
    "                        batch_size=512,\n",
    "                        learning_rate=3e-4,\n",
    "                        temperature=1,\n",
    "                        output_dimension=output_dimension,\n",
    "                        max_iterations=max_iterations,\n",
    "                        distance='cosine',\n",
    "                        device='cuda_if_available',\n",
    "                        verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "pos:  0.1180 neg:  5.3896 total:  5.5076 temperature:  1.0000: 100%|██████████| 10000/10000 [03:18<00:00, 50.48it/s]\n",
      "pos:  0.1162 neg:  5.4925 total:  5.6087 temperature:  1.0000: 100%|██████████| 10000/10000 [03:11<00:00, 52.27it/s]\n",
      "pos:  0.0633 neg:  5.5938 total:  5.6571 temperature:  1.0000: 100%|██████████| 10000/10000 [03:14<00:00, 51.33it/s]\n"
     ]
    }
   ],
   "source": [
    "# Train CEBRA-Behavior models with both position and direction variables.\n",
    "cebra_posdir_model.fit(neural_train, label_train)\n",
    "cebra_posdir_model.save(\"cebra_posdir_model.pt\")\n",
    "\n",
    "# Train CEBRA-Behavior models with position or direction variable.\n",
    "cebra_pos_model.fit(neural_train, label_train[:,0])\n",
    "cebra_pos_model.save(\"cebra_pos_model.pt\")\n",
    "\n",
    "cebra_dir_model.fit(neural_train, label_train[:,1])\n",
    "cebra_dir_model.save(\"cebra_dir_model.pt\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train shuffled CEBRA-Behavior with position, direction variables and both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cebra_posdir_shuffled_model = CEBRA(model_architecture='offset10-model',\n",
    "                        batch_size=512,\n",
    "                        learning_rate=3e-4,\n",
    "                        temperature=1,\n",
    "                        output_dimension=output_dimension,\n",
    "                        max_iterations=max_iterations,\n",
    "                        distance='cosine',\n",
    "                        conditional='time_delta',\n",
    "                        device='cuda_if_available',\n",
    "                        verbose=True,\n",
    "                        time_offsets=10)\n",
    "\n",
    "cebra_pos_shuffled_model = CEBRA(model_architecture='offset10-model',\n",
    "                        batch_size=512,\n",
    "                        learning_rate=3e-4,\n",
    "                        temperature=1,\n",
    "                        output_dimension=output_dimension,\n",
    "                        max_iterations=max_iterations,\n",
    "                        distance='cosine',\n",
    "                        conditional='time_delta',\n",
    "                        device='cuda_if_available',\n",
    "                        verbose=True,\n",
    "                        time_offsets=10)\n",
    "\n",
    "cebra_dir_shuffled_model = CEBRA(model_architecture='offset10-model',\n",
    "                        batch_size=512,\n",
    "                        learning_rate=3e-4,\n",
    "                        temperature=1,\n",
    "                        output_dimension=output_dimension,\n",
    "                        max_iterations=max_iterations,\n",
    "                        distance='cosine',\n",
    "                        device='cuda_if_available',\n",
    "                        verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "pos:  0.3144 neg:  5.8153 total:  6.1297 temperature:  1.0000: 100%|██████████| 10000/10000 [03:20<00:00, 49.80it/s]\n",
      "pos:  0.3112 neg:  5.8201 total:  6.1313 temperature:  1.0000: 100%|██████████| 10000/10000 [03:02<00:00, 54.89it/s]\n",
      "pos:  0.1834 neg:  5.8177 total:  6.0012 temperature:  1.0000: 100%|██████████| 10000/10000 [02:31<00:00, 65.90it/s]\n"
     ]
    }
   ],
   "source": [
    "# Generate shuffled behavior labels for train set.\n",
    "shuffled_posdir = np.random.permutation(label_train)\n",
    "shuffled_pos = np.random.permutation(label_train[:,0])\n",
    "shuffled_dir = np.random.permutation(label_train[:,1])\n",
    "\n",
    "\n",
    "# Train the models with shuffled behavior variables\n",
    "cebra_posdir_shuffled_model.fit(neural_train, shuffled_posdir)\n",
    "cebra_posdir_shuffled_model.save(\"cebra_posdir_shuffled_model.pt\")\n",
    "\n",
    "cebra_pos_shuffled_model.fit(neural_train, shuffled_pos)\n",
    "cebra_pos_shuffled_model.save(\"cebra_pos_shuffled_model.pt\")\n",
    "\n",
    "cebra_dir_shuffled_model.fit(neural_train, shuffled_dir)\n",
    "cebra_dir_shuffled_model.save(\"cebra_dir_shuffled_model.pt\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**------------------- END OF TRAINING SECTION -------------------**\n",
    "\n",
    "## Load the models and get the corresponding embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We get train set embedding and test set embedding. \n",
    "\n",
    "cebra_posdir_model = cebra.CEBRA.load(\"cebra_posdir_model.pt\")\n",
    "cebra_posdir_train = cebra_posdir_model.transform(neural_train)\n",
    "cebra_posdir_test = cebra_posdir_model.transform(neural_test)\n",
    "\n",
    "cebra_pos_model = cebra.CEBRA.load(\"cebra_pos_model.pt\")\n",
    "cebra_pos_train = cebra_pos_model.transform(neural_train)\n",
    "cebra_pos_test = cebra_pos_model.transform(neural_test)\n",
    "\n",
    "cebra_dir_model = cebra.CEBRA.load(\"cebra_dir_model.pt\")\n",
    "cebra_dir_train = cebra_dir_model.transform(neural_train)\n",
    "cebra_dir_test = cebra_dir_model.transform(neural_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ... and similarily for models with shuffled variables\n",
    "\n",
    "cebra_posdir_shuffled_model = cebra.CEBRA.load(\"cebra_posdir_shuffled_model.pt\")\n",
    "cebra_posdir_shuffled_train = cebra_posdir_shuffled_model.transform(neural_train)\n",
    "cebra_posdir_shuffled_test = cebra_posdir_shuffled_model.transform(neural_test)\n",
    "\n",
    "cebra_pos_shuffled_model = cebra.CEBRA.load(\"cebra_pos_shuffled_model.pt\")\n",
    "cebra_pos_shuffled_train = cebra_pos_shuffled_model.transform(neural_train)\n",
    "cebra_pos_shuffled_test = cebra_pos_shuffled_model.transform(neural_test)\n",
    "\n",
    "cebra_dir_shuffled_model = cebra.CEBRA.load(\"cebra_dir_shuffled_model.pt\")\n",
    "cebra_dir_shuffled_train = cebra_dir_shuffled_model.transform(neural_train)\n",
    "cebra_dir_shuffled_test = cebra_dir_shuffled_model.transform(neural_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cebra_pos_all = cebra_pos_model.transform(hippocampus_pos.neural)\n",
    "cebra_dir_all = cebra_dir_model.transform(hippocampus_pos.neural)\n",
    "cebra_posdir_all = cebra_posdir_model.transform(hippocampus_pos.neural)\n",
    "\n",
    "cebra_pos_shuffled_all = cebra_pos_shuffled_model.transform(hippocampus_pos.neural)\n",
    "cebra_dir_shuffled_all = cebra_dir_shuffled_model.transform(hippocampus_pos.neural)\n",
    "cebra_posdir_shuffled_all = cebra_posdir_shuffled_model.transform(hippocampus_pos.neural)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decode the labels from the embeddings\n",
    "We evaluate decoding performance of the different hypothesis models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn.metrics\n",
    "\n",
    "# Define decoding function with kNN decoder. For a simple demo, we will use the fixed number of neighbors 36.\n",
    "def decoding_pos_dir(embedding_train, embedding_test, label_train, label_test):\n",
    "   pos_decoder = cebra.KNNDecoder(n_neighbors=36, metric=\"cosine\")\n",
    "   dir_decoder = cebra.KNNDecoder(n_neighbors=36, metric=\"cosine\")\n",
    "   \n",
    "   pos_decoder.fit(embedding_train, label_train[:,0])\n",
    "   dir_decoder.fit(embedding_train, label_train[:,1])\n",
    "   \n",
    "   pos_pred = pos_decoder.predict(embedding_test)\n",
    "   dir_pred = dir_decoder.predict(embedding_test)\n",
    "   \n",
    "   prediction = np.stack([pos_pred, dir_pred],axis = 1)\n",
    "   \n",
    "   test_score = sklearn.metrics.r2_score(label_test[:,:2], prediction)\n",
    "   pos_test_err = np.median(abs(prediction[:,0] - label_test[:, 0]))\n",
    "   pos_test_score = sklearn.metrics.r2_score(label_test[:, 0], prediction[:,0])\n",
    "   \n",
    "   return test_score, pos_test_err, pos_test_score"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decode the position and direction from the trained hypothesis models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cebra_posdir_decode = decoding_pos_dir(cebra_posdir_train, cebra_posdir_test, label_train, label_test)\n",
    "cebra_pos_decode = decoding_pos_dir(cebra_pos_train, cebra_pos_test, label_train, label_test)\n",
    "cebra_dir_decode = decoding_pos_dir(cebra_dir_train, cebra_dir_test, label_train, label_test)\n",
    "\n",
    "cebra_posdir_shuffled_decode = decoding_pos_dir(cebra_posdir_shuffled_train, cebra_posdir_shuffled_test, label_train, label_test)\n",
    "cebra_pos_shuffled_decode = decoding_pos_dir(cebra_pos_shuffled_train, cebra_pos_shuffled_test, label_train, label_test)\n",
    "cebra_dir_shuffled_decode = decoding_pos_dir(cebra_dir_shuffled_train, cebra_dir_shuffled_test, label_train, label_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize the decoding results and loss - decoding performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10,4))\n",
    "\n",
    "ax1= plt.subplot(121)\n",
    "ax1.bar(np.arange(6), \n",
    "        [cebra_posdir_decode[1], cebra_pos_decode[1], cebra_dir_decode[1], \n",
    "         cebra_posdir_shuffled_decode[1], cebra_pos_shuffled_decode[1], cebra_dir_shuffled_decode[1]],\n",
    "         width = 0.5, color = 'gray')\n",
    "ax1.spines['top'].set_visible(False)\n",
    "ax1.spines['right'].set_visible(False)\n",
    "ax1.set_xticks(np.arange(6))\n",
    "ax1.set_xticklabels(['pos+dir', 'pos', 'dir', 'pos+dir,\\nshuffled', 'pos,\\nshuffled', 'dir,\\nshuffled'])\n",
    "ax1.set_ylabel('Median err. [m]')\n",
    "\n",
    "ax2 = plt.subplot(122)\n",
    "ax2.scatter(cebra_posdir_model.state_dict_['loss'][-1],cebra_posdir_decode[1], s=50, c='deepskyblue', label = 'position+direction')\n",
    "ax2.scatter(cebra_pos_model.state_dict_['loss'][-1],cebra_pos_decode[1], s=50, c='deepskyblue', alpha = 0.3, label = 'position_only')\n",
    "ax2.scatter(cebra_dir_model.state_dict_['loss'][-1],cebra_dir_decode[1], s=50, c='deepskyblue', alpha=0.6,label = 'direction_only')\n",
    "ax2.scatter(cebra_posdir_shuffled_model.state_dict_['loss'][-1],cebra_posdir_shuffled_decode[1], s=50, c='gray', label = 'pos+dir, shuffled')\n",
    "ax2.scatter(cebra_pos_shuffled_model.state_dict_['loss'][-1],cebra_pos_shuffled_decode[1], s=50, c='gray', alpha = 0.3, label = 'position, shuffled')\n",
    "ax2.scatter(cebra_dir_shuffled_model.state_dict_['loss'][-1],cebra_dir_shuffled_decode[1], s=50, c='gray', alpha=0.6,label = 'direction, shuffled')\n",
    "\n",
    "ax2.spines['top'].set_visible(False)\n",
    "ax2.spines['right'].set_visible(False)\n",
    "ax2.set_xlabel('InfoNCE Loss')\n",
    "ax2.set_ylabel('Decoding Median Err.')\n",
    "plt.legend(bbox_to_anchor=(1,1), frameon = False )\n",
    "plt.show()"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}