SpiNNaker/eg_1D_diverging-network.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1D diverging network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fileName\n",
    "\n",
    "fileName = 'eg_1D_diverging-network' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# libs\n",
    "\n",
    "import pyNN.spiNNaker as sim\n",
    "from pyNN import space \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simulation settings\n",
    "\n",
    "sim.setup(\n",
    "        timestep=1, # [ms]\n",
    "        min_delay=1, # [ms]\n",
    "        max_delay=100) # [ms]\n",
    "\n",
    "simtime = 250 #ms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining the network\n",
    "\n",
    "pops = {}\n",
    "n_cells = {}\n",
    "neuron_Model = {}\n",
    "neuron_ModelPars = {}\n",
    "initial_Values = {}\n",
    "\n",
    "for popName in ['Exc']:\n",
    "    n_cells[popName] = 100\n",
    "    neuron_Model[popName] = sim.IF_cond_exp\n",
    "    neuron_ModelPars[popName] = sim.IF_cond_exp.default_parameters # or standard_pars or testing_pars\n",
    "    initial_Values[popName] = sim.IF_cond_exp.default_initial_values\n",
    "    pops[popName] = sim.Population(n_cells[popName], \n",
    "                                   neuron_Model[popName],\n",
    "                                   neuron_ModelPars[popName],\n",
    "                                   structure = space.Line(dx=1.0, x0=0.0, y=0.0, z=0.0),\n",
    "                                   label = popName)\n",
    "                                   # add spatial constraint\n",
    "\n",
    "    pops[popName].record(['spikes','v','gsyn_exc','gsyn_inh'])   \n",
    " \n",
    "pops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining the list of connections\n",
    "\n",
    "def compute_manual_list(n_cells_i, n_cells_j, weights, d_thresh, p_thresh, width): \n",
    "        v_c = 0.35 #m/s\n",
    "        d0 = 1 #ms\n",
    "        scale = 1\n",
    "\n",
    "        connections = {}\n",
    "        probabilities = {}\n",
    "        distances = {}\n",
    "\n",
    "        connections = []\n",
    "        probabilities = []\n",
    "        distances = []\n",
    "        for pre in range(n_cells_i):\n",
    "            for post in range(n_cells_j):\n",
    "                d_ij = np.sqrt((pre - post)**2)\n",
    "                delay = d0 + d_ij / v_c\n",
    "                if d_ij > d_thresh: \n",
    "                    distances.append(d_ij)\n",
    "                    p_ij = scale*np.exp(-0.5 * (d_ij**2/width**2))\n",
    "                    probabilities.append(p_ij)\n",
    "\n",
    "                    if p_ij > p_thresh:\n",
    "                        connections.append([pre, post, weights, delay])#, [d_ij, p_ij]])\n",
    "\n",
    "        return connections, distances, probabilities\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute manual list of connections \n",
    "\n",
    "weight = {('Exc', 'Exc') : 0.08}\n",
    "          \n",
    "d_thresh = {('Exc', 'Exc'): 0}\n",
    "\n",
    "p_thresh = {('Exc', 'Exc'): 0.2}\n",
    "\n",
    "width = {('Exc', 'Exc'): 1}\n",
    "\n",
    "\n",
    "\n",
    "connections = {}\n",
    "distances = {}\n",
    "probabilities = {}\n",
    "\n",
    "connections['Exc', 'Exc'], distances['Exc', 'Exc'], probabilities['Exc', 'Exc'] = compute_manual_list(n_cells['Exc'], \n",
    "                                                                                                      n_cells['Exc'], \n",
    "                                                                                                      weight['Exc', 'Exc'], \n",
    "                                                                                                      d_thresh['Exc', 'Exc'], \n",
    "                                                                                                      p_thresh['Exc', 'Exc'], \n",
    "                                                                                                      width['Exc', 'Exc'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# visual check of the connections\n",
    "\n",
    "fig, ax = plt.subplots(1,2, figsize=(9,5))\n",
    "fig.tight_layout(pad=3)\n",
    "axes_list = fig.axes\n",
    "\n",
    "axes_list[0].plot(np.asarray(connections['Exc', 'Exc']).T[0], np.asarray(connections['Exc', 'Exc']).T[1],'go', label='Exc (i) - Exc (j)')\n",
    "axes_list[0].grid()\n",
    "axes_list[0].legend()\n",
    "axes_list[0].set_title('scatter plot of connections')\n",
    "axes_list[0].set_xlabel('i cells')\n",
    "axes_list[0].set_ylabel('j cells')\n",
    "axes_list[0].set_xlim(20,40)\n",
    "axes_list[0].set_ylim(20,40)\n",
    "\n",
    "axes_list[1].plot(distances['Exc', 'Exc'],probabilities['Exc', 'Exc'],'g+')\n",
    "axes_list[1].plot(np.arange(0, 50), 1*np.exp(-0.5 * (np.arange(0, 50)**2/width['Exc', 'Exc']**2)), 'g:')\n",
    "axes_list[1].grid()\n",
    "axes_list[1].set_xlim(0,15)\n",
    "axes_list[1].set_ylim(0,1)\n",
    "axes_list[1].axhline(p_thresh['Exc', 'Exc'], color='k', label='p_threshold', )\n",
    "axes_list[1].set_title('connections as function of prob and dist')\n",
    "axes_list[1].set_xlabel('distance')\n",
    "axes_list[1].set_ylabel('probability')\n",
    "axes_list[1].legend()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make the projections\n",
    "\n",
    "proj = {}\n",
    "\n",
    "\n",
    "\n",
    "proj['Exc', 'Exc'] = sim.Projection(pops['Exc'], \n",
    "                                    pops['Exc'],\n",
    "                                    connector = sim.FromListConnector(connections['Exc', 'Exc']),\n",
    "                                    receptor_type = 'excitatory',\n",
    "                                    space = space.Space(axes = 'x'),\n",
    "                                    label = 'exc-exc connections'\n",
    "                                    )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make the thalamic input sources\n",
    "\n",
    "popName = 'Thalamus'  \n",
    "\n",
    "n_cells[popName] = n_cells['Exc']\n",
    "spike_times = [[]]*n_cells[popName] #list of spike lists, where one spike list is related to one spike source\n",
    "#random_sources_idx = [np.random.randint(n_cells[popName]*0.40, n_cells[popName]*0.60) for i in range(n_cells[popName])]\n",
    "random_sources_idx = np.arange(int(n_cells[popName]*0.40), int(n_cells[popName]*0.60))\n",
    "\n",
    "for idx, sources in enumerate(random_sources_idx):\n",
    "    spike_times[sources] = np.sort([abs(np.random.normal(loc=100, scale=25)) for n in range(5)])\n",
    "\n",
    "\n",
    "neuron_Model[popName] = sim.SpikeSourceArray(spike_times)\n",
    "\n",
    "\n",
    "pops[popName] = sim.Population(n_cells[popName], \n",
    "                           neuron_Model[popName],\n",
    "                           label = popName)\n",
    "\n",
    "proj['Thalamus', 'Exc'] = sim.Projection(pops['Thalamus'], \n",
    "                                         pops['Exc'],\n",
    "                                         connector = sim.OneToOneConnector(),\n",
    "                                         synapse_type = sim.StaticSynapse(weight=0.08, delay=1),\n",
    "                                         receptor_type = 'excitatory',\n",
    "                                         label = 'thalamus-exc connections')\n",
    "\n",
    "fig, axes = plt.subplots(1,1)\n",
    "axes_list = fig.axes\n",
    "axes_list[0].eventplot(spike_times)\n",
    "axes_list[0].set_xlabel('[ms]')\n",
    "axes_list[0].set_ylabel('thalamic spike sources')\n",
    "axes_list[0].set_title('rasterplot of spike sources')\n",
    "axes_list[0].set_xlim(0, simtime)\n",
    "\n",
    "random_sources_idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run simulation\n",
    "\n",
    "sim.run(simtime) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save the results\n",
    "outputs = {}\n",
    "\n",
    "for layer in ['Exc']:\n",
    "    outputs[layer] = pops[layer].get_data()\n",
    "    for recording in ['v', 'gsyn_inh', 'gsyn_exc', 'spikes']:\n",
    "        pops[layer].write_data(fileName + '_' + str(layer) + '_' + str(recording) + '.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check results\n",
    "\n",
    "def recover_results(outputs):\n",
    "    results = {}\n",
    "    for key in outputs.keys(): # to extract the name of the layer, e.g., Exc, Inh, Thalamus, etc  \n",
    "        \n",
    "        # to get voltage and conductances\n",
    "        for analogsignal in outputs[key].segments[0].analogsignals:\n",
    "            print(analogsignal.name)\n",
    "            results[key, analogsignal.name] = analogsignal\n",
    "\n",
    "        # to get spikes\n",
    "        results[key, 'spikes'] = outputs[key].segments[0].spiketrains\n",
    "    return results\n",
    "\n",
    "results = recover_results(outputs)\n",
    "results.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check the spikes\n",
    "\n",
    "fig, axes = plt.subplots(1, 1)\n",
    "fig.tight_layout(pad=5)\n",
    "axes_list = fig.axes\n",
    "\n",
    "for idx, value in enumerate(['Exc']):\n",
    "    axes_list[idx].eventplot(results[value, 'spikes'])\n",
    "    axes_list[idx].eventplot(spike_times, color='r')\n",
    "    axes_list[idx].set_title('rasterplot of ' + str(value) + ' layer')\n",
    "    axes_list[idx].set_xlabel('[ms]')\n",
    "    axes_list[idx].set_ylabel('cells')\n",
    "    axes_list[idx].set_xlim(0, simtime)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check the voltage\n",
    "\n",
    "fig, axes = plt.subplots(1, 1)#, figsize=(9,5))\n",
    "fig.tight_layout(pad=4)\n",
    "\n",
    "axes_list = fig.axes\n",
    "\n",
    "for idx, value in enumerate(['Exc']):\n",
    "    im = axes_list[idx].imshow(results[value, 'v'].T)\n",
    "    axes_list[idx].set_title('voltage of ' + str(value) + ' layer')\n",
    "    axes_list[idx].set_xlabel('time [ms]')\n",
    "    axes_list[idx].set_ylabel('cells')\n",
    "    fig.colorbar(im, ax=axes_list[idx], fraction=0.010, label='[mV]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check the conductances\n",
    "\n",
    "# check the voltage\n",
    "\n",
    "fig, axes = plt.subplots(2, 1)#, figsize=(9,5))\n",
    "fig.tight_layout(pad=4)\n",
    "\n",
    "axes_list = fig.axes\n",
    "\n",
    "for idx, value in enumerate(['Exc']):\n",
    "    for idx, gsyn in enumerate(['gsyn_exc', 'gsyn_inh']):\n",
    "        im = axes_list[idx].imshow(results['Exc', gsyn].T)\n",
    "        axes_list[idx].set_title(str(gsyn))\n",
    "        axes_list[idx].set_xlabel('time [ms]')\n",
    "        axes_list[idx].set_ylabel('cells')\n",
    "        fig.colorbar(im, ax=axes_list[idx], fraction=0.010, label='[uS]')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# end simulation\n",
    "\n",
    "sim.end()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# task 1: on the stimulus\n",
    "\n",
    "- go to the notebook cell '# make the thalamic input sources' and design and test a new type of thalamic input (e.g., more/sparser input cells, etc)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}