amgen/exp/ProcessExp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experiment: Flashed gratings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import scipy.stats as sts\n",
    "import pickle as pkl\n",
    "import ipywidgets as widgets\n",
    "from mpl_toolkits import mplot3d\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from scipy import sparse\n",
    "import sys\n",
    "from matplotlib import cm\n",
    "sys.path.insert(0, '../model/')\n",
    "\n",
    "# color maps\n",
    "cmap_hot = cm.get_cmap('hot')\n",
    "cmap_viridis = cm.get_cmap('viridis')\n",
    "cmap_jet = cm.get_cmap('jet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "data_folder = \"../data/\"\n",
    "stim_file = \"Stiminfo_PVCre_2021_0012_s06_e14.csv\"\n",
    "spike_times_file = \"Spiketimes_PVCre_2021_0012_s06_e14.npy\"\n",
    "\n",
    "key_symbol = {'pair':'$(\\\\theta,\\phi)$', 'orientation':'$\\\\theta$', 'phase':'$\\phi$'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['data_folder', 'stim_file', 'spike_times_file', 'key_symbol', 'stim', 'num_trial', 'stim_val', 'trial_stim_id', 'key_list', 'stim_id_trial', 'num_stim', 'key', 'pair_id', 'trial_pair_id', 'pair_val', 'pair_trial_id', 'spike_times', 'num_unit', 'num_spike', 'spike_count_rate', 'avg_firing_rate', 'firing_rate', 'stim_num_trial', 'stim_hist', 'optimal_avg_firing_rate', 'latest_spike_time', 'dt', 'exp_time', 'B_stim', 'trials', 't_on', 't_off', 'B_spike', 'trial_range', 'units', 'orientation', 'phase', 'trial_spike_times', 'delta_t_on', 'delta_t_off', 'subseq_trials', 'subseq_spike_times', 'subseq_spike_times_locked', 'time_range', 'unit_id_2', 'p1', 'p2', 'delta_t', 'time_range_smoothing', 'period_1_dist', 'period_2_dist', 'period_3_dist', 'num_units', 'max_p_1', 'max_p_2', 'max_p_3', 'delta_2', 'delta_3', 't_p1', 't_p2', 'subseq_spike_times_locked_2', 'B_spike_fixed', 'B_stim_original', 'B_spike_smooth', 'B_stim_total', 'R', 'R_pair_smoothed', 'Rp', 'firing_rates_noise_red', 'firing_rates_flat', 'firing_rates_in_trials', 'avg_firing_rates', 'avg_fr_blur', 'avg_firing_rates_pca', 'param_corr', 'avg_firing_rates_pca_', 'embed'])\n"
     ]
    }
   ],
   "source": [
    "file = open(\"dump.pkl\", 'rb')\n",
    "pair_id = None\n",
    "data = pkl.load(file)\n",
    "print(data.keys())\n",
    "for key, value in data.items():\n",
    "    globals()[key] = value\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('dump.pkl', 'wb') as f:\n",
    "    pickle.dump({k: globals()[k] for k in [\n",
    "        'data_folder', 'stim_file', 'spike_times_file', 'key_symbol', \n",
    "        'stim', 'num_trial', 'stim_val', 'trial_stim_id', 'key_list', 'stim_id_trial', 'num_stim', 'key', 'pair_id', 'trial_pair_id', 'pair_val', 'pair_trial_id',\n",
    "        'spike_times', 'num_unit', 'num_spike', 'spike_count_rate', 'avg_firing_rate', 'firing_rate', 'stim_num_trial', 'stim_hist', 'optimal_avg_firing_rate',\n",
    "        'latest_spike_time', 'dt', 'exp_time', 'B_stim', 'trials', 't_on', 't_off', 'B_spike', 'trial_range', 'units', 'orientation', 'phase', 'trial_spike_times',\n",
    "        'delta_t_on', 'delta_t_off', 'subseq_trials', 'subseq_spike_times', 'subseq_spike_times_locked', 'time_range', 'unit_id_2', 'p1', 'p2', 'delta_t', 'time_range_smoothing',\n",
    "        'period_1_dist', 'period_2_dist', 'period_3_dist', 'num_units', 'max_p_1', 'max_p_2', 'max_p_3', 'delta_2', 'delta_3', 't_p1', 't_p2', 'subseq_spike_times_locked_2',\n",
    "        'B_spike_fixed', 'B_stim_original', 'B_spike_smooth', 'B_stim_total', 'R', 'R_pair_smoothed', 'Rp', 'firing_rates_noise_red', 'firing_rates_flat', 'firing_rates_in_trials', 'avg_firing_rates',\n",
    "        'avg_fr_blur', 'avg_firing_rates', 'avg_firing_rates_pca', 'param_corr', 'avg_firing_rates_pca_', 'embed'\n",
    "        ]}, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load the stimulus data\n",
    "**Stimulus data layout:**\n",
    "```\n",
    "stim_val = {'pair': [(or1, ph1), (or2, ph2), ...], 'orientation': [...], 'phase': [...]}\n",
    "stim_id_trial = {'pair': [id1, id2, ...], 'phase': [..], ...}   # corresponding trials\n",
    "pair_trial_id[orientation_id][phase_id] = [Trial ids]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stimulus DataFrame\n",
    "stim = pd.read_csv(data_folder + stim_file)\n",
    "num_trial = len(stim)\n",
    "stim_val = {}\n",
    "trial_stim_id = {}\n",
    "# 50 trials per orientation-phase pair\n",
    "stim_val['pair'], trial_stim_id['pair'] = np.unique(stim[['grat_orientation', 'grat_phase']], return_inverse=True, axis=0) \n",
    "# 1000 trials per orientation\n",
    "stim_val['orientation'], trial_stim_id['orientation'] = np.unique(stim['grat_orientation'], return_inverse=True) \n",
    "# 1000 trials per phase\n",
    "stim_val['phase'], trial_stim_id['phase'] = np.unique(stim['grat_phase'], return_inverse=True) \n",
    "key_list = ['pair', 'orientation', 'phase']\n",
    "stim_id_trial = {}\n",
    "num_stim = {}\n",
    "for key in key_list:\n",
    "    stim_id_trial[key] = [np.where(trial_stim_id[key] == i)[0] for i in range(len(stim_val[key]))]\n",
    "    num_stim[key] = len(stim_val[key])\n",
    "\n",
    "def pair_id(i):\n",
    "    return (int(i//num_stim['orientation']), i%num_stim['orientation'])\n",
    "\n",
    "trial_pair_id = np.array([pair_id(i) for i in trial_stim_id['pair']], dtype=object)\n",
    "pair_val = stim_val['pair'].reshape(num_stim['orientation'], num_stim['phase'],2)\n",
    "\n",
    "# for each (orientation_id = i, phase_id = j) find the trial indices\n",
    "pair_trial_id = np.ndarray((num_stim['orientation'], num_stim['phase']), dtype=object)\n",
    "for i in range(num_stim['pair']):\n",
    "    pair_trial_id[pair_id(i)] = stim_id_trial['pair'][i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Unnamed: 0</th>\n",
       "      <th>grat_orientation</th>\n",
       "      <th>grat_phase</th>\n",
       "      <th>stimvals</th>\n",
       "      <th>stim_ontime</th>\n",
       "      <th>stim_offtime</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>36.0</td>\n",
       "      <td>102</td>\n",
       "      <td>2.5005</td>\n",
       "      <td>2.5839</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>1</td>\n",
       "      <td>2.6195</td>\n",
       "      <td>2.7028</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>162.0</td>\n",
       "      <td>288.0</td>\n",
       "      <td>376</td>\n",
       "      <td>2.7030</td>\n",
       "      <td>2.7863</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>54.0</td>\n",
       "      <td>3</td>\n",
       "      <td>2.7865</td>\n",
       "      <td>2.8699</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>108.0</td>\n",
       "      <td>36.0</td>\n",
       "      <td>242</td>\n",
       "      <td>2.8700</td>\n",
       "      <td>2.9534</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Unnamed: 0  grat_orientation  grat_phase  stimvals  stim_ontime  \\\n",
       "0           0              45.0        36.0       102       2.5005   \n",
       "1           1               0.0        18.0         1       2.6195   \n",
       "2           2             162.0       288.0       376       2.7030   \n",
       "3           3               0.0        54.0         3       2.7865   \n",
       "4           4             108.0        36.0       242       2.8700   \n",
       "\n",
       "   stim_offtime  \n",
       "0        2.5839  \n",
       "1        2.7028  \n",
       "2        2.7863  \n",
       "3        2.8699  \n",
       "4        2.9534  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stim.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pair, orientation, phase\n",
      "(400, 2)\n",
      "(20,) (20,)\n"
     ]
    }
   ],
   "source": [
    "print(', '.join(stim_val.keys()))\n",
    "print(stim_val['pair'].shape)\n",
    "print(stim_val['orientation'].shape, stim_val['phase'].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   82   482  1021  1421  1821  2183  2645  3045  3445  3643  4357  4757\n",
      "  5014  5493  5893  6293  6693  6965  7365  7652  8052  8513  9116  9203\n",
      "  9603 10003 10628 10849 11512 11912 12312 12535 12947 13347 13666 14248\n",
      " 14682 14857 15257 15657 16393 16793 17193 17262 17906 18146 18546 19050\n",
      " 19450 19904]\n"
     ]
    }
   ],
   "source": [
    "print(stim_id_trial['pair'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   82,   482,  1021,  1421,  1821,  2183,  2645,  3045,  3445,\n",
       "        3643,  4357,  4757,  5014,  5493,  5893,  6293,  6693,  6965,\n",
       "        7365,  7652,  8052,  8513,  9116,  9203,  9603, 10003, 10628,\n",
       "       10849, 11512, 11912, 12312, 12535, 12947, 13347, 13666, 14248,\n",
       "       14682, 14857, 15257, 15657, 16393, 16793, 17193, 17262, 17906,\n",
       "       18146, 18546, 19050, 19450, 19904])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pair_trial_id[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Stimulus data layout:**\n",
    "```\n",
    "stim_val = {'pair': [(or1, ph1), (or2, ph2), ...], 'orientation': [...], 'phase': [...]}\n",
    "stim_id_trial = {'pair': [id1, id2, ...], 'phase': [..], ...}   # corresponding trials\n",
    "pair_trial_id[orientation_id][phase_id] = [Trial ids]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load the spike data and correlations\n",
    "```\n",
    "Loaded: spike_count_rate, avg_firing_rate, sem_firing_rate, firing_rate, stim_num_trial, C_r_fphi_theta, theta_hist, phase_hist, pair_hist\n",
    "Loaded: corr_stim_unit, optimal_avg_firing_rate, stim_hist, stim_hist_caution\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spike_times_file = \"Spiketimes_PVCre_2021_0012_s06_e14.npy\"\n",
    "spike_times = np.load(data_folder+spike_times_file, allow_pickle=True)\n",
    "active = [len(spike_times[i]) > 0 for i in range(len(spike_times))]\n",
    "spike_times = spike_times[np.where(active)]\n",
    "num_unit = len(spike_times)\n",
    "spike_times.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sort spikes by firing rate**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "num_spike = list(map(len, spike_times))\n",
    "spike_times = spike_times[np.argsort(num_spike)[::-1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Load a lot of variables out of a `.pkl` file**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded: spike_count_rate, avg_firing_rate, sem_firing_rate, firing_rate, stim_num_trial, C_r_fphi_theta, theta_hist, phase_hist, pair_hist\n",
      "Loaded: corr_stim_unit, optimal_avg_firing_rate, stim_hist, stim_hist_caution\n"
     ]
    }
   ],
   "source": [
    "# yeah...\n",
    "files = ['spike_data.pkl', 'corr_data.pkl']\n",
    "for file_name in files:\n",
    "    file = open(file_name, 'rb')\n",
    "    data = pkl.load(file)\n",
    "    print('Loaded:', ', '.join(data.keys()))\n",
    "    for key, value in data.items():\n",
    "        globals()[key] = value\n",
    "\n",
    "    file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Spike and stimulus preprocessing\n",
    "\n",
    "```\n",
    "B_stim = {'pair': [mat_stim_1, mat_stim_2, ..], 'orientation': .., ...}\n",
    "```\n",
    "\n",
    "`mat_stim_i` is a matrix of shape `(1, M)` such that `mat[0][t] = 1` if there was stimuli at time $t$ and $0$ if not\n",
    "\n",
    "```\n",
    "B_spike = [unit_1_spikes, unit_2_spikes, ..]\n",
    "unit_1_spikes[t] = 1 if there was a spike, 0 if not\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Read the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reverse correlation time offset range \n",
    "max_delay = 300 # dt\n",
    "tau_id_range = np.arange(max_delay)\n",
    "\n",
    "# experiment duration\n",
    "latest_spike_time = max([np.max(s) for s in spike_times if len(s)])\n",
    "latest_stim_offtime = list(stim['stim_offtime'])[-1]\n",
    "experiment_dur = max([latest_spike_time, latest_stim_offtime])\n",
    "\n",
    "dt = 0.001 # 1 ms\n",
    "exp_time = np.arange(0, experiment_dur, dt)\n",
    "M = len(exp_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "B_stim = {}\n",
    "for key in key_list:\n",
    "    B_stim[key] = []\n",
    "    for stim_id, trials in enumerate(stim_id_trial[key]):\n",
    "        B_stim[key].append([])\n",
    "        s = []\n",
    "        for trial_id in trials:\n",
    "            t_on, t_off = stim['stim_ontime'][trial_id], stim['stim_offtime'][trial_id]\n",
    "            s += list(np.arange(int(t_on//dt), int(t_off//dt)))\n",
    "\n",
    "        B_stim[key][stim_id] = sparse.coo_matrix((np.ones(len(s)), (np.zeros(len(s), dtype=int), s)), shape=(1, M))\n",
    "s = spike_times//dt\n",
    "B_spike = []\n",
    "for unit_id in range(num_unit):\n",
    "    B_spike.append(sparse.coo_matrix((np.ones(len(s[unit_id])), (np.zeros(len(s[unit_id]), dtype=int), np.int0(s[unit_id]))), shape=(1, M)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_spike_num = np.sort(num_spike)[::-1]\n",
    "cutoff_num_spike = 1000\n",
    "num_unit = np.sum(sorted_spike_num > cutoff_num_spike)\n",
    "for key in key_list:\n",
    "    stim_hist[key] = stim_hist[key][:num_unit]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Some plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This graph shows for unit 0 at a particular moment:\n",
    "- One stimulus duration (blue)\n",
    "- The second stimulus (red)\n",
    "\n",
    "And spike events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "stim_id = 10\n",
    "trial_id = stim_id_trial['phase'][stim_id][0]\n",
    "unit_id = 0\n",
    "t_on, t_off = stim['stim_ontime'][trial_id], stim['stim_offtime'][trial_id]\n",
    "t0, t1 = t_off-0.2, t_off+0.1\n",
    "stim_prev_id = trial_stim_id['phase'][trial_id-1]\n",
    "t_prev_on, t_prev_off = stim['stim_ontime'][trial_id-1], stim['stim_offtime'][trial_id-1]\n",
    "spikes = spike_times[unit_id][np.where((t0 < spike_times[unit_id]) & (spike_times[unit_id] < t1))]\n",
    "plt.axvspan(t_on, t_off, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3)\n",
    "plt.axvspan(t_prev_on, t_prev_off, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3)\n",
    "plt.eventplot(spikes)\n",
    "plt.xlim([t0, t1])\n",
    "plt.title('Spikes for unit 0')\n",
    "plt.xlabel('Time')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 504x504 with 7 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import gridspec\n",
    "\n",
    "fig, ax = plt.subplots(3,1,figsize=(7,7))\n",
    "gs0 = gridspec.GridSpec(3, 3, figure=fig, hspace=0, wspace=0)\n",
    "\n",
    "stim_id = 10\n",
    "trial_id = stim_id_trial['phase'][stim_id][0]\n",
    "unit_id = 0\n",
    "t_on, t_off = stim['stim_ontime'][trial_id], stim['stim_offtime'][trial_id]\n",
    "t0, t1 = t_off-0.2, t_off+0.1\n",
    "stim_prev_id = trial_stim_id['phase'][trial_id-1]\n",
    "t_prev_on, t_prev_off = stim['stim_ontime'][trial_id-1], stim['stim_offtime'][trial_id-1]\n",
    "spikes = spike_times[unit_id][np.where((t0 < spike_times[unit_id]) & (spike_times[unit_id] < t1))]\n",
    "\n",
    "ax0 = fig.add_subplot(gs0[0, :-1])\n",
    "ax1 = fig.add_subplot(gs0[1, :-1])\n",
    "ax2 = fig.add_subplot(gs0[2, :-1])\n",
    "ax3 = fig.add_subplot(gs0[:, -1])\n",
    "\n",
    "ax0.axvspan(t_on, t_off, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3, label='preferred')\n",
    "ax0.axvspan(t_prev_on, t_prev_off, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3, label='non-preferred')\n",
    "ax0.eventplot(spikes)\n",
    "ax0.set_xlim([t0, t1])\n",
    "ax0.legend(loc='upper left')\n",
    "\n",
    "ax1.axvspan(t_on, t_off, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3)\n",
    "ax1.axvspan(t_prev_on, t_prev_off, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3)\n",
    "ax1.eventplot(spikes-0.05)\n",
    "ax1.set_xlim([t0, t1])\n",
    "\n",
    "ax2.axvspan(t_on, t_off, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3)\n",
    "ax2.axvspan(t_prev_on, t_prev_off, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3)\n",
    "ax2.eventplot(spikes-0.15)\n",
    "ax2.set_xlim([t0, t1])\n",
    "\n",
    "ax3.plot(np.sin(np.pi*tau_id_range/300), np.arange(300))\n",
    "ax3.set_xticks([])\n",
    "ax3.set_yticks([])\n",
    "ax3.set_title('reverse correlation')\n",
    "# ax2.legend()\n",
    "for ax in fig.get_axes():\n",
    "    ax.tick_params(bottom=False, labelbottom=False, left=False, labelleft=False)\n",
    "\n",
    "ax2.tick_params(bottom=True, labelbottom=True)\n",
    "ax2.set_xlabel('t/s')\n",
    "plt.tight_layout()\n",
    "fig.suptitle('subspace reverse correlation', size=16, y=1.05)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 504x504 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# subspace reverese correlation\n",
    "stim_id = 13\n",
    "ref_trial_id = stim_id_trial['phase'][stim_id][0]\n",
    "stim_prev_id = trial_stim_id['phase'][ref_trial_id-1]\n",
    "past_trials = 3\n",
    "future_trials = 10\n",
    "trial_range = np.arange(-past_trials, future_trials+1) + ref_trial_id\n",
    "\n",
    "units = np.arange(num_unit)\n",
    "orientation, phase, t_on = np.array(stim[['grat_orientation', 'grat_phase','stim_ontime']].iloc[trial_range]).T\n",
    "spikes = [\n",
    "    spike_times[unit_id][\n",
    "        # Where the spike occurs during the stimulus period in one of the right trials\n",
    "        np.where((t_on[0] < spike_times[unit_id]) & (spike_times[unit_id] < t_on[-1]))\n",
    "        ]\n",
    "    for unit_id in units]\n",
    "\n",
    "fig, ax = plt.subplots(2,1,figsize=(7,7))\n",
    "plt.subplots_adjust(hspace=0)\n",
    "s = 1\n",
    "ax[0].eventplot(spikes, linelength=s, lineoffsets=s)\n",
    "\n",
    "ref_id = list(trial_range).index(ref_trial_id)\n",
    "# ax[0].axvspan(t_on[ref_id], t_on[ref_id]+0.08, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3)\n",
    "# ax[0].axvspan(t_on[ref_id-1], t_on[ref_id-1]+0.08, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3)\n",
    "ax[0].set(ylabel='unit')\n",
    "ax[0].invert_yaxis()\n",
    "ax[1].step(t_on, phase, 'b', where='post', alpha=0.5, label='phase')\n",
    "ax[1].set(xlabel='t / s', xlim=[t_on[0], t_on[-1]], ylim=[0, 360], ylabel='phase')\n",
    "ax[1].legend(loc='upper left')\n",
    "ax2 = ax[1].twinx()\n",
    "ax2.step(t_on, orientation, 'r', where='post', alpha=0.5, label='orientation')\n",
    "ax2.set(ylim=[0, 180], ylabel='orientation')\n",
    "ax2.legend()\n",
    "ax[0].set_title('Spikes in units')\n",
    "ax[1].set_title('Phase and orientation')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "afc70624cbfe4a5f8838bce9ae0c0ebc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='delay/ms', max=299), IntSlider(value=0, description='uni…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@widgets.interact(key=widgets.RadioButtons(options=key_list[1:],\n",
    "    description='stimulus:',\n",
    "    disabled=False), tau_id=widgets.IntSlider(0, min=0, max=max_delay-1, description='delay/ms'), unit_id=widgets.IntSlider(0, min=0, max=num_unit-1))\n",
    "\n",
    "def PSSH(tau_id, unit_id, key):\n",
    "    fig, ax = plt.subplots(1, 1, figsize=(7,6))\n",
    "    prob = stim_hist[key][unit_id, tau_id]\n",
    "    n = sorted_spike_num[unit_id]\n",
    "    confidence_interval = np.sqrt(prob/n)\n",
    "    plt.errorbar(stim_val[key], stim_hist[key][unit_id, tau_id], yerr=confidence_interval)\n",
    "    ymin = np.min(stim_hist[key][unit_id])*0.95\n",
    "    ymax = np.max(stim_hist[key][unit_id])*1.05\n",
    "    ax.set_ylabel('$\\mathcal{P}($'+key_symbol[key]+'$|\\\\tau)$')\n",
    "    ax.set_xlabel(key_symbol[key])\n",
    "    plt.ylim([ymin, ymax])\n",
    "    plt.suptitle('Distribution of stimulus at time $\\\\tau$ before a spike of unit: %d'%unit_id)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Problem with the data\n",
    "\n",
    "The picture a couple of cells below clearly shows that there is a shift in the stimulus presentation times. Let's fix it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3.10/site-packages/pandas/core/roperator.py:13: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  return right - left\n"
     ]
    }
   ],
   "source": [
    "trial_spike_times = np.ndarray((num_unit, num_trial), dtype=object)\n",
    "delta_t_on = 0.2 # 200ms\n",
    "delta_t_off = 0.3\n",
    "for trial_id in range(num_trial):\n",
    "    t_on, t_off = stim['stim_ontime'][trial_id]-delta_t_on, stim['stim_offtime'][trial_id]+delta_t_off\n",
    "    for unit_id in range(num_unit):\n",
    "        trial_spike_times[unit_id, trial_id] = spike_times[unit_id][np.where((spike_times[unit_id] < t_off) & (spike_times[unit_id] > t_on))]\n",
    "subseq_trials = 5\n",
    "subseq_spike_times = np.ndarray(num_unit, dtype=object)\n",
    "for unit_id in range(num_unit):\n",
    "    subseq_spike_times[unit_id] = [np.concatenate(trial_spike_times[unit_id][i:i+subseq_trials]) for i in range(num_trial-subseq_trials)]\n",
    "\n",
    "subseq_spike_times_locked = {}\n",
    "subseq_spike_times_locked['ontime'] = [subseq_spike_times[unit_id] - stim['stim_ontime'][:-subseq_trials] for unit_id in range(num_unit)]\n",
    "subseq_spike_times_locked['offtime'] = [subseq_spike_times[unit_id] - stim['stim_offtime'][:-subseq_trials]  for unit_id in range(num_unit)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_range = np.arange(0, stim['stim_ontime'].max(), np.array(sorted(np.diff(stim['stim_ontime'], n=1))[10:-10]).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((28, 19995), (28, 19995), 0.7671829999999886)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subseq_spike_times_len = len(subseq_spike_times[0])\n",
    "subseq_spike_times_locked['ontime'] = np.array(subseq_spike_times_locked['ontime'])\n",
    "subseq_spike_times_locked['offtime'] = np.array(subseq_spike_times_locked['offtime'])\n",
    "from itertools import chain\n",
    "subseq_spike_times_locked['ontime'].shape, subseq_spike_times_locked['offtime'].shape, max(chain(*subseq_spike_times_locked['ontime'].flatten()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1440x720 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "unit_id = 1\n",
    "unit_id_2 = 3\n",
    "\n",
    "fig, ax = plt.subplots(1,3, figsize=(20,10))\n",
    "ax[0].plot(np.diff(stim['stim_ontime'], n=2), np.arange(20000-2))\n",
    "ax[0].invert_yaxis()\n",
    "ax[0].set_xlabel('$\\Delta^2[t_{on}]=\\Delta$ trial duration / s', size=20)\n",
    "ax[0].set(ylabel='trials')\n",
    "ax[1].eventplot(subseq_spike_times_locked['ontime'][unit_id], lineoffsets=1, linelengths=0.8)\n",
    "ax[1].set(title='unit %d'%unit_id, yticks=[], xlabel='t/s (locked to trial onsets)')\n",
    "ax[1].invert_yaxis()\n",
    "ax[2].eventplot(subseq_spike_times_locked['ontime'][unit_id_2], lineoffsets=1, linelengths=0.8)\n",
    "ax[2].set(title='unit %d'%(unit_id_2), yticks=[], xlabel='t/s (locked to trial ends)')\n",
    "ax[2].invert_yaxis()\n",
    "plt.subplots_adjust(wspace=0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Whaaat?_\n",
    "\n",
    "Ok, we've gotta fix it.\n",
    "\n",
    "Let's take the \"bad\" times, identify the periods we want to calibrate - and align everything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2280 2286 2291 2292 2295 2298 2301 2307 2377 2378 2380 2383 2386 2464 2467 2469 2472 2475 2478 15300 15306 15312 15315 15316 15318 15327 15329 15333 15336 15338 15342 15344 15348 15349 15402 15403 15405 15408\n"
     ]
    }
   ],
   "source": [
    "stim_2diffs = np.diff(stim['stim_ontime'], n=2)\n",
    "print(*[i for i in range(len(stim_2diffs)) if stim_2diffs[i] > 0.01])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Periods:\n",
    "$[0, 2350)$, $[2350, 15350)$, $[15350, 20000]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_4135643/175591453.py:20: DeprecationWarning: Please use `gaussian_filter1d` from the `scipy.ndimage` namespace, the `scipy.ndimage.filters` namespace is deprecated.\n",
      "  period_1_dist = scipy.ndimage.filters.gaussian_filter1d(period_1_dist, sigma=10)\n",
      "/tmp/ipykernel_4135643/175591453.py:21: DeprecationWarning: Please use `gaussian_filter1d` from the `scipy.ndimage` namespace, the `scipy.ndimage.filters` namespace is deprecated.\n",
      "  period_2_dist = scipy.ndimage.filters.gaussian_filter1d(period_2_dist, sigma=10)\n",
      "/tmp/ipykernel_4135643/175591453.py:22: DeprecationWarning: Please use `gaussian_filter1d` from the `scipy.ndimage` namespace, the `scipy.ndimage.filters` namespace is deprecated.\n",
      "  period_3_dist = scipy.ndimage.filters.gaussian_filter1d(period_3_dist, sigma=10)\n"
     ]
    }
   ],
   "source": [
    "p1, p2 = 2350, 15350\n",
    "delta_t = 0.002\n",
    "time_range_smoothing = np.arange(0, 0.8, delta_t)\n",
    "period_1_dist = np.zeros(len(time_range_smoothing) - 1)\n",
    "period_2_dist = np.zeros(len(time_range_smoothing) - 1)\n",
    "period_3_dist = np.zeros(len(time_range_smoothing) - 1)\n",
    "num_units = subseq_spike_times_locked['ontime'].shape[0]\n",
    "for i in range(num_units):\n",
    "    for j, row in enumerate(subseq_spike_times_locked['ontime'][i]):\n",
    "        hist = np.histogram(row, bins=time_range_smoothing)[0]\n",
    "        if j < p1:\n",
    "            period_1_dist += hist\n",
    "        elif j < p2:\n",
    "            period_2_dist += hist\n",
    "        else:\n",
    "            period_3_dist += hist\n",
    "period_1_dist /= num_units\n",
    "period_2_dist /= num_units\n",
    "period_3_dist /= num_units\n",
    "period_1_dist = scipy.ndimage.filters.gaussian_filter1d(period_1_dist, sigma=10)\n",
    "period_2_dist = scipy.ndimage.filters.gaussian_filter1d(period_2_dist, sigma=10)\n",
    "period_3_dist = scipy.ndimage.filters.gaussian_filter1d(period_3_dist, sigma=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.collections.EventCollection at 0x7f1b53e02f80>]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x1440 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(3, 1, figsize=(10,20))\n",
    "ax[0].plot(time_range_smoothing[:-1], period_1_dist, label='period 1')\n",
    "ax[1].plot(time_range_smoothing[:-1], period_2_dist, label='period 2')\n",
    "ax[2].plot(time_range_smoothing[:-1], period_3_dist, label='period 3')\n",
    "ax[0].set(xlabel='t/s', ylabel='spike count', title='1st part')\n",
    "ax[1].set(xlabel='t/s', ylabel='spike count', title='2nd part')\n",
    "ax[2].set(xlabel='t/s', ylabel='spike count', title='3rd part')\n",
    "ax[0].eventplot([0.2], linelengths=0.8)\n",
    "ax[1].eventplot([0.2], linelengths=0.8)\n",
    "ax[2].eventplot([0.2], linelengths=0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(time_range_smoothing).index(0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2 0.162 0.194\n"
     ]
    }
   ],
   "source": [
    "max_p_1 = time_range_smoothing[np.argmax(period_1_dist[:120])]\n",
    "max_p_2 = time_range_smoothing[np.argmax(period_2_dist[:100])]\n",
    "max_p_3 = time_range_smoothing[np.argmax(period_3_dist[:120])]\n",
    "delta_2 = max_p_1 - max_p_2\n",
    "delta_3 = max_p_1 - max_p_3\n",
    "print(max_p_1, max_p_2, max_p_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll fix the times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_p1, t_p2 = stim['stim_offtime'][p1], stim['stim_offtime'][p2]\n",
    "fix_time = lambda t: t - delta_2 * ((t < t_p2) & (t >= t_p1)) - delta_3 * ((t >= t_p2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0           2.5839\n",
       "1           2.7028\n",
       "2           2.7863\n",
       "3           2.8699\n",
       "4           2.9534\n",
       "           ...    \n",
       "19990    1671.6389\n",
       "19991    1671.7224\n",
       "19992    1671.8059\n",
       "19993    1671.8894\n",
       "19994    1671.9730\n",
       "Name: stim_offtime, Length: 19995, dtype: float64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fix_time(stim['stim_offtime'][:-subseq_trials])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3.10/site-packages/pandas/core/roperator.py:13: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  return right - left\n"
     ]
    }
   ],
   "source": [
    "subseq_spike_times_locked_2 = {}\n",
    "subseq_spike_times_locked_2['ontime'] = [subseq_spike_times[unit_id] - fix_time(stim['stim_ontime'][:-subseq_trials]) for unit_id in range(num_unit)]\n",
    "subseq_spike_times_locked_2['offtime'] = [subseq_spike_times[unit_id] - fix_time(stim['stim_offtime'][:-subseq_trials])  for unit_id in range(num_unit)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1440x720 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "unit_id = 1\n",
    "\n",
    "fig, ax = plt.subplots(1,3, figsize=(20,10))\n",
    "ax[0].plot(np.diff(stim['stim_ontime'], n=2), np.arange(20000-2))\n",
    "ax[0].invert_yaxis()\n",
    "ax[0].set_xlabel('$\\Delta^2[t_{on}]=\\Delta$ trial duration / s', size=20)\n",
    "ax[0].set(ylabel='trials')\n",
    "ax[1].eventplot(subseq_spike_times_locked_2['ontime'][unit_id], lineoffsets=1, linelengths=0.8)\n",
    "ax[1].set(title='unit %d'%unit_id, yticks=[], xlabel='t/s (locked to trial onsets)')\n",
    "ax[1].invert_yaxis()\n",
    "ax[2].eventplot(subseq_spike_times_locked_2['ontime'][unit_id_2], lineoffsets=1, linelengths=0.8)\n",
    "ax[2].set(title='unit %d'%(unit_id_2), yticks=[], xlabel='t/s (locked to trial ends)')\n",
    "ax[2].invert_yaxis()\n",
    "plt.subplots_adjust(wspace=0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = np.array([np.array(list(map(fix_time, spike_times[unit_id]))) for unit_id in range(len(spike_times))], dtype=object)//dt\n",
    "B_spike_fixed = []\n",
    "for unit_id in range(num_unit):\n",
    "    B_spike_fixed.append(sparse.coo_matrix((np.ones(len(s[unit_id])), (np.zeros(len(s[unit_id]), dtype=int), np.int0(s[unit_id]))), shape=(1, M)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "B_stim_original = deepcopy(B_stim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "B_stim = {}\n",
    "for key in key_list:\n",
    "    B_stim[key] = []\n",
    "    for stim_id, trials in enumerate(stim_id_trial[key]):\n",
    "        B_stim[key].append([])\n",
    "        s = []\n",
    "        for trial_id in trials:\n",
    "            t_on, t_off = fix_time(stim['stim_ontime'][trial_id]), fix_time(stim['stim_offtime'][trial_id])\n",
    "            s += list(np.arange(int(t_on//dt), int(t_off//dt)))\n",
    "\n",
    "        B_stim[key][stim_id] = sparse.coo_matrix((np.ones(len(s)), (np.zeros(len(s), dtype=int), s)), shape=(1, M))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculate some matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_trial_index = lambda t: fix_time(stim['stim_ontime'][t])//dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "B_spike_smooth = list()\n",
    "for unit_id in range(len(B_spike)):\n",
    "    B_spike_smooth.append(scipy.ndimage.gaussian_filter(B_spike[unit_id].toarray()[0], sigma=50))\n",
    "B_spike_smooth = np.array(B_spike_smooth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f1b6ae5dcc0>]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABS2UlEQVR4nO29eZxkZ3nf+31rX3vfZu8ZzUij0YoYLUhgYwgYcEAxBlvg6xDbN8R2+NwbO3ECjq9jE998jG9snASubRJzg1cwYGLZgGVACIMkJI3WmZE0mn3p6Z7eu7r27b1/nPOerq46VXWqpraufr+fz3ymuupM13t6qp/znN/7PL9HSCnRaDQaTf/i6vYCNBqNRtNedKDXaDSaPkcHeo1Go+lzdKDXaDSaPkcHeo1Go+lzPN1eQDljY2Nyenq628vQaDSaLcWzzz67KKUct3ut5wL99PQ0x44d6/YyNBqNZkshhLhY7TUt3Wg0Gk2fowO9RqPR9Dk60Gs0Gk2fowO9RqPR9Dk60Gs0Gk2fowO9RqPR9Dk60Gs0Gk2fowO9RqPRdJjvvLbAsxdXOvZ+PdcwpdFoNP1MIpPnQ599GoCz/+lduF2i7e+pM3qNRqPpIK/OxazH5xbiHXlPHeg1Go2mg7w6t249vriU7Mh76kCv0Wg0HeTqasp6PFPyuJ3oQK/RaDQdZD6WYSLqx+dxbQr67URvxmo0Gk0HWYhnmBwI4HW7WIhnOvKeOtBrNBpNB5mPZZgaDFCUktVkriPvqaUbjUaj6SALcUO6GQn7WE5kO/KejgK9EOIdQohTQogzQoiP2rzuF0J8wXz9KSHEtPm8VwjxOSHEcSHEK0KIj7V4/RqNRrNlKBYlS/EMYxE/QyEfq8keCfRCCDfwaeCdwBHgA0KII2WH/SywIqU8CHwS+IT5/PsBv5TyNuD1wL9QFwGNRqPZbsSzeYoShkJehkNeVnpIurkHOCOlPCelzAKfBx4sO+ZB4HPm4y8BbxVCCEACYSGEBwgCWSCGRqPRbEPW03kAogEPQyEfa6kchaJs+/s6CfS7gMslX18xn7M9RkqZB9aAUYygnwBmgUvAf5ZSLpe/gRDiw0KIY0KIYwsLCw2fhEaj0WwFYikjgx8IeIn6jVqYRDbf9vdt92bsPUAB2AnsB/61EOJA+UFSys9IKY9KKY+Oj9sOMddoNJotjwr00YCXSMAI9PF0bwT6GWBPyde7zedsjzFlmkFgCfgg8HdSypyUch54HDh6vYvWaDSarYiSbgaCHiIqo8/0RqB/BjgkhNgvhPABDwEPlx3zMPAh8/H7gEellBJDrnkLgBAiDNwHvNqKhWs0Gs1WI5auzOjXeyHQm5r7R4BHgFeAv5RSnhRCfFwI8R7zsD8CRoUQZ4BfAlQJ5qeBiBDiJMYF4/+TUr7U6pPQaDSarYCV0Qc2MvpOSDeOOmOllF8Dvlb23K+VPE5jlFKW/7u43fMajUazHdmk0feYdKPRaDSaFhBL5wh4Xfg8LivQ94R0o9FoNJrWsJ7OMxDwAnRUutGBXqPRaDpELJ0jam7ChrV0o9FoNP3HejpP1MzofR5DwonrQK/RaDT9QypbIORzW1+HfW6S2ULb31cHeo1Go+kQybJAH/S6SeV0oNdoNJq+IZ0rEPBuBPqAz01KZ/QajUbTP6RyBYIlgT7k0xm9RqPR9BWpXIFguXSjM3qNRqPpH5LZzYE+oDV6jUaj6R8KRUk2X6yUbnRGr9FoNP1B2szcSwO9rrrRaDSaPkIF9E0avd6M1Wg0mv5BSTSbM3qPlm40Go2mX7DP6F2kcgWMOU3tQwd6TQXr6RxPnl3q9jI0mr7CPqN3UyhKcgUd6DUd5qNfPs4H/vv3efbiSreXotH0DSm7zVif4WDZbvlGB3pNBd985RoAT5xZ7PJKNJr+QQX6QFnDVOlr7UIHes0mEpk8mXwRgLML8S6vZvuxnMjy8ItXKRTbeyuv6Twqaw+VafTQ/kDvaGasZvtweSVpPb64nKxxpKYd/PuvHOfrJ+bI5Aq8/+iebi9H00KqVd0AJLPt9aTXGb1mE5eXUwDcvGOAKyupLq9meyGl5B9eWwDgsVMLXV6NptXYa/TG47SWbjSdZCmeAeDmHVGWE1mKPSYhfP/cEsuJbLeX0RZmVlMkzKzvhcur3V2MpuWka2j07R4+ogO9ZhMryRwAhyaiFIqSlWTvBNUTM2s89Jnv84tfeKHbS2kLp68ZeyI/eOM4M6uptmd5ms6StJFuAl4jBGdyxba+tw70mk2sJLMEvC72jAQBWIz3TqB/9NV5AL7z2kJfblbOrBpS2RsPjgFwWe+R9BWpXAGvW+B1b4RdNYQkndcZvaaDrCSyDId8jEX8ACyaUk4vUFoFdKkPg+D8egaXgNftHQL68xy3M6ns5ulSAH6Pzug1XWAl2buB/txCgojfqFK4sJTo8mpaz3wszWjEz/RYGNAZfb+RLpsuBTqj13SJ5USW4bCX4ZAXgFVTs+8FLiwmuO/AKADX1tJdXk3rmV/PMBH1MxLy4XEJ5td75yKruX7KB4ODzug1XWI1mWMo5GMgaAT6tVRvBPpUtsB6Js/tuwcRAuZi/Rjo00xE/bhcgrGIXwf6PiOVq5RudEav6QqxdJ6BgBev20XY5ybWI4FeSUhTAwFGw36u9WOgj2WYiAYAmBjws6ADfV+RLpsXC+Bz64xe0wUSmTwRv/FhHAh6eyajXzJr58eiPiai/RcEpTRKWUciPgAmojqj7zdS2UqN3uUS+DwundFrOkehKEnlCoTNDc/BHgr0i2bQGw37GQp5e2rvoBWkcgVyBcmgKZmNR/0srPffXct2xk6jB0On1xm9pmMkTL8NVdnSWxm9EejHon6GQz5We2RdrSKWMn72G4E+wFIiS77Q3gCg6RxpG40eDJ1eGQm2Cx3oNRaJjBFsejKjNxu3RsM+BkNeVnuoY7cVqJ/zQMAI9CMhL1L2zma45vpJ2ZRXgsrotXSj6RDlgX4g4GU93V5XPacsxjNE/B4CXjdDQUO6aff4tU4SS5uBPmj87IfDhla/0mcSVTmFouQTf/cqj2+D2Qcpm81YMAO9zug1nSKeMbIKtRnbSxn9SiLLiBn8hkJe8kVpGYD1A2tmQFfSzVDIONd+u3Mp57unF/j9x87y4T8+1u2ltJ1k1j7QB7xu7V6p6RxWRu/bkG7imXxP6MSxdN7KdlUQXOkjF8ty6UY1rPV7Rv/MhWUAEtlCX5bMKgpFSTZfrC7d6Ixe0yniZqCPBIyAGjX/Vs93k1gqZwXBoWDvde1eL0q6URn98DbJ6E/MxKzH/TzRLG3jRa/QGb2mo6iMXlXdqIDfCzr9ejpvXXiiZsBfz/RPoFcZvTrHwR60oGgHV1aS3L57EICLS/3r7WMNHelljV4I8Q4hxCkhxBkhxEdtXvcLIb5gvv6UEGK65LXbhRBPCiFOCiGOCyECLVz/Ji4s9p/RVSeJl23GRs2/E20ec+aEWHojo1fBMJHpH40+lsoT8XvwmJ2SUb8Hj0v01DyAViOlZGY1xdF9I3hcoq9N3OzGCCp6IqMXQriBTwPvBI4AHxBCHCk77GeBFSnlQeCTwCfMf+sB/hT4OSnlLcCbgbakKE+dW+Itv/MYf/3CTDu+/bYgXpbRq4Af74GMPpbKWZm8ta4+y+gHAhsjnIUQDIW8fa3RLyWypHNF9o4EGYv4e8optdVshYz+HuCMlPKclDILfB54sOyYB4HPmY+/BLxVCCGAtwMvSSlfBJBSLkkp23LpumPPEAcnInzuiQvt+PbbgkQmj9slLEc9S7rpskafLxRJZAvWZmzYrAqK91FGv57euJAphkK+vtboZ8yZxLuGQ4xFfX1na1FKvYw+0wMWCLuAyyVfXzGfsz1GSpkH1oBR4EZACiEeEUI8J4T4t3ZvIIT4sBDimBDi2MJCc0ORA143bzk8yfGZNT2CrUkSmQJhnxvjGl0i3XQ50Ks7DRUIo37j716402gVyWzBuoAphvvQ6qEUlcGPR/2MR/wsbIeMvkrVTXqLWyB4gDcCP2n+/aNCiLeWHySl/IyU8qiU8uj4+HjTb3bbrkF
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(B_spike_smooth[0][:5000])  # ~10 trials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Reverse correlation\n",
    "\n",
    "TL;DR: We find the reverse correlation matrices. When we plot them they look meh, but if we plot them smoothed, they look awesome. However, we shouldn't use this smoothing when decoding parameters because it uses our (parameter-defined) notion of distance between points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "B_stim_total = np.sum(B_stim['phase'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "R = dict()\n",
    "for key in key_list:\n",
    "    R[key] = list()\n",
    "    for i in range(len(B_stim[key])):\n",
    "        item = []\n",
    "        for u in range(len(B_spike_smooth)):\n",
    "            item.append(B_stim[key][i].dot(np.roll(B_spike_smooth[u], 80)))\n",
    "        R[key].append(item)\n",
    "    R[key] = np.array(R[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "R['pair'] = R['pair'].reshape((20, 20, 40))\n",
    "Rp = R['pair']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "R_pair_smoothed = np.array([scipy.ndimage.gaussian_filter(R['pair'][:, :, i], sigma=2) for i in range(40)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 864x936 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(4, 4, figsize=(12, 13))\n",
    "fig.tight_layout(w_pad=2)\n",
    "for i, ax in enumerate(axs.flatten()):\n",
    "    ax.imshow(R['pair'][:, :, i], extent=(0, 360, 0, 180), aspect=2)\n",
    "    ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 864x936 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(4, 4, figsize=(12, 13))\n",
    "fig.tight_layout(w_pad=2)\n",
    "for i, ax in enumerate(axs.flatten()):\n",
    "    ax.imshow(R_pair_smoothed[i], extent=(0, 360, 0, 180), aspect=2)\n",
    "    ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Topological noise reduction: 100%|██████████| 100/100 [01:57<00:00,  1.18s/it]\n"
     ]
    }
   ],
   "source": [
    "res = top_noise_reduction(pd.DataFrame(Rp.reshape((400, 40)))).to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "128.81601674915015"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Intermission: save variables to a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('dump.pkl', 'wb') as f:\n",
    "    pickle.dump({k: globals()[k] for k in [\n",
    "        'data_folder', 'stim_file', 'spike_times_file', 'key_symbol', \n",
    "        'stim', 'num_trial', 'stim_val', 'trial_stim_id', 'key_list', 'stim_id_trial', 'num_stim', 'key', 'pair_id', 'trial_pair_id', 'pair_val', 'pair_trial_id',\n",
    "        'spike_times', 'num_unit', 'num_spike', 'spike_count_rate', 'avg_firing_rate', 'firing_rate', 'stim_num_trial', 'stim_hist', 'optimal_avg_firing_rate',\n",
    "        'latest_spike_time', 'dt', 'exp_time', 'B_stim', 'trials', 't_on', 't_off', 'B_spike', 'trial_range', 'units', 'orientation', 'phase', 'trial_spike_times',\n",
    "        'delta_t_on', 'delta_t_off', 'subseq_trials', 'subseq_spike_times', 'subseq_spike_times_locked', 'time_range', 'unit_id_2', 'p1', 'p2', 'delta_t', 'time_range_smoothing',\n",
    "        'period_1_dist', 'period_2_dist', 'period_3_dist', 'num_units', 'max_p_1', 'max_p_2', 'max_p_3', 'delta_2', 'delta_3', 't_p1', 't_p2', 'subseq_spike_times_locked_2',\n",
    "        'B_spike_fixed', 'B_stim_original', 'B_spike_smooth', 'B_stim_total', 'R', 'R_pair_smoothed', 'Rp'\n",
    "        ]}, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['data_folder', 'stim_file', 'spike_times_file', 'key_symbol', 'stim', 'num_trial', 'stim_val', 'trial_stim_id', 'key_list', 'stim_id_trial', 'num_stim', 'key', 'pair_id', 'trial_pair_id', 'pair_val', 'pair_trial_id', 'spike_times', 'num_unit', 'num_spike', 'spike_count_rate', 'avg_firing_rate', 'firing_rate', 'stim_num_trial', 'stim_hist', 'optimal_avg_firing_rate', 'latest_spike_time', 'dt', 'exp_time', 'B_stim', 'trials', 't_on', 't_off', 'B_spike', 'trial_range', 'units', 'orientation', 'phase', 'trial_spike_times', 'delta_t_on', 'delta_t_off', 'subseq_trials', 'subseq_spike_times', 'subseq_spike_times_locked', 'time_range', 'unit_id_2', 'p1', 'p2', 'delta_t', 'time_range_smoothing', 'period_1_dist', 'period_2_dist', 'period_3_dist', 'num_units', 'max_p_1', 'max_p_2', 'max_p_3', 'delta_2', 'delta_3', 't_p1', 't_p2', 'subseq_spike_times_locked_2', 'B_spike_fixed', 'B_stim_original', 'B_spike_smooth', 'B_stim_total', 'R', 'R_pair_smoothed', 'Rp', 'firing_rates_noise_red', 'firing_rates_flat', 'firing_rates_in_trials', 'avg_firing_rates'])\n"
     ]
    }
   ],
   "source": [
    "file = open(\"dump.pkl\", 'rb')\n",
    "data = pkl.load(file)\n",
    "print(data.keys())\n",
    "for key, value in data.items():\n",
    "    globals()[key] = value\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__name__ __doc__ __package__ __loader__ __spec__ __builtin__ __builtins__ _ih _oh _dh In Out get_ipython exit quit _ __ ___ os sys __vsc_ipynb_file__ _i _ii _iii _i1 np plt pd scipy sts pkl widgets mplot3d Axes3D sparse cm cmap_hot cmap_viridis cmap_jet _i2 data_folder stim_file spike_times_file key_symbol _i3 stim num_trial stim_val trial_stim_id key_list stim_id_trial num_stim key pair_id trial_pair_id pair_val pair_trial_id i _i4 _4 _i5 _i6 _i7 _7 _i8 spike_times active num_unit _8 _i9 num_spike _i10 files file_name file data value spike_count_rate avg_firing_rate sem_firing_rate firing_rate stim_num_trial C_r_fphi_theta theta_hist phase_hist pair_hist corr_stim_unit optimal_avg_firing_rate stim_hist stim_hist_caution _i11 max_delay tau_id_range latest_spike_time latest_stim_offtime experiment_dur dt exp_time M _i12 B_stim stim_id trials s trial_id t_on t_off B_spike unit_id _i13 sorted_spike_num cutoff_num_spike _i14 t0 t1 stim_prev_id t_prev_on t_prev_off spikes _i15 gridspec fig ax gs0 ax0 ax1 ax2 ax3 _i16 ref_trial_id past_trials future_trials trial_range units orientation phase ref_id _i17 PSSH _i18 trial_spike_times delta_t_on delta_t_off subseq_trials subseq_spike_times subseq_spike_times_locked _i19 time_range _i20 subseq_spike_times_len chain _20 _i21 unit_id_2 _i22 stim_2diffs _i23 p1 p2 delta_t time_range_smoothing period_1_dist period_2_dist period_3_dist num_units j row hist _i24 _24 _i25 _25 _i26 max_p_1 max_p_2 max_p_3 delta_2 delta_3 _i27 t_p1 t_p2 fix_time _i28 _28 _i29 subseq_spike_times_locked_2 _i30 _i31 B_spike_fixed _i32 deepcopy B_stim_original _i33 _i34 get_trial_index _i35 B_spike_smooth _i36 _36 _i37 _37 _i38 _38 _i39 _39 _i40 _40 _i41 _41 _i42 B_stim_total _i43 _i44 R _i45 item u _i46 _i47 _i48 _i49 _i50 _i51 _51 _i52 _52 _i53 _53 _i54 _54 _i55 _i56 _56 _i57 _57 _i58 _58 _i59 _59 _i60 _60 _i61 _61 _i62 _62 _i63 _63 _i64 _64 _i65 _65 _i66 _66 _i67 R_pair_smoothed _i68 axs _i69 _i70 _i71 _i72 _i73 _i74 _i75 _i76 _i77 _i78 _i79 _i80 _i81 _i82 _i83 _i84 _i85 _i86 _i87 _i88 _i89 _i90 _i91 _i92 _i93 _i94 _i95 _i96 _i97 _i98 _i99 _i100 R1 item1 _i101 _i102 _i103 _i104 Rp _i105 _i106 _i107 _i108 _i109 top_noise_reduction _i110 _i111 _i112 _i113 res _i114 _114 _i115 _115 _i116 _116 _i117 _117 _i118 _118 _i119 _i120 _120 _i121 _121 _i122 pickle _i123 f _i124 _i125 _i126 _i127 _i128 _128 _i129 _129 _i130 _130 _i131\n"
     ]
    }
   ],
   "source": [
    "print(*globals().keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Forward correlation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "firing_rates_in_trials = []   # by pair, then by trial, then by neuron\n",
    "firing_rates_flat = []\n",
    "\n",
    "for trial_ids in stim_id_trial['pair']:\n",
    "    row = []\n",
    "    for trial_id in trial_ids:\n",
    "        ind = round(get_trial_index(trial_id))\n",
    "        rr = []\n",
    "        for u in range(len(B_spike_smooth)):\n",
    "            rr.append(np.mean(B_spike_smooth[u][ind + 50:ind + 90]))\n",
    "        row.append(np.array(rr))\n",
    "        firing_rates_flat.append(np.array(rr))\n",
    "    firing_rates_in_trials.append(np.array(row))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(400, (50, 40))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firing_rates_flat = np.array(firing_rates_flat)\n",
    "len(firing_rates_in_trials), firing_rates_in_trials[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_firing_rates = np.array([np.mean(fr_pair, axis=0) for fr_pair in firing_rates_in_trials]).reshape((20, 20, 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 20, 40)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 864x936 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(4, 4, figsize=(12, 13))\n",
    "fig.tight_layout(w_pad=2)\n",
    "for i, ax in enumerate(axs.flatten()):\n",
    "    ax.imshow(avg_firing_rates[:, :, i], extent=(0, 360, 0, 180), aspect=2)\n",
    "    ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "G_PAD = 5\n",
    "\n",
    "def gauss(img):\n",
    "    img_vpad = np.concatenate((img[-G_PAD:][:, ::-1], img, img[:G_PAD][:, ::-1]))\n",
    "    # pad horizontally too\n",
    "    img_vhpad = np.concatenate((img_vpad[:, -G_PAD:], img_vpad, img_vpad[:, :G_PAD]), axis=1)\n",
    "    return scipy.ndimage.gaussian_filter(img_vhpad, sigma=2, mode='wrap')[G_PAD:-G_PAD, G_PAD:-G_PAD]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 20)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_fr_blur = np.array([gauss(avg_firing_rates[:, :, i]) for i in range(40)])\n",
    "gauss(avg_firing_rates[:, :, 0]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 864x936 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(4, 4, figsize=(12, 13))\n",
    "fig.tight_layout(w_pad=2)\n",
    "for i, ax in enumerate(axs.flatten()):\n",
    "    ax.imshow(avg_fr_blur[i], extent=(0, 360, 0, 180), aspect=2)\n",
    "    ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")\n",
    "avg_fr_blur = avg_fr_blur.swapaxes(0, 2).reshape((400, 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.,   9.,  18.,  27.,  36.,  45.,  54.,  63.,  72.,  81.,  90.,\n",
       "        99., 108., 117., 126., 135., 144., 153., 162., 171.])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stim_val['orientation']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f26f889e2c0>]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from sym_model import sigmoid\n",
    "# sns.distplot([np.argmax(avg_fr_blur.reshape((20, 20, 40))[:, :, i], axis=0) for i in range(40)])\n",
    "# plt.imshow(sigmoid(avg_fr_blur * 10000).reshape((20, 20, 40)).sum(axis=2), extent=(0, 360, 0, 180), aspect=2)\n",
    "plt.plot(stim_val['orientation'], sigmoid(avg_fr_blur * 10000).reshape((20, 20, 40)).sum(axis=2).mean(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Topological noise reduction (not used)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.insert(0, '../model')\n",
    "from noisereduction import top_noise_reduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Topological noise reduction: 100%|██████████| 100/100 [31:33<00:00, 18.93s/it]\n"
     ]
    }
   ],
   "source": [
    "firing_rates_noise_red = top_noise_reduction(pd.DataFrame(firing_rates_flat[::5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(400, 40)"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firing_rates_noise_red.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Topological noise reduction: 100%|██████████| 100/100 [3:44:17<00:00, 134.57s/it] \n"
     ]
    }
   ],
   "source": [
    "firing_rates_noise_red = top_noise_reduction(pd.DataFrame(firing_rates_flat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2000, 40)"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firing_rates_noise_red = firing_rates_noise_red.to_numpy()\n",
    "firing_rates_noise_red.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firing_rates_noise_red[0] in firing_rates_flat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "from decoding import cohomological_parameterization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decoding... done\n"
     ]
    }
   ],
   "source": [
    "param = cohomological_parameterization(pd.DataFrame(firing_rates_noise_red[::5, ::5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fr_df = pd.DataFrame(firing_rates_flat)\n",
    "sns.heatmap(fr_df.corr())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(400, 40)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_fr_blur.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(400, 7)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.000519</td>\n",
       "      <td>-0.000166</td>\n",
       "      <td>-0.000440</td>\n",
       "      <td>-0.000621</td>\n",
       "      <td>0.000040</td>\n",
       "      <td>0.000021</td>\n",
       "      <td>0.000077</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.000851</td>\n",
       "      <td>-0.000060</td>\n",
       "      <td>-0.000512</td>\n",
       "      <td>-0.000473</td>\n",
       "      <td>0.000343</td>\n",
       "      <td>0.000135</td>\n",
       "      <td>0.000052</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.001155</td>\n",
       "      <td>0.000042</td>\n",
       "      <td>-0.000481</td>\n",
       "      <td>-0.000354</td>\n",
       "      <td>0.000566</td>\n",
       "      <td>0.000213</td>\n",
       "      <td>0.000038</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.001385</td>\n",
       "      <td>0.000152</td>\n",
       "      <td>-0.000368</td>\n",
       "      <td>-0.000247</td>\n",
       "      <td>0.000665</td>\n",
       "      <td>0.000252</td>\n",
       "      <td>0.000033</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-0.001536</td>\n",
       "      <td>0.000289</td>\n",
       "      <td>-0.000196</td>\n",
       "      <td>-0.000120</td>\n",
       "      <td>0.000648</td>\n",
       "      <td>0.000248</td>\n",
       "      <td>0.000016</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1         2         3         4         5         6\n",
       "0 -0.000519 -0.000166 -0.000440 -0.000621  0.000040  0.000021  0.000077\n",
       "1 -0.000851 -0.000060 -0.000512 -0.000473  0.000343  0.000135  0.000052\n",
       "2 -0.001155  0.000042 -0.000481 -0.000354  0.000566  0.000213  0.000038\n",
       "3 -0.001385  0.000152 -0.000368 -0.000247  0.000665  0.000252  0.000033\n",
       "4 -0.001536  0.000289 -0.000196 -0.000120  0.000648  0.000248  0.000016"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N_COMP = 7\n",
    "pca = PCA(n_components=N_COMP)\n",
    "pca.fit(avg_fr_blur)\n",
    "data_pca = pca.transform(avg_fr_blur)\n",
    "data_pca = pd.DataFrame(data_pca)\n",
    "print(data_pca.shape)\n",
    "data_pca.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(400, 50, 7)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firing_rates_in_trials_pca = []\n",
    "for trials in firing_rates_in_trials:\n",
    "    firing_rates_in_trials_pca.append(pca.transform(pd.DataFrame(trials)))\n",
    "firing_rates_in_trials_pca = np.array(firing_rates_in_trials_pca)\n",
    "firing_rates_in_trials_pca.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_firing_rates_pca = data_pca.to_numpy().reshape((20, 20, N_COMP))# np.mean(firing_rates_in_trials_pca, axis=1).reshape((20, 20, N_COMP))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 864x864 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "fig, axs = plt.subplots(2, 3, figsize=(12, 12))\n",
    "fig.tight_layout(w_pad=2)\n",
    "for i, ax in enumerate(axs.flatten()[:7]):\n",
    "    ax.imshow(avg_firing_rates_pca[:, :, i], extent=(0, 360, 0, 180), aspect=2)\n",
    "    ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 864x936 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "fig, axs = plt.subplots(2, 3, figsize=(12, 13))\n",
    "fig.tight_layout(w_pad=2)\n",
    "for i, ax in enumerate(axs.flatten()):\n",
    "    ax.imshow(scipy.ndimage.gaussian_filter(avg_firing_rates_pca[:, :, i], sigma=2), extent=(0, 360, 0, 180), aspect=2)\n",
    "    ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Point Cloud Simplification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def radial_distance(X, eps, random_state=None):\n",
    "    \"\"\"\n",
    "    point cloud simplification using radial distance (euclidean metric). \n",
    "    Start with the first point in in X and mark it as a key point. All consecutive points that have a distance less than a predetermined distance eps to the key point are removed. The first point that have a distance greater than eps to the key point is marked as the new key point. The process repeates itself from this new key point, and continues until it reaches the end of the point cloud.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    X: pandas DataFrame (n_datapoints, n_features):\n",
    "\n",
    "    eps: max radial distance - cutoff distance\n",
    "\n",
    "    random_state: seed of random generator used for choosing the inital point\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    X.iloc[ind_reduced]: dataframe with chosen datapoints \n",
    "    \"\"\"\n",
    "    if random_state is not None:\n",
    "        np.random.seed(random_state)\n",
    "        \n",
    "    ix0 = np.random.choice(X.shape[0])\n",
    "    x0 = X.iloc[ix0]\n",
    "    xt = x0\n",
    "    ixt = ix0\n",
    "    X_temp = X\n",
    "    ind_reduced = [ix0]\n",
    "\n",
    "    while True:\n",
    "        dist = np.linalg.norm(X_temp.to_numpy() - xt.to_numpy(), axis=1)\n",
    "        cond = dist < eps\n",
    "\n",
    "        X_temp = X_temp.drop(X_temp.index[np.where(cond)])\n",
    "        if len(X_temp)==0:\n",
    "            break\n",
    "\n",
    "        where_not_cond = np.where(np.logical_not(cond))\n",
    "        w = np.argmin(dist[where_not_cond])        \n",
    "        ixt = X_temp.index[w]\n",
    "        xt = X.iloc[ixt]\n",
    "        ind_reduced.append(ixt)\n",
    "\n",
    "    return X.iloc[ind_reduced], ind_reduced   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from noisereduction import compute_gradient\n",
    "def top_noise_reduction(X, n=100, omega=0.2, fraction=0.1, plot=False):\n",
    "    \"\"\"\n",
    "    Topological denoising algorithm as in arxiv:0910.5947\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    X: dataframe(n_datapoints, n_features):\n",
    "        Dataframe containing the data\n",
    "    n: int, optional, default 100\n",
    "        Number of iterations\n",
    "    omega: float, optional, default 0.2\n",
    "        Strength of the repulsive force between datapoints\n",
    "    fraction: float between 0 and 1, optional, default 0.1\n",
    "        The fraction of datapoints from which the denoised dataset is\n",
    "        constructed\n",
    "    plot: bool, optional, default False\n",
    "        When true plot the dataset and homology each iteration\n",
    "    \"\"\"\n",
    "    N = X.shape[0]\n",
    "    inds = np.random.choice(N, round(fraction*N), replace=False)\n",
    "    S = X.iloc[inds]\n",
    "    sigma = X.stack().std()\n",
    "    c = 0.02*np.max(scipy.spatial.distance.cdist(X, X, metric='euclidean'))\n",
    "    \n",
    "    iterator = trange(0, n, position=0, leave=True)\n",
    "    iterator.set_description(\"Topological noise reduction\")\n",
    "    for i in iterator:\n",
    "        gradF = compute_gradient(S.to_numpy(), X.to_numpy(), sigma, omega)\n",
    "            \n",
    "        if i == 0:\n",
    "            maxgradF = np.max(np.sqrt(np.square(gradF).sum(axis=1)))\n",
    "        S = S + c* gradF/maxgradF\n",
    "        \n",
    "        if plot:\n",
    "            fig = pyplot.figure()\n",
    "            ax = Axes3D(fig)\n",
    "            ax.scatter(X[0],X[1],X[2],alpha=0.1)\n",
    "            ax.scatter(S[0],S[1],S[2])\n",
    "            pyplot.show()\n",
    "    return S, inds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(414, 7)"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fr_pca_simpl, inds_simpl = radial_distance(pd.DataFrame(firing_rates_in_trials_pca.reshape((400 * 50, -1))), 0.025)\n",
    "fr_pca_simpl.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(400, 2)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param_corr = stim_val['pair']  # [np.array(inds_simpl) // 50]\n",
    "param_corr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_firing_rates_pca_ = avg_firing_rates_pca.reshape((-1, N_COMP))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 576x576 with 15 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "ncomp_disp = 5\n",
    "fig = plt.figure(figsize=(8,8))\n",
    "for j in range(ncomp_disp):\n",
    "  for i in range(j+1):\n",
    "    ax = fig.add_subplot(ncomp_disp,ncomp_disp, j + ncomp_disp*i + 1)\n",
    "    if i == j:\n",
    "      ax.scatter(\n",
    "        # param_corr[:, 0],\n",
    "        stim_val['pair'].reshape((-1, 2))[:, 1],\n",
    "        avg_firing_rates_pca_[:, i], s=1)\n",
    "      ax.set(xlabel='stim', ylabel='PC%d'%i)\n",
    "    else:\n",
    "      ax.scatter(avg_firing_rates_pca_[:, j], avg_firing_rates_pca_[:, i], s=1, c=stim_val['pair'].reshape((-1, 2))[:, 1], cmap='hsv')\n",
    "    \n",
    "    ax.set(xticks=[], yticks=[])\n",
    "    \n",
    "    if i==0 and j>0:\n",
    "      ax.set(xlabel='PC%d'%j)\n",
    "      ax.xaxis.set_label_position('top') \n",
    "\n",
    "    if j==ncomp_disp-1 and i<ncomp_disp-1:\n",
    "      ax.set(ylabel='PC%d'%i)\n",
    "      ax.yaxis.set_label_position('right') \n",
    "\n",
    "fig.set_facecolor('white')\n",
    "fig.suptitle('PCA')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### UMAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from umap import UMAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "ncomp_umap = 4\n",
    "embed = UMAP(n_components=ncomp_umap, n_neighbors=10, metric='euclidean').fit_transform(avg_firing_rates_pca_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_corr[:, 0].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a036911daea64abdac7731b44eefce28",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "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
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='data:image/png;base64,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
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mpl_toolkits import mplot3d\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "%matplotlib inline\n",
    "%matplotlib widget\n",
    "\n",
    "x, y, z, u = embed[:,0], embed[:,1], embed[:,2], embed[:,3]    \n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=(20, 10))\n",
    "# ax.scatter3D(x, y, z, c=np.array([param_corr[:, 0] / 180, [0] * param_corr.shape[0], param_corr[:, 1] / 360]).swapaxes(0, 1))\n",
    "ax = fig.add_subplot(1, 2, 1, projection='3d')\n",
    "ax.scatter3D(x, y, z, c=param_corr[:, 0], cmap=\"hsv\")\n",
    "ax.set(xlabel=\"U0\", ylabel=\"U1\", zlabel=\"U2\", xticks=[], yticks=[], zticks=[])\n",
    "ax = fig.add_subplot(1, 2, 2, projection='3d')\n",
    "ax.scatter3D(x, y, z, c=param_corr[:, 1], cmap=\"hsv\")\n",
    "ax.set(xlabel=\"U0\", ylabel=\"U1\", zlabel=\"U2\", xticks=[], yticks=[], zticks=[])\n",
    "# ax = fig.add_subplot(2, 2, 3, projection='3d')\n",
    "# ax.scatter3D(x, y, u, c=param_corr[:, 0], cmap=\"hsv\")\n",
    "# ax.set(xlabel=\"U0\", ylabel=\"U1\", zlabel=\"U3\", xticks=[], yticks=[], zticks=[])\n",
    "# ax = fig.add_subplot(2, 2, 4, projection='3d')\n",
    "# ax.scatter3D(x, y, u, c=param_corr[:, 1], cmap=\"hsv\")\n",
    "# ax.set(xlabel=\"U0\", ylabel=\"U1\", zlabel=\"U3\", xticks=[], yticks=[], zticks=[])\n",
    "fig.suptitle('UMAP 3D')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "65996d51cb674a8b957ab31e54312416",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABaAAAALQCAYAAABmJdeHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd5xcV33//9e5d2a2qxdLsmy5yL1hbGObZmya6TUU0xMgAcKXloQACeUXEiCBJPQSmoHQ4mC6CR3TbNy7XGSrWVZvO7s75d7z+2N2VVfSrrSz9fV8PPSwd/funTuj1ew573vO5xNijEiSJEmSJEmSNNKSsb4ASZIkSZIkSdLkZAAtSZIkSZIkSWoKA2hJkiRJkiRJUlMYQEuSJEmSJEmSmsIAWpIkSZIkSZLUFAbQkiRJkiRJkqSmMICWJEmSJEmSJDWFAbQkSZIkSZIkqSkMoCVJkiRJkiRJTWEALUmSJEmSJElqCgNoSZIkSZIkSVJTGEBLkiRJkiRJkprCAFqSJEmSJEmS1BQG0JIkSZIkSZKkpjCAliRJ0oQXQoghhOP3+tx7Qghf7f//i/qP+c5ex5zZ//lf7fX5EEJYHkK4Y5DH+lUIoS+E0B1C2BhC+N8QwoL9XNeHQgirQgjbQwgrQgjv2O1rS/ofu7v/z7oQwg9CCE84jJdCkiRJGlcMoCVJkjRVbAAuCCHM3u1zLwfuHuTYxwDzgGNDCOcO8vU3xBg7gROAGcC/7+cxPw+cFGOcBlwIXBZCeM5ex8zoP9eZwE+B74QQXjG0pyRJkiSNbwbQkiRJmiqqwJXACwFCCCnwAuBrgxz7cuC7wI/6/39QMcbNwBXAafv5+rIYY3m3T+XA8fs59qEY438C7wE+GEJwrC5JkqQJz0GtJEmSppLLgZf1//+TgNuAB3c/IITQDjyPRjD9NeCFIYTSYCcLIcwBngvcuL8HDCG8PYTQDawGOoD/Psg1/i+N1dcnHuzJSJIkSeOdAbQkSZKmjBjj74FZIYQTaQTRlw9y2HOACvB/wA+BIvDUvY75aAhhK3AzsBZ4ywEe8wNAF3A28BVg20EucyAQn3WQ4yRJkqRxzwBakiRJk0FGIyjeXRGoDXLsV4A3AI8DvjPI118OfCvGWI8x9tEosbF3GY43xhhnxBgXxRgvizFuONDFxYYbgV7gvQd5Lov6/7v5IMdJkiRJ415hrC9AkiRJGgErgSXAnbt97hgGbzD4FeBe4PIYY08IYecXQghHAhcD54UQntv/6XagNYQwJ8a48TCvswAcd5Bjng2sB5Yd5mNJkiRJY84V0JIkSZoMvgm8K4RwZAghCSE8Hng68D97HxhjvB94LPDOQc7zUhqh9YnAWf1/TqBRv/lFw7mg/ut4bQhhZmg4D3g98PP9HD8/hPAG4N3A38cY8+E8niRJkjQeuQJakiRJk8H7+v/8FpgJ3AdcFmO8bbCDY4y/3c95Xg58Isb40O6fDCF8uv9rHxvmdT0b+BegRKO288cGOcfW0FiGXQauA54fY7xqmI8jSZIkjUshxjjW1yBJkiRJkiRJmoQswSFJkiRJkiRJagoDaEmSJEmSJElSUxhAS5IkSZIkSZKawgBakiRJkiRJktQUBtCSJEmSJEmSpKYwgJYkSZIkSZIkNYUBtCRJkiRJkiSpKQygJUmSJEmSJElNYQAtSZIkSZIkSWoKA2hJkiRJkiRJUlMYQEuSJEmSJEmSmsIAWpIkSZIkSZLUFAbQkiRJkiRJkqSmMICWJEmSJEmSJDWFAbQkSZIkSZIkqSkMoCVJkiRJkiRJTWEALUmSJEmSJElqCgNoSZIkSZIkSVJTGEBLkiRJkiRJkprCAFqSJEmSJEmS1BQG0JIkSZIkSZKkpjCAliRJkiRJkiQ1hQG0JEmSJEmSJKkpDKAlSZIkSZIkSU1hAC1JkiRJkiRJagoDaEmSJEmSJElSUxhAS5IkSZIkSZKawgBakiRJkiRJktQUBtCSJEmSJEmSpKYwgJYkSZIkSZIkNYUBtCRJkiRJkiSpKQygJUmSJEmSJElNYQAtSZIkSZIkSWoKA2hJkiRJkiRJUlMYQEuSJEmSJEmSmsIAWpIkSZIkSZLUFAbQkiRJkiRJkqSmMICWJEmSJEmSJDWFAbQkSZIkSZIkqSkMoCVJkiRJkiRJTWEALUmSJEmSJElqCgNoSZIkSZIkSVJTGEBLkiRJkiRJkprCAFqSJEmSJEmS1BQG0JIkSZIkSZKkpjCAliRJkiRJkiQ1hQG0JEmSJEmSJKkpDKAlSZIkSZIkSU1hAC1JkiRJkiRJagoDaEmSJEmSJElSUxhAS5IkSZIkSZKawgBakiRJkiRJktQUBtCSJEmSJEmSpKYwgJYkSZIkSZIkNYUBtCRJkiRJkiSpKQygJUmSJEmSJElNYQAtSZIkSZIkSWoKA2iNiRDCF0II60MIt+3n6yGE8NEQwr0hhFtCCGeP9jVKkiRJkiRJOjwG0BorXwKefICvXwos7f/zGuBTo3BNkiRJkiRJkkaQAbTGRIzxN8DmAxzyTODy2PBHYEYIYcHoXJ0kSZIkSZKkkWAArfFqEbBqt49X939OkiRJkiRJ0gRRGOsLkA5XCOE1NMp00NHR8fCTTjppjK9IkiRJkiRp8rj++us3xhjnjvV1aGIygNZ4tQZYvNvHR/Z/bh8xxs8CnwU455xz4nXXXdf8q5MkSZIkSZoiQggrxvoaNHFZgkPj1feAl4WG84FtMca1Y31RkiRJkiRJkobOFdAaEyGErwMXAXNCCKuBdwNFgBjjp4EfAU8B7gV6gFeOzZVKkiRJkiRJOlQG0BoTMcYXHeTrEXj9KF2OJEmSJEmSpCawBIckSZIkSZIkqSkMoCVJkiRJkiRJTWEALUmSJEmSJElqCgNoSZIkSZIkSVJTGEBLkiRJkiRJkprCAFqSJEmSJEmS1BQG0JIkSZIkSZKkpjCAliRJkiRJkiQ1hQG0JEmSJEmSJKkpDKAlSZIkSZIkSU1hAC1JkiRJkiRJagoDaEmSJEmSJElSUxhAS5IkSZIkSZKawgBakiRJkiRJktQUIcY41tcgjSR/oCVJkiRJkkZQCOH6GOM5Y30dmphcAS1JkiRJkiRJagoDaEmSJEmSJElSUxhAS5IkSZIkSZKawgBakiRJkiRJktQUBtCSJEmSJEmSpKYwgJYkSZIkSZIkNYUBtCRJkiRJkiSpKQygJUmSJEmSJElNYQAtSZIkSZIkSWoKA2hJkiRJkiRJUlMYQEuSJEmSJEmSmsIAWpIkSZIkSZLUFAbQkiRJkiRJkqSmMICWJEmSJEmSJDWFAbQkSZIkSZIkqSkMoCVJkiRJkiRJTWEALUmSJEmSJElqCgNoSZIkSZIkSVJTGEBLkiRJkiRJkprCAFqSJEmSJEmS1BQG0JIkSZIkSZKkpjCAliRJkiRJkiQ1hQG0JEmSJEmSJKkpDKAlSZIkSZIkSU1hAC1JkiRJkiRJagoDaEmSJEmSJElSUxhAS5IkSZIkSZKawgBakiRJkiRJktQUBtCSJEmSJEmSpKYwgJYkSZIkSZIkNYUBtCRJkiRJkiSpKQygJUmSJEmSJElNYQAtSZIkSZIkSWoKA2hJkiRJkiRJUlMYQEuSJEmSJEmSmsIAWpIkSZIkSZLUFAbQkiRJkiRJkqSmKIz1BUiSRleMkUqlQpIkpGlKkiSEEMb6siRJkia1PM+pVCoUCoWdYzBJkqYCA2hJmkLq9Tr1ep2+vr6dnwshUCwW95gMGUhLkiSNjBjjHmOwgXFWkiT7jMEkSZqMDKAlaQrYfeITQiBNU2KMhBCIMVKtVqlUKsCuyVCxWCRNU0IIBtKSJEmHYGCclec5wM6xVYxx5660vcdgBtKSpMnGAFqSJrk8z6nVauR5PmiYPBBID9g9kA4hkCQJhULBQFqSJGkYBm7+D9z0393e46nBAuk0TXeOvwqFguMvSdKEZQAtSZNUjJEsy6jVagBDXkWzeyAdYwSgWq1SrVZ3nmf3QNrVOZIkSbvsvfNsYKw0MK4azGCBdJ7ne5RNGwikB1ZIG0hLkiYKA2hJmoRijNRqNbIsO6wVywP
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='data:image/png;base64,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
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize=(20, 10))\n",
    "# ax.scatter3D(x, y, z, c=np.array([param_corr[:, 0] / 180, [0] * param_corr.shape[0], param_corr[:, 1] / 360]).swapaxes(0, 1))\n",
    "ax = fig.add_subplot(1, 2, 1, projection='3d')\n",
    "ax.scatter3D(x, y, u, c=param_corr[:, 0], cmap=\"hsv\")\n",
    "ax.set(xlabel=\"U0\", ylabel=\"U1\", zlabel=\"U3\", xticks=[], yticks=[], zticks=[])\n",
    "ax = fig.add_subplot(1, 2, 2, projection='3d')\n",
    "ax.scatter3D(x, y, u, c=param_corr[:, 1], cmap=\"hsv\")\n",
    "ax.set(xlabel=\"U0\", ylabel=\"U1\", zlabel=\"U3\", xticks=[], yticks=[], zticks=[])\n",
    "\n",
    "fig.suptitle('UMAP 3D')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Decoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import decoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decoding... done\n"
     ]
    }
   ],
   "source": [
    "# param = decoding.cohomological_parameterization(pd.DataFrame(firing_rates_in_trials_pca.reshape((400*50, -1))[::41]))\n",
    "param = decoding.cohomological_parameterization(pd.DataFrame(embed))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(788,)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param_corr[:, 0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f26ce0f09a0>"
      ]
     },
     "execution_count": 5,
     "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.scatter(param_corr[:, 0], param_corr[:, 1], c=param.to_numpy())\n",
    "plt.imshow(param.to_numpy().reshape((20, 20)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f26cbff4d30>"
      ]
     },
     "execution_count": 6,
     "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.scatter(param_corr[:, 0], param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3.10/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:ylabel='Density'>"
      ]
     },
     "execution_count": 36,
     "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": [
    "sns.distplot(param.clip(0.885, 0.888))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f26a77e8d60>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plt.imshow(gauss(np.random.uniform(size=(20, 20))))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.5 64-bit",
   "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.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}