{ "cells": [ { "cell_type": "code", "source": [ "# %load imports.py\n", "%load_ext autoreload\n", "%autoreload\n" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "The autoreload extension is already loaded. To reload it, use:\n", " %reload_ext autoreload\n" ] } ], "execution_count": 482, "metadata": {} }, { "cell_type": "code", "source": [ "import brian2 as br\n", "from brian2.units import *\n", "import numpy as np" ], "outputs": [], "execution_count": 483, "metadata": {} }, { "cell_type": "code", "source": [ "import warnings \n", "def set_parameters_from_dict(neurongroup, dictionary_of_parameters):\n", " for param_key, param_value in dictionary_of_parameters.items():\n", " try: \n", " neurongroup.__setattr__(param_key, param_value)\n", " except AttributeError as err:\n", " warnings.warn(\"{:s} has no paramater {:s}\".format(neurongroup.name, param_key))" ], "outputs": [], "execution_count": 484, "metadata": {} }, { "cell_type": "markdown", "source": [ "# Definition of the Neuron and Synapse Model" ], "metadata": {} }, { "cell_type": "code", "source": [ "import sys\n", "import os\n", "cwd = os.getcwd()\n", "sys.path.append('/home/drangmeister/projects/grid_cell_model_with_reciprocal_ie_connectivity/grid_cell_model')\n", "from default_params import defaultParameters as no\n", "\n", "y_dim = np.sqrt(3)/2.\n", "\n", "for key, value in no.items():\n", " try:\n", " exec(\"%s=%f\" % (key, value))\n", " except:\n", " warnings.warn('This is highly terrible and does not convert strings to variables')\n", "tau1_GABA = tau_GABA_A_fall\n", "tau2_GABA = tau_GABA_A_rise * tau_GABA_A_fall / \\\n", " (tau_GABA_A_rise + tau_GABA_A_fall)\n", "B_GABA = 1./((tau2_GABA/tau1_GABA)**(tau_GABA_A_rise/tau1_GABA) - \n", " (tau2_GABA/tau1_GABA)**(tau_GABA_A_rise/tau2_GABA))\n", "model_eqs = '''\n", " dvm/dt = 1/C*Im + (noise_sigma*xi/taum_mean**.5) : volt (unless refractory)\n", " Ispike = gL*deltaT*exp((vm-Vt)/deltaT) : amp\n", " Im = gL*(EL-vm) + g_ahp*(Eahp - vm) + Ispike + Isyn + Iext : amp\n", " Isyn = B_GABA*(gi1 - gi2)*(Esyn_i - vm) + ge*(Esyn_e - vm) + gNMDA*(Esyn_e - vm) : amp\n", " dge/dt = -ge/syn_tau_e : siemens\n", " dgNMDA/dt = -gNMDA/tau_NMDA_fall : siemens\n", " dgi1/dt = -gi1/syn_tau1 : siemens\n", " dgi2/dt = -gi2/syn_tau2 : siemens\n", " dg_ahp/dt = -g_ahp/tau_ahp : siemens\n", " Iext = Iext_const : amp\n", " EL : volt\n", " taum : second\n", " '''\n", "\n", "C = taum_e * gL_e * pF\n", "gL = gL_e * nS\n", "noise_sigma = noise_sigma * mV\n", "deltaT = deltaT_e * mV\n", "Vt = Vt_e * mV\n", "Esyn_i = E_GABA_A * mV\n", "Esyn_e = E_AMPA * mV\n", "Vclamp = Vclamp * mV\n", "syn_tau_e = tau_AMPA * ms\n", "tau_NMDA_fall = tau_NMDA_fall * ms\n", "syn_tau1 = tau1_GABA * ms\n", "syn_tau2 = tau2_GABA * ms\n", "B_GABA = B_GABA\n", "taum_mean = taum_e * ms\n", "tau_ahp = tau_AHP_e * ms\n", "Eahp = E_AHP_e * mV\n", "\n", "EL = EL_e * mV\n", "\n", "g_AHP_e = g_AHP_e_max * nS\n", "Vr_e = Vr_e * mV \n", "Iext_const = Iext_e_const * pA\n", "# model=eqs_e,\n", "model_threshold= 'vm > V_peak_e * mV'\n", "model_reset=\"vm=Vr_e; g_ahp=g_AHP_e\"\n", "# model_refractory= 0.0 * t_ref_e * msecond\n", "model_refractory= 2.0 * msecond\n", "\n", "print(t_ref_e)\n", "\n", "gi1_synapse_model = 'gi1_w: siemens'\n", "gi1_synapse = 'gi1+=gi1_w'\n", "# gi1_w = 0.2 * B_GABA * g_GABA_total * nS\n", "\n", "gi2_synapse_model = 'gi2_w: siemens'\n", "gi2_synapse = 'gi2+=gi2_w'\n", "pulse_strength = 0.2 * B_GABA * g_GABA_total * nS\n", "\n", "print(EL)\n" ], "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "WARNING /home/drangmeister/miniconda3/envs/micro_circuit_notebooks/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: This is highly terrible and does not convert strings to variables\n", " del sys.path[0]\n", " [py.warnings]\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "10.1\n", "-68.5 mV\n" ] } ], "execution_count": 485, "metadata": {} }, { "cell_type": "markdown", "source": [ "## Analysis Functions for the Spike Train" ], "metadata": {} }, { "cell_type": "code", "source": [ "def get_spike_train(delay, pulse_strength, record_state):\n", " neuron = br.NeuronGroup(N=1, \\\n", " name='single_neuron',\\\n", " model=model_eqs, \\\n", " threshold=model_threshold, \\\n", " reset=model_reset,\\\n", " refractory = model_refractory)\n", "\n", " neuron.vm = EL\n", " neuron.gi1 = 0.0\n", " neuron.gi2 = 0.0\n", " neuron.g_ahp = 0.0\n", "\n", " spike_recorder = br.SpikeMonitor(source=neuron)\n", " \n", " gi1_auto_synapse = br.Synapses(source=neuron, target=neuron, model=gi1_synapse_model, on_pre = gi1_synapse, delay = delay)\n", " gi1_auto_synapse.connect()\n", " gi1_auto_synapse.gi1_w = pulse_strength\n", " \n", " gi2_auto_synapse = br.Synapses(source=neuron, target=neuron, model=gi2_synapse_model, on_pre = gi2_synapse, delay = delay)\n", " gi2_auto_synapse.connect()\n", " gi2_auto_synapse.gi2_w = pulse_strength\n", " \n", " net = br.Network(neuron)\n", " net.add(gi1_auto_synapse)\n", " net.add(gi2_auto_synapse)\n", " net.add(spike_recorder)\n", " \n", " if record_state:\n", " state_recorder = br.StateMonitor(neuron,'vm',record=True)\n", " net.add(state_recorder)\n", " net.run(duration=duration, report='stdout')\n", " \n", " spike_train = spike_recorder.spike_trains()\n", " return spike_train, np.array([state_recorder.t,state_recorder.vm[0]])\n", " else:\n", " net.run(duration=duration)\n", "\n", " spike_train = spike_recorder.spike_trains()\n", " return spike_train\n" ], "outputs": [], "execution_count": 486, "metadata": {} }, { "cell_type": "code", "source": [ "def get_mean_period(spike_train):\n", " return (np.max(spike_train[0]) - np.min(spike_train[0])) / (spike_train[0].shape[0] - 1)" ], "outputs": [], "execution_count": 487, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "code", "source": [ "def get_mean_response(spike_trains_dict,t_isi):\n", " mean_response_dict = {}\n", "# t_isi = get_mean_period(spike_trains_dict[0.0 * ms])\n", " for delay, spike_train in spike_trains_dict.items():\n", " mean_response_dict[delay] = get_mean_period(spike_train) - t_isi\n", " return mean_response_dict" ], "outputs": [], "execution_count": 488, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "markdown", "source": [ "## Plotting Functions" ], "metadata": {} }, { "cell_type": "code", "source": [ "import matplotlib.pyplot as plt" ], "outputs": [], "execution_count": 489, "metadata": {} }, { "cell_type": "code", "source": [ "def plot_spiking(spike_trains_dict):\n", " fig = plt.figure()\n", " ax = fig.add_subplot(111)\n", " for key, times in spike_trains_dict.items():\n", " ax.plot(times[0]/ms, key*np.ones(times[0].shape), 'b.')\n", "# ax.plot(spike_train[0]/ms, np.ones(spike_train[0].shape), 'b|')\n", "\n", " ax.grid(axis='x')\n", "# ax.set_ylim(-0.1, 1.1)\n", " ax.set_xlabel(\"Time(ms)\");" ], "outputs": [], "execution_count": 490, "metadata": {} }, { "cell_type": "code", "source": [ "def plot_mean_period(mean_period_dict):\n", " fig = plt.figure()\n", " ax = fig.add_subplot(111)\n", " ax.plot(list(mean_period_dict.keys()), list(mean_period_dict.values()), 'b')\n", "\n", " ax.grid(axis='x')\n", " ax.set_xlabel(\"Delay (ms)\");" ], "outputs": [], "execution_count": 491, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "code", "source": [ "def plot_mean_response(mean_response_dict):\n", " fig = plt.figure()\n", " ax = fig.add_subplot(111)\n", " ax.plot(list(mean_response_dict.keys()), list(mean_response_dict.values()), 'b')\n", "\n", " ax.grid(axis='x')\n", " ax.set_xlabel(\"Delay (ms)\");" ], "outputs": [], "execution_count": 492, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "code", "source": [ "def plot_state(state):\n", " fig = plt.figure()\n", " ax = fig.add_subplot(111)\n", " plt.plot(state[0], state[1],'r')\n", " ax.grid(axis='x')\n", " ax.set_ylim(-0.1,0.0)\n", " ax.set_xlabel(\"Time(ms)\");" ], "outputs": [], "execution_count": 493, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "markdown", "source": [ "## Execution" ], "metadata": {} }, { "cell_type": "code", "source": [ "duration = 20*ms\n", "n_simulations = 10\n", "\n", "spikes_unperturbed, state_unperturbed = get_spike_train(0.0 * ms, 0.0, True)\n", "spikes_perturbed, state_perturbed = get_spike_train(0.0 * ms, pulse_strength, True)\n" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Starting simulation at t=0. s for a duration of 20. ms\n", "0.02 (100%) simulated in < 1s\n", "Starting simulation at t=0. s for a duration of 20. ms\n", "0.02 (100%) simulated in < 1s\n" ] } ], "execution_count": 500, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "code", "source": [ "plot_state(state_unperturbed)\n", "plot_state(state_perturbed)\n" ], "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": [ "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\n" ] }, "metadata": { "needs_background": "light" } }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": [ "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\n" ] }, "metadata": { "needs_background": "light" } } ], "execution_count": 501, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "code", "source": [ "t_isi = get_mean_period(spikes_unperturbed)\n", "print(t_isi)\n", "delay_list = np.linspace(0.0 * ms,t_isi,n_simulations)\n", "spike_trains_dict = {}\n", "\n", "for delay in delay_list:\n", " spike_train = get_spike_train(delay, pulse_strength, False)\n", " spike_trains_dict[delay/ms] = spike_train" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "4.53333333 ms\n" ] } ], "execution_count": 496, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "code", "source": [ "mean_response_dict = get_mean_response(spike_trains_dict, t_isi)\n", "plot_mean_response(mean_response_dict)" ], "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "WARNING /home/drangmeister/miniconda3/envs/micro_circuit_notebooks/lib/python3.7/site-packages/brian2/units/fundamentalunits.py:1386: RuntimeWarning: invalid value encountered in true_divide\n", " result = operation(self_arr, other_arr)\n", " [py.warnings]\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": [ "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\n" ] }, "metadata": { "needs_background": "light" } } ], "execution_count": 497, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "code", "source": [ "plot_spiking(spike_trains_dict)" ], "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": [ "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\n" ] }, "metadata": { "needs_background": "light" } } ], "execution_count": 498, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } }, { "cell_type": "code", "source": [ "# mean_period_dict = {}\n", "\n", "# for delay, spike_train in spike_trains_dict.items():\n", "# mean_period_dict[delay] = get_mean_period(spike_train)\n", "\n# plot_mean_period(mean_period_dict)" ], "outputs": [], "execution_count": 499, "metadata": { "collapsed": false, "outputHidden": false, "inputHidden": false } } ], "metadata": { "kernelspec": { "name": "micro_circuit_notebooks", "language": "python", "display_name": "micro_circuit_notebooks" }, "language_info": { "name": "python", "version": "3.7.5", "mimetype": "text/x-python", "codemirror_mode": { "name": "ipython", "version": 3 }, "pygments_lexer": "ipython3", "nbconvert_exporter": "python", "file_extension": ".py" }, "kernel_info": { "name": "micro_circuit_notebooks" }, "nteract": { "version": "0.12.3" } }, "nbformat": 4, "nbformat_minor": 2 }