{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: lazyarray in /opt/conda/lib/python3.5/site-packages (0.3.2)\n", "Requirement already satisfied: numpy>=1.8 in /opt/conda/lib/python3.5/site-packages (from lazyarray) (1.12.1)\n", "\u001b[31mcryptography 2.2.1 requires asn1crypto>=0.21.0, which is not installed.\u001b[0m\n", "\u001b[31mcffi 1.11.5 requires pycparser, which is not installed.\u001b[0m\n", "\u001b[31mallensdk 0.14.2 has requirement pandas<0.20.0,>=0.16.2, but you'll have pandas 0.23.1 which is incompatible.\u001b[0m\n", "\u001b[33mYou are using pip version 10.0.1, however version 18.1 is available.\n", "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/opt/conda/lib/python3.5/site-packages/pyNN/neuron/__init__.py:14: UserWarning: mpi4py not available\n", " warnings.warn(\"mpi4py not available\")\n" ] } ], "source": [ "from pyNN.neuron import *\n", "from pyNN.neuron import HH_cond_exp\n", "from pyNN.neuron import EIF_cond_exp_isfa_ista\n", "from pyNN.neuron import Izhikevich\n", "\n", "from pyNN import neuron\n", "#\n", "from pyNN.neuron import simulator as sim\n", "from pyNN.neuron import setup as setup\n", "\n", "from pyNN.neuron import DCSource\n", "from types import MethodType\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import io\n", "import math\n", "import pdb\n", "#from numba import jit\n", "from sciunit.utils import redirect_stdout\n", "import numpy as np\n", "#from .base import *\n", "import quantities as qt\n", "from quantities import mV, ms, s\n", "import matplotlib.pyplot as plt\n", "from pyNN.neuron import *\n", "from pyNN.neuron import HH_cond_exp\n", "from pyNN.neuron import EIF_cond_exp_isfa_ista\n", "from pyNN.neuron import Izhikevich\n", "from elephant.spike_train_generation import threshold_detection\n", "\n", "from pyNN import neuron\n", "#\n", "#from pyNN.neuron import simulator as sim\n", "from pyNN.neuron import setup as setup\n", "#from pyNN.neuron import Izhikevich\n", "#from pyNN.neuron import Population\n", "from pyNN.neuron import DCSource\n", "import numpy as np\n", "import copy\n", "from neo import AnalogSignal\n", "import neuronunit.capabilities.spike_functions as sf\n", "\n", "import neuronunit.capabilities as cap\n", "cap.ReceivesCurrent\n", "cap.ProducesActionPotentials\n", "def bind_NU_interface(model):\n", "\n", " def load_model(self):\n", " neuron = None\n", " from pyNN import neuron\n", " self.hhcell = neuron.create(EIF_cond_exp_isfa_ista())\n", " neuron.setup(timestep=self.dt, min_delay=1.0)\n", "\n", "\n", " def init_backend(self, attrs = None, cell_name= 'HH_cond_exp', current_src_name = 'hannah', DTC = None, dt=0.01):\n", " backend = 'HHpyNN'\n", " self.current_src_name = current_src_name\n", " self.cell_name = cell_name\n", " self.adexp = True\n", "\n", " self.DCSource = DCSource\n", " self.setup = setup\n", " self.model_path = None\n", " self.related_data = {}\n", " self.lookup = {}\n", " self.attrs = {}\n", " self.neuron = neuron\n", " self.model._backend = str('ExternalSim')\n", " self.backend = self\n", " self.model.attrs = {}\n", "\n", " #self.orig_lems_file_path = 'satisfying'\n", " #self.model._backend.use_memory_cache = False\n", " #self.model.unpicklable += ['h','ns','_backend']\n", " self.dt = dt\n", " if type(DTC) is not type(None):\n", " if type(DTC.attrs) is not type(None):\n", "\n", " self.set_attrs(**DTC.attrs)\n", " assert len(self.model.attrs.keys()) > 0\n", "\n", " if hasattr(DTC,'current_src_name'):\n", " self._current_src_name = DTC.current_src_name\n", "\n", " if hasattr(DTC,'cell_name'):\n", " self.cell_name = DTC.cell_name\n", " \n", " self.load_model()\n", "\n", " def get_membrane_potential(self):\n", " \"\"\"Must return a neo.core.AnalogSignal.\n", " And must destroy the hoc vectors that comprise it.\n", " \"\"\"\n", " #dt = float(copy.copy(self.neuron.dt))\n", " data = self.hhcell.get_data().segments[0]\n", " volts = data.filter(name=\"v\")[0]#/10.0\n", " #data_block = all_cells.get_data()\n", "\n", " vm = AnalogSignal(volts,\n", " units = mV,\n", " sampling_period = self.dt *ms)\n", " #results['vm'] = vm\n", " return vm#data.filter(name=\"v\")[0]\n", "\n", " def _local_run(self):\n", " '''\n", " pyNN lazy array demands a minimum population size of 3. Why is that.\n", " '''\n", " results = {}\n", " DURATION = 1000.0\n", " \n", " #ctx_cells.celltype.recordable\n", " \n", " \n", " if self.celltype == 'HH_cond_exp':\n", "\n", " self.hhcell.record('spikes','v')\n", "\n", " else:\n", " self.neuron.record_v(self.hhcell, \"Results/HH_cond_exp_%s.v\" % str(neuron))\n", "\n", " #self.neuron.record_gsyn(self.hhcell, \"Results/HH_cond_exp_%s.gsyn\" % str(neuron))\n", " self.neuron.run(DURATION)\n", " data = self.hhcell.get_data().segments[0]\n", " volts = data.filter(name=\"v\")[0]#/10.0\n", " #data_block = all_cells.get_data()\n", "\n", " vm = AnalogSignal(volts,\n", " units = mV,\n", " sampling_period = self.dt *ms)\n", " results['vm'] = vm\n", " results['t'] = vm.times # self.times\n", " results['run_number'] = results.get('run_number',0) + 1\n", " return results\n", "\n", "\n", "\n", "\n", " def set_attrs(self,**attrs):\n", " self.init_backend()\n", " self.model.attrs.update(attrs)\n", " assert type(self.model.attrs) is not type(None)\n", " self.hhcell[0].set_parameters(**attrs)\n", " return self\n", "\n", "\n", " def inject_square_current(self,current):\n", " attrs = copy.copy(self.model.attrs)\n", " self.init_backend()\n", " self.set_attrs(**attrs)\n", " c = copy.copy(current)\n", " if 'injected_square_current' in c.keys():\n", " c = current['injected_square_current']\n", "\n", " stop = float(c['delay'])+float(c['duration'])\n", " duration = float(c['duration'])\n", " start = float(c['delay'])\n", " amplitude = float(c['amplitude'])\n", " electrode = self.neuron.DCSource(start=start, stop=stop, amplitude=amplitude)\n", "\n", "\n", " electrode.inject_into(self.hhcell)\n", " self.results = self._local_run()\n", " self.vm = self.results['vm']\n", "\n", " def get_APs(self,vm):\n", " vm = self.get_membrane_potential()\n", " waveforms = sf.get_spike_waveforms(vm,threshold=-45.0*mV)\n", " return waveforms\n", "\n", " def get_spike_train(self,**run_params):\n", " vm = self.get_membrane_potential()\n", "\n", " spike_train = threshold_detection(vm,threshold=-45.0*mV)\n", "\n", " return spike_train\n", " \n", " def get_spike_count(self,**run_params):\n", " vm = self.get_membrane_potential()\n", " return len(threshold_detection(vm,threshold=-45.0*mV))\n", " \n", " model.init_backend = MethodType(init_backend,model)\n", " model.get_spike_count = MethodType(get_spike_count,model)\n", " model.get_APs = MethodType(get_APs,model)\n", " model.get_spike_train = MethodType(get_spike_train,model)\n", " model.set_attrs = MethodType(set_attrs, model) # Bind to the score.\n", " model.inject_square_current = MethodType(inject_square_current, model) # Bind to the score.\n", " model.set_attrs = MethodType(set_attrs, model) # Bind to the score.\n", " model.get_membrane_potential = MethodType(get_membrane_potential,model)\n", " model.load_model = MethodType(load_model, model) # Bind to the score.\n", " model._local_run = MethodType(_local_run,model)\n", " model.init_backend(model)\n", " #model.load_model() #= MethodType(load_model, model) # Bind to the score.\n", "\n", " return model\n", "HH_cond_exp = bind_NU_interface(HH_cond_exp) \n", "#HH_cond_exp" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [], "source": [ "electro_tests = []\n", "obs_frame = {}\n", "test_frame = {}\n", "import os\n", "import pickle\n", "try: \n", "\n", " electro_path = str(os.getcwd())+'all_tests.p'\n", "\n", " assert os.path.isfile(electro_path) == True\n", " with open(electro_path,'rb') as f:\n", " (obs_frame,test_frame) = pickle.load(f)\n", "\n", "except:\n", " for p in pipe:\n", " p_tests, p_observations = get_neab.get_neuron_criteria(p)\n", " obs_frame[p[\"name\"]] = p_observations#, p_tests))\n", " test_frame[p[\"name\"]] = p_tests#, p_tests))\n", " electro_path = str(os.getcwd())+'all_tests.p'\n", " with open(electro_path,'wb') as f:\n", " pickle.dump((obs_frame,test_frame),f)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": true }, "outputs": [ { "ename": "NameError", "evalue": "name 'test_frame' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0muse_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtest_frame\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"Neocortex pyramidal cell layer 5-6\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0muse_test\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobservation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m#from neuronunit.tests import RheobaseP\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mneuronunit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtests\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfi\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mRheobaseTest\u001b[0m\u001b[0;31m# as discovery\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mNameError\u001b[0m: name 'test_frame' is not defined" ] } ], "source": [ "use_test = test_frame[\"Neocortex pyramidal cell layer 5-6\"]\n", "use_test[0].observation\n", "#from neuronunit.tests import RheobaseP\n", "from neuronunit.tests.fi import RheobaseTest# as discovery\n", "\n", "rtp = RheobaseTest(use_test[0].observation)\n", "use_test[0] = rtp\n", "\n", "\n", "HH_cond_exp.attrs = HH_cond_exp.simple_parameters(HH_cond_exp)\n", "#print(HH_cond_exp.attrs)\n", "HH_cond_exp.scaled_parameters(HH_cond_exp)\n", "dir(HH_cond_exp)\n", "HH_cond_exp.default_initial_values\n", "HH_cond_exp.attrs\n", "NGEN = 10\n", "MU = 10\n", "from neuronunit.optimization import optimization_management as om\n", "explore_ranges = {'e_rev_Na' : (40,70), 'e_rev_K': (-90.0,-75.0), 'cm' : (0.25,1.5)}\n", "npcl, DO = om.run_ga(explore_ranges,NGEN,use_test,free_params=explore_ranges.keys(), NSGA = True, MU = MU,model_type=None)\n", "\n", "#hc = " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "#dir(HH_cond_exp)\n", "#HH_cond_exp.get_parameters()\n", "#hhcell[0].get_parameters()\n", "#dir(HH_cond_exp)\n", "HH_cond_exp.attrs = HH_cond_exp.simple_parameters(HH_cond_exp)\n", "HH_cond_exp.celltype = HH_cond_exp\n", "iparams = {}\n", "iparams['injected_square_current'] = {}\n", "#iparams['injected_square_current']['amplitude'] = 1.98156805*pq.pA\n", "iparams['injected_square_current']['amplitude'] = 0.68156805*pq.pA\n", "\n", "DELAY = 100.0*pq.ms\n", "DURATION = 1000.0*pq.ms\n", "iparams['injected_square_current']['delay'] = DELAY\n", "iparams['injected_square_current']['duration'] = int(DURATION)\n", "\n", "HH_cond_exp.inject_square_current(iparams)\n", "print(HH_cond_exp.get_spike_count())\n", "\n", "print(HH_cond_exp.vm)\n", "\n", "import matplotlib.pyplot as plt\n", "plt.plot(HH_cond_exp.vm.times,HH_cond_exp.vm)\n", "\n", "\n", "plt.show()\n", "iparams['injected_square_current']['amplitude'] = 0.8598156805*pq.pA\n", "#iparams['injected_square_current']['amplitude'] = 2000.98156805*pq.pA\n", "\n", "DELAY = 100.0*pq.ms\n", "DURATION = 1000.0*pq.ms\n", "iparams['injected_square_current']['delay'] = DELAY\n", "iparams['injected_square_current']['duration'] = int(DURATION)\n", "\n", "HH_cond_exp.inject_square_current(iparams)\n", "print(HH_cond_exp.get_spike_count())\n", "import matplotlib.pyplot as plt\n", "plt.plot(HH_cond_exp.vm.times,HH_cond_exp.vm)\n", "\n", "plt.show()\n", "pred = use_test[0].generate_prediction(HH_cond_exp)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "#dir(HH_cond_exp)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "print(pred)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "iparams['injected_square_current']['amplitude'] = pred['value']\n", "#iparams['injected_square_current']['amplitude'] = 2000.98156805*pq.pA\n", "\n", "DELAY = 100.0*pq.ms\n", "DURATION = 1000.0*pq.ms\n", "iparams['injected_square_current']['delay'] = DELAY\n", "iparams['injected_square_current']['duration'] = int(DURATION)\n", "\n", "HH_cond_exp.inject_square_current(iparams)\n", "print(HH_cond_exp.get_spike_count())\n", "import matplotlib.pyplot as plt\n", "plt.plot(HH_cond_exp.vm.times,HH_cond_exp.vm)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "\n", "import pyNN\n", "from pyNN import neuron\n", "from pyNN.neuron import EIF_cond_exp_isfa_ista\n", "#neurons = pyNN.Population(N_CX, pyNN.EIF_cond_exp_isfa_ista, RS_parameters)\n", "\n", "cell = neuron.create(EIF_cond_exp_isfa_ista())\n", "#cell[0].set_parameters(**LTS_parameters)\n", "cell[0].get_parameters()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "\n", "\n", "explore_ranges = {'E_Na' : (40,70), 'E_K': (-90.0,-75.0), 'C_m' : (0.25,1.5), 'g_K':(30,40), 'g_Na':(100,140), 'g_L':(0.1,0.5), 'E_L':(-60.0,-45)}\n", "\n", "attrs = { 'g_K' : 36.0, 'g_Na' : 120.0, 'g_L' : 0.3, \\\n", " 'C_m' : 1.0, 'E_L' : -54.387, 'E_K' : -77.0, 'E_Na' : 50.0, 'vr':-65.0 } \n", "\n", " \n", "from neuronunit.optimization import optimization_management as om\n", "print(test_frame) \n", "MU = 12\n", "NGEN = 25\n", "cnt = 1\n", "#hc = { 'g_L' : 0.3, 'E_L' : -54.387,\n", "hc = {'vr':-65.0 } \n", "\n", "#npcl, DO = om.run_g\n", "npcl, DO = om.run_ga(explore_ranges,NGEN,use_test,free_params=explore_ranges.keys(), hc = hc, NSGA = True, MU = MU,model_type='HH')\n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "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.5.2" } }, "nbformat": 4, "nbformat_minor": 2 }