{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "stim_data.pkl\n", "dict_keys(['stim_val', 'trial_stim_id', 'key_list', 'num_trial', 'trial_pair_id', 'pair_val', 'pair_trial_id', 'stim_id_trial', 'num_stim'])\n", "spike_data.pkl\n", "dict_keys(['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", "corr_data.pkl\n", "dict_keys(['corr_stim_unit', 'optimal_avg_firing_rate', 'stim_hist', 'stim_hist_caution'])\n" ] } ], "source": [ "# load data 1\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "import scipy.stats as sts\n", "import pickle\n", "import ipywidgets as widgets\n", "from mpl_toolkits import mplot3d\n", "from mpl_toolkits.mplot3d import Axes3D\n", "from scipy import sparse\n", "from matplotlib import cm\n", "import cmocean\n", "\n", "cmap_phase = cmocean.cm.phase\n", "cmap_hot = cm.get_cmap('hot')\n", "cmap_viridis = cm.get_cmap('viridis')\n", "\n", "execfile('Stimulus.py')\n", "data_folder = \"Data/\"\n", "\n", "stim_file = \"Stiminfo_PVCre_2021_0012_s06_e14.csv\"\n", "stim = pd.read_csv(data_folder+stim_file)\n", "\n", "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", "\n", "num_unit = len(spike_times)\n", "num_trial = len(stim)\n", "\n", "# sort by firing rate\n", "\n", "num_spike = list(map(len, spike_times))\n", "# num_spike = np.array([len(spike_times[i]) for i in range(len(spike_times))])\n", "spike_times = spike_times[np.argsort(num_spike)[::-1]]\n", "execfile('load.py')\n", "\n", "max_delay = 300 # dt\n", "tau_id_range = np.arange(max_delay)\n", "\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)\n", "\n", "# binary spike and stimulus trains\n", "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)))\n", "\n", "# histogram error bars: num spikes\n", "s = np.zeros((num_unit, 2))\n", "for unit_id in range(num_unit):\n", " # print(\"unit: %d\"%unit_id)\n", " a = np.zeros(len(tau_id_range))\n", " for tau_id in tau_id_range:\n", " a[tau_id] = np.sum(B_spike[unit_id].col >= tau_id)\n", " \n", " s[unit_id] = [np.mean(a), np.std(a)]\n", "\n", "key_symbol = {'pair':'$(\\\\theta,\\phi)$', 'orientation':'$\\\\theta$', 'phase':'$\\phi$'}\n", "\n", "# 2D tuning\n", "avg_firing_rate_pair = np.array([sts.zscore(stim_hist['pair'][unit_id]).reshape((len(tau_id_range), num_stim['orientation'], num_stim['phase'])) for unit_id in range(num_unit)])\n", "\n", "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]\n", "\n", "opt_time = np.load('optimal_time.npy')\n", "stim_val_pair = pd.DataFrame(stim_val['pair'], columns=['orientation', 'phase'])" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "stim_data.pkl\n", "dict_keys(['stim_val', 'trial_stim_id', 'key_list', 'num_trial', 'trial_pair_id', 'pair_val', 'pair_trial_id', 'stim_id_trial', 'num_stim'])\n", "spike_data.pkl\n", "dict_keys(['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", "corr_data.pkl\n", "dict_keys(['corr_stim_unit', 'optimal_avg_firing_rate', 'stim_hist', 'stim_hist_caution'])\n" ] } ], "source": [ "# load data 0\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "import scipy.stats as sts\n", "import pickle\n", "import ipywidgets as widgets\n", "from mpl_toolkits import mplot3d\n", "from mpl_toolkits.mplot3d import Axes3D\n", "from scipy import sparse\n", "from matplotlib import cm\n", "\n", "cmap_hot = cm.get_cmap('hot')\n", "cmap_viridis = cm.get_cmap('viridis')\n", "\n", "execfile('Stimulus.py')\n", "data_folder = \"Data/\"\n", "\n", "stim_file = \"Stiminfo_PVCre_2021_0012_s06_e14.csv\"\n", "stim = pd.read_csv(data_folder+stim_file)\n", "\n", "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", "\n", "num_unit = len(spike_times)\n", "num_trial = len(stim)\n", "\n", "# sort by firing rate\n", "\n", "num_spike = list(map(len, spike_times))\n", "# num_spike = np.array([len(spike_times[i]) for i in range(len(spike_times))])\n", "spike_times = spike_times[np.argsort(num_spike)[::-1]]\n", "execfile('load.py')\n", "\n", "max_delay = 300 # dt\n", "tau_id_range = np.arange(max_delay)\n", "\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)\n", "\n", "# binary spike and stimulus trains\n", "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)))\n", "\n", "# histogram error bars: num spikes\n", "s = np.zeros((num_unit, 2))\n", "for unit_id in range(num_unit):\n", " # print(\"unit: %d\"%unit_id)\n", " a = np.zeros(len(tau_id_range))\n", " for tau_id in tau_id_range:\n", " a[tau_id] = np.sum(B_spike[unit_id].col >= tau_id)\n", " \n", " s[unit_id] = [np.mean(a), np.std(a)]\n", "\n", "key_symbol = {'pair':'$(\\\\theta,\\phi)$', 'orientation':'$\\\\theta$', 'phase':'$\\phi$'}\n", "\n", "# 2D tuning\n", "avg_firing_rate_pair = np.array([sts.zscore(stim_hist['pair'][unit_id]).reshape((len(tau_id_range), num_stim['orientation'], num_stim['phase'])) for unit_id in range(num_unit)])\n", "\n", "\n", "import sys\n", "sys.path.insert(0, './Persistent_Homology')\n", "\n", "from gratings import grating_model\n", "from plotting import plot_data, plot_mean_against_index, show_feature\n", "from persistence import persistence\n", "from decoding import cohomological_parameterization, remove_feature\n", "from noisereduction import *\n", "from sklearn.decomposition import PCA \n", "\n", "# relabelling\n", "param = np.arange(400).reshape(20,20)\n", "phase_ref = 10\n", "x = param[:phase_ref]\n", "reparam = np.vstack((x, x[:,::-1]))\n", "stim_val_reparam = {}\n", "stim_val_reparam['phase'] = stim_val['phase'][:phase_ref]\n", "stim_val_reparam['orientation'] = np.concatenate((stim_val['orientation'], stim_val['orientation']+180))\n", "\n", "\n", "opt_time = np.load('optimal_time.npy')" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "stim_data.pkl\n", "dict_keys(['stim_val', 'trial_stim_id', 'key_list', 'num_trial', 'trial_pair_id', 'pair_val', 'pair_trial_id', 'stim_id_trial', 'num_stim'])\n", "spike_data.pkl\n", "dict_keys(['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", "corr_data.pkl\n", "dict_keys(['corr_stim_unit', 'optimal_avg_firing_rate', 'stim_hist', 'stim_hist_caution'])\n" ] } ], "source": [ "# load data\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "import scipy.stats as sts\n", "import pickle\n", "import ipywidgets as widgets\n", "from mpl_toolkits import mplot3d\n", "from mpl_toolkits.mplot3d import Axes3D\n", "from scipy import sparse\n", "from matplotlib import cm\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')\n", "\n", "# load and process stimuli\n", "execfile('Stimulus.py')\n", "data_folder = \"Data/\"\n", "stim_file = \"Stiminfo_PVCre_2021_0012_s06_e14.csv\"\n", "stim = pd.read_csv(data_folder+stim_file)\n", "num_trial = len(stim)\n", "\n", "# load and process spikes\n", "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", "\n", "\n", "# sort by firing rate\n", "num_spike = list(map(len, spike_times))\n", "spike_times = spike_times[np.argsort(num_spike)[::-1]]\n", "execfile('load.py')\n", "\n", "# 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)\n", "\n", "# binary spike and stimulus trains\n", "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)))\n", "\n", "# histogram error bars: num spikes\n", "# spike_count = np.zeros((num_unit, 2))\n", "# for unit_id in range(num_unit):\n", "# # print(\"unit: %d\"%unit_id)\n", "# a = np.zeros(len(tau_id_range))\n", "# for tau_id in tau_id_range:\n", "# a[tau_id] = np.sum(B_spike[unit_id].col >= tau_id)\n", " \n", "# spike_count[unit_id] = [np.mean(a), np.std(a)]\n", "\n", "key_symbol = {'pair':'$(\\\\theta,\\phi)$', 'orientation':'$\\\\theta$', 'phase':'$\\phi$'}\n", "\n", "# 2D tuning\n", "avg_firing_rate_pair = np.array([sts.zscore(stim_hist['pair'][unit_id]).reshape((len(tau_id_range), num_stim['orientation'], num_stim['phase'])) for unit_id in range(num_unit)])\n", "\n", "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]\n", "\n", "\n", "from tqdm import trange\n", "import sys\n", "sys.path.insert(0, './Persistent_Homology')\n", "\n", "import gratings\n", "import decorator\n", "from noisereduction import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Optimal time independently for each unit" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "# Z = sts.zscore([stim_hist['pair'][unit_id, opt_time[unit_id], :].T for unit_id in range(num_unit)], axis=0) \n", "# taking zscore does not make sense since we are dealing with probability distributions as activity not firing rate\n", "# Z = Z[:, np.logical_not(np.isnan(Z[0]))]\n", "# n_components = len(Z[0])\n", "from sklearn.decomposition import PCA\n", "from scipy.stats import zscore\n", "n_components = 20\n", "pca = PCA(n_components)\n", "data = pd.DataFrame([stim_hist['pair'][unit_id, opt_time[unit_id], :] for unit_id in range(num_unit)]).T\n", "# X = pca.fit_transform(data)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PCA explained variance:\n", "[0.16646987 0.10646209 0.07980927 0.07637544 0.07305655 0.06312245\n", " 0.0520563 0.05141274 0.0436141 0.04114367 0.0392689 0.02982529\n", " 0.02595947 0.02514927 0.02247076 0.01964191 0.01509293 0.01312476\n", " 0.01038999 0.0080545 ]\n" ] } ], "source": [ "ncomp = 20\n", "data = PCA_reduction(data, ncomp)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "13e6d26adfaf4482833713f11abb7724", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "
\n", " | decoding | \n", "phase | \n", "orientation | \n", "
---|---|---|---|
0 | \n", "0.437717 | \n", "0.0 | \n", "0.0 | \n", "
1 | \n", "0.449213 | \n", "18.0 | \n", "0.0 | \n", "
2 | \n", "0.429066 | \n", "36.0 | \n", "0.0 | \n", "
3 | \n", "0.424594 | \n", "54.0 | \n", "0.0 | \n", "
4 | \n", "0.816654 | \n", "72.0 | \n", "0.0 | \n", "
... | \n", "... | \n", "... | \n", "... | \n", "
395 | \n", "0.438846 | \n", "270.0 | \n", "171.0 | \n", "
396 | \n", "0.441466 | \n", "288.0 | \n", "171.0 | \n", "
397 | \n", "0.462445 | \n", "306.0 | \n", "171.0 | \n", "
398 | \n", "0.672323 | \n", "324.0 | \n", "171.0 | \n", "
399 | \n", "0.677862 | \n", "342.0 | \n", "171.0 | \n", "
400 rows × 3 columns
\n", "\n", " | decoding | \n", "phase | \n", "orientation | \n", "
---|---|---|---|
0 | \n", "0.217130 | \n", "0.0 | \n", "0.0 | \n", "
1 | \n", "0.329715 | \n", "18.0 | \n", "0.0 | \n", "
2 | \n", "0.244882 | \n", "36.0 | \n", "0.0 | \n", "
3 | \n", "0.260258 | \n", "54.0 | \n", "0.0 | \n", "
4 | \n", "0.781878 | \n", "72.0 | \n", "0.0 | \n", "
... | \n", "... | \n", "... | \n", "... | \n", "
395 | \n", "0.204446 | \n", "270.0 | \n", "171.0 | \n", "
396 | \n", "0.207642 | \n", "288.0 | \n", "171.0 | \n", "
397 | \n", "0.181627 | \n", "306.0 | \n", "171.0 | \n", "
398 | \n", "0.552974 | \n", "324.0 | \n", "171.0 | \n", "
399 | \n", "0.558591 | \n", "342.0 | \n", "171.0 | \n", "
400 rows × 3 columns
\n", "\n", " | decoding | \n", "
---|---|
261 | \n", "0.932910 | \n", "
396 | \n", "0.930706 | \n", "
322 | \n", "0.932025 | \n", "
253 | \n", "0.930178 | \n", "
113 | \n", "0.931438 | \n", "
... | \n", "... | \n", "
310 | \n", "0.930397 | \n", "
327 | \n", "0.932556 | \n", "
207 | \n", "0.929700 | \n", "
160 | \n", "0.929805 | \n", "
233 | \n", "0.931270 | \n", "
200 rows × 1 columns
\n", "