2022-11-29_CAD_shifts.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4e607479",
   "metadata": {},
   "source": [
    "#  Cell assembly detection (CAD)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1c0163f5-b685-412d-b5c6-8ff1670e9998",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import quantities as pq\n",
    "import neo\n",
    "import elephant\n",
    "import viziphant\n",
    "from elephant.conversion import BinnedSpikeTrain\n",
    "np.random.seed(4542)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5488bfdb",
   "metadata": {},
   "source": [
    "## introducing heterogeneous delays\n",
    "\n",
    "the function developed in the scan + a shift in time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "717a2fc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "A_sync = 0.05\n",
    "shift = 0.\n",
    "A = [0]+[1.-A_sync]+[0]*8+[A_sync]\n",
    "spiketrains = elephant.spike_train_generation.compound_poisson_process(\n",
    "                             rate=5*pq.Hz, A=A, shift=shift*pq.ms, t_stop=10*pq.s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9904a68e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(15, 7))\n",
    "plt.eventplot([spiketrains[i].magnitude for i in range(len(spiketrains))], linelengths=0.75, color='black')\n",
    "plt.xlabel('Time (ms)', fontsize=16)\n",
    "plt.ylabel('Neuron')\n",
    "plt.title(\"Raster plot\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f2ba2b89",
   "metadata": {},
   "outputs": [],
   "source": [
    "bst = BinnedSpikeTrain(spiketrains, bin_size=1 * pq.ms)                             "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "37a20b77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BinnedSpikeTrain(t_start=0.0 s, t_stop=10.0 s, bin_size=0.001 s; shape=(10, 10000), format=csr_matrix)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b2e6a0de",
   "metadata": {},
   "outputs": [],
   "source": [
    "bst.rescale('ms')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "37a20b77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BinnedSpikeTrain(t_start=0.0 ms, t_stop=10000.0 ms, bin_size=1.0 ms; shape=(10, 10000), format=csr_matrix)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "dd9b1d45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;31mSignature:\u001b[0m\n",
      "\u001b[0mcell_assembly_detection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0mbinned_spiketrain\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0mmax_lag\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0mreference_lag\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.05\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0mmin_occurrences\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0msize_chunks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0mmax_spikes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minf\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0msignificance_pruning\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0msubgroup_pruning\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0msame_configuration_pruning\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0mbool_times_format\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m    \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
      "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mDocstring:\u001b[0m\n",
      "Perform the CAD analysis :cite:`cad-Russo2017_e19428` for the binned\n",
      "(discretized) spike trains given in the input. The method looks for\n",
      "candidate significant patterns with lags (number of bins between successive\n",
      "spikes in the pattern) ranging from `-max_lag` to `max_lag` (the second\n",
      "parameter of the function). Thus, between two successive spikes in the\n",
      "pattern there can be at most `max_lag`*`bin_size` units of time.\n",
      "\n",
      "The method agglomerates pairs of units (or a unit and a preexisting\n",
      "assembly), tests their significance by a statistical test\n",
      "and stops when the detected assemblies reach their maximal dimension\n",
      "(parameter `max_spikes`).\n",
      "\n",
      "At every agglomeration size step (e.g. from triplets to quadruplets), the\n",
      "method filters patterns having the same neurons involved, and keeps only\n",
      "the most significant one. This pruning is optional and the choice is\n",
      "identified by the parameter 'significance_pruning'.\n",
      "Assemblies already included in a bigger assembly are eliminated in a final\n",
      "pruning step. Also this pruning is optional, and the choice is identified\n",
      "by the parameter `subgroup_pruning`.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "binned_spiketrain : elephant.conversion.BinnedSpikeTrain\n",
      "    Binned spike trains containing data to be analyzed.\n",
      "max_lag : int\n",
      "    Maximal lag to be tested. For a binning dimension of bin_size the\n",
      "    method will test all pairs configurations with a time\n",
      "    shift between '-max_lag' and 'max_lag'.\n",
      "reference_lag : int, optional\n",
      "    Reference lag (in bins) for the non-stationarity correction in the\n",
      "    statistical test.\n",
      "    Default: 2\n",
      "alpha : float, optional\n",
      "    Significance level for the statistical test.\n",
      "    Default: 0.05\n",
      "min_occurrences : int, optional\n",
      "    Minimal number of occurrences required for an assembly\n",
      "    (all assemblies, even if significant, with fewer occurrences\n",
      "    than min_occurrences are discarded).\n",
      "    Default: 0\n",
      "size_chunks : int, optional\n",
      "    Size (in bins) of chunks in which the spike trains are divided\n",
      "    to compute the variance (to reduce non stationarity effects\n",
      "    on variance estimation).\n",
      "    Default: 100\n",
      "max_spikes : int, optional\n",
      "    Maximal assembly order (the algorithm will return assemblies\n",
      "    composed of maximum `max_spikes` elements).\n",
      "    Default: `np.inf`\n",
      "significance_pruning : bool, optional\n",
      "    If True, the method performs significance pruning among\n",
      "    the detected assemblies.\n",
      "    Default: True\n",
      "subgroup_pruning : bool, optional\n",
      "    If True, the method performs subgroup pruning among\n",
      "    the detected assemblies.\n",
      "    Default: True\n",
      "same_configuration_pruning : bool, optional\n",
      "    If True, performs pruning (not present in the original code and more\n",
      "    efficient), not testing assemblies already formed\n",
      "    if they appear in the very same configuration.\n",
      "    Default: False\n",
      "bool_times_format : bool, optional\n",
      "    .. deprecated:: 0.10.0\n",
      "    Has no effect, the returning 'times' are always a quantity array\n",
      "    specifying the pattern spike times.\n",
      "    Default: None\n",
      "verbose : bool, optional\n",
      "    Regulates the number of prints given by the method. If true all prints\n",
      "    are given, otherwise the method does give any prints.\n",
      "    Default: False\n",
      "\n",
      "Returns\n",
      "-------\n",
      "assembly : list of dict\n",
      "    Contains the assemblies detected for the bin size chosen. Each\n",
      "    assembly is a dictionary with attributes:\n",
      "\n",
      "    'neurons' : list\n",
      "        Vector of units taking part to the assembly (unit order correspond\n",
      "        to the agglomeration order).\n",
      "    'lag' : pq.Quantity\n",
      "        Vector of time lags.\n",
      "        `lag[z]` is the activation delay between `neurons[1]` and\n",
      "        `neurons[z+1]`.\n",
      "    'pvalue' : list\n",
      "        Vector containing p-values.\n",
      "        `pvalue[z]` is the p-value of the statistical test between\n",
      "        performed adding `neurons[z+1]` to the `neurons[1:z]`.\n",
      "    'times' : pq.Quantity\n",
      "        Assembly activation times in the units of `binned_spiketrain`.\n",
      "    'signature' : np.ndarray\n",
      "        Array of two entries `(z,c)`. The first is the number of neurons\n",
      "        participating in the assembly (size), and the second is number of\n",
      "        assembly occurrences.\n",
      "\n",
      "Raises\n",
      "------\n",
      "TypeError\n",
      "    If `binned_spiketrain` is not an instance of\n",
      "    `elephant.conversion.BinnedSpikeTrain`.\n",
      "ValueError\n",
      "    If the parameters are out of bounds.\n",
      "\n",
      "Notes\n",
      "-----\n",
      "Alias: cad\n",
      "\u001b[0;31mFile:\u001b[0m      ~/opt/anaconda3/envs/brainhack/lib/python3.9/site-packages/elephant/cell_assembly_detection.py\n",
      "\u001b[0;31mType:\u001b[0m      function\n"
     ]
    }
   ],
   "source": [
    "from elephant.cell_assembly_detection import cell_assembly_detection\n",
    "cell_assembly_detection?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcf629ff",
   "metadata": {},
   "source": [
    "All in one function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "79922ad6",
   "metadata": {},
   "outputs": [],
   "source": [
    "t_stop = 10*pq.s\n",
    "def generate_and_test(A_sync=A_sync, shift=shift, winlen=1, slope=0., t_stop=t_stop):\n",
    "\n",
    "    A = [0]+[1.-A_sync]+[0]*8+[A_sync]\n",
    "    spiketrains = elephant.spike_train_generation.compound_poisson_process(\n",
    "                             rate=5*pq.Hz, A=A, shift=shift*pq.ms, t_stop=t_stop)\n",
    "\n",
    "    for i_st in range(10):\n",
    "        delay = (i_st*slope)*pq.ms\n",
    "        spike_times = np.sort(np.mod(spiketrains[i_st].times + delay, t_stop))\n",
    "        spiketrains[i_st] = neo.SpikeTrain(spike_times, t_start=0*pq.s, t_stop=t_stop)\n",
    "\n",
    "    for i in range(90):\n",
    "        spiketrains.append(elephant.spike_train_generation.homogeneous_poisson_process(\n",
    "            rate=5*pq.Hz, t_stop=t_stop))\n",
    "\n",
    "    bst = BinnedSpikeTrain(spiketrains, bin_size=1 * pq.ms)   \n",
    "    bst.rescale('ms')                          \n",
    "\n",
    "    patterns = cell_assembly_detection(bst, max_lag=10)\n",
    "\n",
    "    return patterns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5488bfdb",
   "metadata": {},
   "source": [
    "\n",
    "* changing the synchrony probability to check when SPADE will begin to fail:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8bc9a171",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.001 []\n",
      "0.0027825594022071257 []\n",
      "0.007742636826811269 []\n",
      "0.021544346900318832 []\n",
      "0.05994842503189409 []\n",
      "0.1668100537200059 []\n",
      "0.46415888336127775 []\n",
      "1.2915496650148828 []\n",
      "3.593813663804626 []\n",
      "10.0 []\n"
     ]
    }
   ],
   "source": [
    "for slope_ in np.logspace(-3, 1, 10, base=10):\n",
    "    patterns = generate_and_test(slope=slope_)\n",
    "    print(slope_, 'max delay=', 10*slope, 'ms: ', patterns)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('brainhack')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "f76abcfae7407d101ef34ba86f468988314045e4e2c214982f718a8acd3606b2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}