{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1c2478f9",
   "metadata": {},
   "source": [
    "# Kinematic decoding\n",
    "\n",
    "This notebook compares the decoding performance of MARBLE with CEBRA and TDR on a macaque centre-out reaching task. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cae68224-84f6-43fd-82f4-bba80b806780",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib widget\n",
    "\n",
    "!pip install statannotations ipympl\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import seaborn as sns\n",
    "from statannotations.Annotator import Annotator\n",
    "from sklearn.model_selection import KFold\n",
    "from macaque_reaching_helpers import *\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1d50682-1117-4481-854d-76d2563a200b",
   "metadata": {
    "tags": []
   },
   "source": [
    "Load firing rate and kinematics data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2883f5a-4789-49e2-8d43-1b3946c3a4fd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!mkdir data\n",
    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/6969885 -O data/kinematics.pkl\n",
    "\n",
    "with open('data/kinematics.pkl', 'rb') as handle:\n",
    "    data = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94051207",
   "metadata": {},
   "source": [
    "# Load MARBLE and CEBRA embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9bc422a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/7062022 -O data/marble_embeddings_out20_pca5_100ms.pkl\n",
    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/7509031 -O data/cebra_embeddings_out20_pca5_100ms.pkl\n",
    "\n",
    "with open('data/marble_embeddings_out20_pca5_100ms.pkl', 'rb') as handle:\n",
    "    _, marble_embeddings, _, _, trial_ids, _  = pickle.load(handle)\n",
    "\n",
    "with open('data/cebra_embeddings_out20_pca5_100ms.pkl', 'rb') as handle:\n",
    "    _, cebra_embeddings, _, _, _, _ = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a66b1c78-ebdc-44d7-a249-ba39659538e3",
   "metadata": {},
   "source": [
    "# Load raw firing rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d25686c-08c0-40d1-8528-61056a3bc9c6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pca_n = 5\n",
    "filter_data = True\n",
    "conditions=['DownLeft','Left','UpLeft','Up','UpRight','Right','DownRight']  \n",
    "\n",
    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/6969883 -O data/rate_data_20ms_100ms.pkl\n",
    "\n",
    "with open('data/rate_data_20ms_100ms.pkl', 'rb') as handle:\n",
    "    rates = pickle.load(handle)\n",
    "\n",
    "!wget -nc https://dataverse.harvard.edu/api/access/datafile/6963200 -O data/trial_ids.pkl\n",
    "\n",
    "with open('data/trial_ids.pkl', 'rb') as handle:\n",
    "    trials = pickle.load(handle)\n",
    "    \n",
    "pos, pos_raw = [], []\n",
    "for day in rates.keys():\n",
    "    #preprocess by PCA dimensionality reduction and smoothing\n",
    "    pca = fit_pca(rates, day, conditions, filter_data=filter_data, pca_n=pca_n)\n",
    "    pos_, _, _, _, _ = format_data(rates, \n",
    "                                   trials,\n",
    "                                   day, \n",
    "                                   conditions, \n",
    "                                   pca=pca,\n",
    "                                   filter_data=filter_data,\n",
    "                                  )\n",
    "\n",
    "    #no preprocessing for comparison\n",
    "    pos_raw_, _, _, _, _ = format_data(rates, \n",
    "                                   trials,\n",
    "                                   day, \n",
    "                                   conditions,\n",
    "                                  )\n",
    "    \n",
    "    pos.append(np.vstack(pos_))\n",
    "    pos_raw.append(np.vstack(pos_raw_))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2c473e3-48e8-403a-8384-b98541a6535c",
   "metadata": {},
   "source": [
    "### Targeted Dimensionality Reduction (TDR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d41142bd-2b2e-4d74-8808-e7aac0b5b66b",
   "metadata": {},
   "outputs": [],
   "source": [
    "condition_labels = {'DownLeft': [1,[-1, -1]], \n",
    "                    'Left': [2, [-1, 0]], \n",
    "                    'UpLeft': [3,[-1, 1]], \n",
    "                    'Up': [4,[0, 1]], \n",
    "                    'UpRight': [5,[1, 1]], \n",
    "                    'Right': [6,[1, 0]], \n",
    "                    'DownRight': [7,[1, -1]]} \n",
    "\n",
    "TDR_embeddings = {}\n",
    "for day in tqdm(rates.keys()):\n",
    "    unique_trial_ids = np.unique(trial_ids[day])\n",
    "    Z, X, cond = [], [], []\n",
    "    for t in unique_trial_ids:\n",
    "        c_l = data[day][t]['condition']\n",
    "        firing_rates = pos_raw[day][trial_ids[day]==t,:].T\n",
    "        c = np.tile(condition_labels[c_l][1], (firing_rates.shape[1],1))\n",
    "        regressors = np.hstack([c, np.ones([firing_rates.shape[1], 1])])\n",
    "        \n",
    "        Z.append(firing_rates)\n",
    "        X.append(regressors)\n",
    "        cond.append(condition_labels[c_l][0])\n",
    "    \n",
    "    Z = np.stack(Z, axis=2)\n",
    "    X = np.stack(X, axis=2)\n",
    "    cond = np.hstack(cond)\n",
    "    \n",
    "    #standardise per neuron\n",
    "    Z -= Z.mean(axis=(1,2), keepdims=True)\n",
    "    Z /= Z.std(axis=(1,2), keepdims=True)\n",
    "    \n",
    "    [n, T, tr] = Z.shape\n",
    "    n_reg = X.shape[1]\n",
    "    \n",
    "    #compute TDR regression coefficients\n",
    "    betaBehav2Neural = np.zeros([T,n,n_reg-1])\n",
    "    for i in range(T):\n",
    "        Ztrain = Z[:,i,:].T\n",
    "        Xtrain = X[i,:,:].T\n",
    "    \n",
    "        reg = np.linalg.lstsq(Xtrain, Ztrain, rcond=None)[0]\n",
    "        reg = np.linalg.pinv(reg) # Compute the TDR axes.\n",
    "        reg = reg[:,:-1] # remove last regressor (bias)\n",
    "    \n",
    "        betaBehav2Neural[i,:,:] = reg\n",
    "    \n",
    "    #project data to TDR subspace\n",
    "    Zproj = np.zeros([n_reg-1,T,tr])\n",
    "    for i in range(T):\n",
    "        Zt = Z[:,i,:].T \n",
    "        regt = betaBehav2Neural[i,:,:]\n",
    "        Zproj[:,i,:] = (Zt @ regt).T\n",
    "\n",
    "    TDR_embeddings[day] = Zproj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f9c6226-2c82-4177-bf85-4a6ed75ee47a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot\n",
    "plt.figure()\n",
    "colors = plt.cm.viridis(np.linspace(0,1,7))\n",
    "for j in range(tr):\n",
    "    c = cond[j]-1\n",
    "    plt.plot(Zproj[0,:,j], Zproj[1,:,j], c = colors[c])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1638c8f-f4b7-450b-a16c-981a74353417",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# match the neural representations to the kinematics\n",
    "for day in data.keys():\n",
    "    unique_trial_ids = np.unique(trial_ids[day])\n",
    "    for i, t in enumerate(unique_trial_ids):\n",
    "        data[day][t]['kinematics'] = data[day][t]['kinematics'][:,:-1] #remove last point because\n",
    "        data[day][t]['lfads_factors'] = data[day][t]['lfads_factors'][:,:-1] \n",
    "        data[day][t]['marble_emb'] = marble_embeddings[day][trial_ids[day]==t,:].T\n",
    "        data[day][t]['firing_rates'] = pos[day][trial_ids[day]==t,:].T\n",
    "        data[day][t]['cebra_emb'] = cebra_embeddings[day][trial_ids[day]==t,:].T\n",
    "        data[day][t]['raw_firing_rates'] = pos_raw[day][trial_ids[day]==t,:].T\n",
    "        data[day][t]['TDR_emb'] = TDR_embeddings[day][:,:,i]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49b9822e-5817-4022-a5f9-3d5962877b60",
   "metadata": {},
   "source": [
    "# Visualise kinematics for a single session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22176228-1e45-445f-acd7-180c4b5c22b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "session = 0\n",
    "\n",
    "colors = plt.cm.viridis(np.linspace(0,1,7))\n",
    "\n",
    "# plot average kinematic position across trials for a given session\n",
    "plt.figure()\n",
    "for c,cond in enumerate(conditions):   \n",
    "    meh = np.dstack([data[session][t]['kinematics'] for t in data[session].keys() if data[session][t]['condition']==cond]).mean(2)        \n",
    "    plt.plot(meh[0,:],meh[1,:],c=colors[c])\n",
    "plt.title('average kinematic hand position across trials')\n",
    "\n",
    "# plot kinematic position for each trials in a given session\n",
    "plt.figure()\n",
    "for c,cond in enumerate(conditions):   \n",
    "    for t in data[session].keys():\n",
    "        if data[session][t]['condition']==cond:\n",
    "            meh = data[session][t]['kinematics']\n",
    "            plt.plot(meh[0,:],meh[1,:],c=colors[c])\n",
    "plt.title('per trial kinematic hand position')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76a52b47",
   "metadata": {},
   "source": [
    "# Decoding single session"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e70f5fe-6cd8-46dd-ae95-269f5b449bd8",
   "metadata": {},
   "source": [
    "### Optimal linear decoding via LFADS, MARBLE and CEBRA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cb13479",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "session = 0\n",
    "\n",
    "unique_trial_ids = np.unique(trial_ids[session])\n",
    "\n",
    "L_lfads = train_OLE(data[session], trial_ids[session], representation='lfads_factors')\n",
    "\n",
    "# loop over test trials\n",
    "for tr in unique_trial_ids:\n",
    "    trial_pred = decode_kinematics(data[session][tr], L_lfads, dt=20, representation='lfads_factors')\n",
    "    data[session][tr]['lfads_decoded'] = trial_pred\n",
    "\n",
    "L_firing_rates = train_OLE(data[session], trial_ids[session], representation='firing_rates')\n",
    "\n",
    "# loop over test trials\n",
    "for tr in unique_trial_ids:\n",
    "    trial_pred = decode_kinematics(data[session][tr], L_firing_rates, dt=20, representation='firing_rates')\n",
    "    data[session][tr]['firing_rates_decoded'] = trial_pred\n",
    "\n",
    "L_marble = train_OLE(data[session], trial_ids[session], representation='marble_emb')\n",
    "\n",
    "# loop over test trials\n",
    "for tr in unique_trial_ids:\n",
    "    trial_pred = decode_kinematics(data[session][tr], L_marble, dt=20, representation='marble_emb')\n",
    "    data[session][tr]['marble_decoded'] = trial_pred\n",
    "    \n",
    "L_cebra = train_OLE(data[session], trial_ids[session], representation='cebra_emb')\n",
    "\n",
    "# loop over test trials\n",
    "for tr in unique_trial_ids:\n",
    "    trial_pred = decode_kinematics(data[session][tr], L_cebra, dt=20, representation='cebra_emb')\n",
    "    data[session][tr]['cebra_decoded'] = trial_pred\n",
    "\n",
    "L_TDR = train_OLE(data[session], trial_ids[session], representation='TDR_emb')\n",
    "\n",
    "# loop over test trials\n",
    "for tr in unique_trial_ids:\n",
    "    trial_pred = decode_kinematics(data[session][tr], L_TDR, dt=20, representation='TDR_emb')\n",
    "    data[session][tr]['TDR_decoded'] = trial_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a0a408b",
   "metadata": {},
   "source": [
    "### Comparison of decoding with ground truth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4bfea1d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(2,3,figsize=(10,4))\n",
    "\n",
    "plot_kinematics(data, session, unique_trial_ids, representation='kinematics', ax=ax[0,0])\n",
    "plot_kinematics(data, session, unique_trial_ids, representation='firing_rates_decoded', ax=ax[0,1])\n",
    "plot_kinematics(data, session, unique_trial_ids, representation='marble_decoded', ax=ax[0,2])\n",
    "plot_kinematics(data, session, unique_trial_ids, representation='lfads_decoded', ax=ax[1,0])\n",
    "plot_kinematics(data, session, unique_trial_ids, representation='cebra_decoded', ax=ax[1,1])\n",
    "plot_kinematics(data, session, unique_trial_ids, representation='TDR_decoded', ax=ax[1,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea829c14",
   "metadata": {},
   "source": [
    "# Decode across all sessions\n",
    "\n",
    "Above we decoded for a single session. Lets now loop over every session and compute some quantitative comparisons with the ground truth kinematics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b77a49a6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "kf = KFold(n_splits=5, shuffle=True) # use 5-fold split of the data \n",
    "\n",
    "r2_lfads_vel = []; r2_lfads_pos = []\n",
    "r2_cebra_vel = []; r2_cebra_pos = []\n",
    "r2_marble_vel = []; r2_marble_pos = []\n",
    "r2_TDR_vel = []; r2_TDR_pos = []\n",
    "r2_firing_rates_vel = []; r2_firing_rates_pos = []\n",
    "\n",
    "# loop over seessions\n",
    "for d in tqdm(data.keys()):\n",
    "    unique_trial_ids = np.unique(trial_ids[d])\n",
    "    \n",
    "    # cross validation\n",
    "    for i, (train_index, test_index) in enumerate(kf.split(unique_trial_ids)):\n",
    "\n",
    "        train_data = {key: data[d][key] for key in train_index if key in data[d]}\n",
    "\n",
    "        #LFADS\n",
    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='lfads_factors')\n",
    "        \n",
    "        for tr in unique_trial_ids[test_index]:\n",
    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='lfads_factors')\n",
    "            data[d][tr]['lfads_decoded'] = trial_pred\n",
    "           \n",
    "        #CEBRA\n",
    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='cebra_emb')\n",
    "        \n",
    "        for tr in unique_trial_ids[test_index]:\n",
    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='cebra_emb')\n",
    "            data[d][tr]['cebra_decoded'] = trial_pred\n",
    "            \n",
    "        #MARBLE\n",
    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='marble_emb')\n",
    "        \n",
    "        for tr in unique_trial_ids[test_index]:\n",
    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='marble_emb')\n",
    "            data[d][tr]['marble_decoded'] = trial_pred\n",
    "\n",
    "        #TDR\n",
    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='TDR_emb')\n",
    "        \n",
    "        for tr in unique_trial_ids[test_index]:\n",
    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='TDR_emb')\n",
    "            data[d][tr]['TDR_decoded'] = trial_pred\n",
    "\n",
    "        #Firing rates\n",
    "        Lw = train_OLE(data[d], unique_trial_ids[train_index], representation='firing_rates')\n",
    "        \n",
    "        for tr in unique_trial_ids[test_index]:\n",
    "            trial_pred = decode_kinematics(data[d][tr], Lw, dt=20, representation='firing_rates')\n",
    "            data[d][tr]['firing_rates_decoded'] = trial_pred\n",
    "            \n",
    "    # r-squared velocity\n",
    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='lfads_decoded')   \n",
    "    r2_lfads_pos.append(r2_pos)\n",
    "    r2_lfads_vel.append(r2_vel)\n",
    "    \n",
    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='cebra_decoded')   \n",
    "    r2_cebra_pos.append(r2_pos)\n",
    "    r2_cebra_vel.append(r2_vel)\n",
    "    \n",
    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='marble_decoded')   \n",
    "    r2_marble_pos.append(r2_pos)\n",
    "    r2_marble_vel.append(r2_vel)\n",
    "\n",
    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='TDR_decoded')   \n",
    "    r2_TDR_pos.append(r2_pos)\n",
    "    r2_TDR_vel.append(r2_vel)\n",
    "\n",
    "    r2_pos, r2_vel = correlation(data[d], unique_trial_ids, representation='firing_rates_decoded')   \n",
    "    r2_firing_rates_pos.append(r2_pos)\n",
    "    r2_firing_rates_vel.append(r2_vel)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4aaba62",
   "metadata": {},
   "source": [
    "Lets now visualise the decoded kinematics for the same set of example sessions (Fig S7)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2ba8691",
   "metadata": {},
   "outputs": [],
   "source": [
    "# chosen example sessions\n",
    "examples = [5,6,8,11,14,15,18,23,26,32]\n",
    "\n",
    "fig, ax = plt.subplots(4,len(examples),figsize=(15,5))\n",
    "\n",
    "for i,d in enumerate(examples):\n",
    "    \n",
    "    unique_trial_ids = np.unique(trial_ids[d])\n",
    "\n",
    "    ax[0,i] = plot_kinematics(data, d, unique_trial_ids, representation='kinematics', ax=ax[0,i])\n",
    "    ax[1,i] = plot_kinematics(data, d, unique_trial_ids, representation='marble_decoded', ax=ax[1,i])\n",
    "    ax[2,i] = plot_kinematics(data, d, unique_trial_ids, representation='cebra_decoded', ax=ax[2,i])\n",
    "    ax[3,i] = plot_kinematics(data, d, unique_trial_ids, representation='lfads_decoded', ax=ax[3,i])\n",
    "    ax[3,i] = plot_kinematics(data, d, unique_trial_ids, representation='firing_rates_decoded', ax=ax[3,i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a20a9cb0",
   "metadata": {},
   "source": [
    "## Instantaneous velocity decoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75da5f8b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "results = pd.DataFrame(data=np.vstack([ r2_marble_vel, r2_cebra_vel, r2_lfads_vel, r2_TDR_vel, r2_firing_rates_vel]).T,columns=['marble', 'CEBRA', 'LFADS', 'TDR', 'firing_rates'])\n",
    "results = results.melt()\n",
    "results.columns = ['model','accuracy']\n",
    "\n",
    "f, ax = plt.subplots(figsize=(4,5))\n",
    "sns.despine(bottom=True, left=True)\n",
    "\n",
    "sns.stripplot(\n",
    "    data=results, x=\"model\", y=\"accuracy\",\n",
    "    dodge=True, alpha=.5, zorder=1,\n",
    ")\n",
    "\n",
    "sns.pointplot(\n",
    "    data=results, x=\"model\", y=\"accuracy\",\n",
    "    join=False, dodge=.8 - .8 / 3, palette=\"dark\",\n",
    "    markers=\"d\", scale=.75, errorbar=None\n",
    ")\n",
    "\n",
    "pairs=[(\"LFADS\", \"marble\"), (\"CEBRA\",\"marble\"), (\"firing_rates\",\"marble\"), (\"TDR\",\"marble\")]\n",
    "\n",
    "annotator = Annotator(ax, pairs, data=results, x=\"model\", y=\"accuracy\",)\n",
    "annotator.configure(test='Wilcoxon', text_format='star', loc='outside')\n",
    "annotator.apply_and_annotate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "379d1077",
   "metadata": {},
   "source": [
    "## Decoding final reach direction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91f2c2a7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "marble_model_acc = []\n",
    "cebra_model_acc = []\n",
    "lfads_model_acc = []\n",
    "TDR_model_acc = []\n",
    "firing_rates_model_acc = []\n",
    "\n",
    "for d in tqdm(data.keys()):           \n",
    "\n",
    "    unique_trial_ids = np.unique(trial_ids[d])\n",
    "    \n",
    "    # fit classifier to kinematics\n",
    "    clf = fit_classifier(data[d], conditions, unique_trial_ids, representation='kinematics')\n",
    "    \n",
    "    # evaluate classifier on marble decoded\n",
    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='marble_decoded')\n",
    "    marble_model_acc.append(score)\n",
    "    \n",
    "    # evaluate classifier on cebra decoded\n",
    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='cebra_decoded')\n",
    "    cebra_model_acc.append(score)\n",
    "    \n",
    "    # evaluate classifier on lfads decoded\n",
    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='lfads_decoded')\n",
    "    lfads_model_acc.append(score)\n",
    "\n",
    "    # evaluate classifier on lfads decoded\n",
    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='TDR_decoded')\n",
    "    TDR_model_acc.append(score)\n",
    "\n",
    "    # evaluate classifier on firing_rates\n",
    "    score = transform_classifier(clf, data[d], conditions, unique_trial_ids, representation='firing_rates_decoded')\n",
    "    firing_rates_model_acc.append(score)\n",
    "\n",
    "results = pd.DataFrame(data=np.vstack([ marble_model_acc, cebra_model_acc, lfads_model_acc, TDR_model_acc, firing_rates_model_acc]).T,columns=['marble', 'cebra', 'LFADS', 'TDR', 'firing_rates'])\n",
    "\n",
    "results = results.melt()\n",
    "results.columns = ['model','accuracy']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90c62030",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "f, ax = plt.subplots(figsize=(4,4))\n",
    "sns.despine(bottom=True, left=True)\n",
    "\n",
    "sns.stripplot(\n",
    "    data=results, x=\"model\", y=\"accuracy\",\n",
    "    dodge=True, alpha=.5, zorder=1,\n",
    ")\n",
    "\n",
    "sns.pointplot(\n",
    "    data=results, x=\"model\", y=\"accuracy\",\n",
    "    join=False, dodge=.8 - .8 / 3, palette=\"dark\",\n",
    "    markers=\"d\", scale=.75, errorbar=None\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78d726e8-3a27-4e5e-b959-199d2de8199a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}