def bind_score_to_dtc(dtc):
#import evaluate_as_module
from neuronunit.optimization import evaluate_as_module
#from neuronunit.models import backends
from neuronunit.models.reduced import ReducedModel
import quantities as pq
import numpy as np
from neuronunit.optimization import get_neab
model = ReducedModel(get_neab.LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURONMemory')
model.set_attrs(dtc.attrs)
get_neab.tests[0].prediction = dtc.rheobase
model.rheobase = dtc.rheobase['value']
if dtc.rheobase['value'] <= 0.0:
return dtc
for k, t in enumerate(get_neab.tests):
if k > 0:
t.params = dtc.vtest[k]
score = t.judge(model, stop_on_error=False, deep_error=False)
#import pdb; pdb.set_trace()
dtc.scores[str(t)] = score.sort_key
try:
observation = score.observation
prediction = score.prediction
delta = evaluate_as_module.difference(observation, prediction)
dtc.differences[str(t)] = delta
except:
pass
return dtc
def nunit_evaluation(tuple_object):
# Inputs single data transport container modules, and neuroelectro observations that
# inform test error error_criterion
# Outputs Neuron Unit evaluation scores over error criterion
dtc, tests = tuple_object
dtc = copy.copy(dtc)
dtc.model_path = path_params['model_path']
LEMS_MODEL_PATH = path_params['model_path']
assert dtc.rheobase is not None
tests = [t for t in tests if str('RheobaseTestP') not in str(t)]
#for t in tests:
# dtc.scores[str(t)] = 1.0
for k, t in enumerate(tests):
t.params = dtc.vtest[k]
score = None
model = None
model = ReducedModel(LEMS_MODEL_PATH,
name=str('vanilla'),
backend=('NEURON', {
'DTC': dtc
}))
model.set_attrs(dtc.attrs)
score = t.judge(model, stop_on_error=False, deep_error=False)
if type(score.sort_key) is not type(None):
dtc.scores[str(t)] = 1 - score.sort_key
dtc = score_proc(dtc, t, copy.copy(score))
else:
dtc.scores[str(t)] = 1.0
dtc.get_ss()
return dtc
'''
def test_rheobase_single_value_parallel_and_serial_comparison(self):
from neuronunit.tests.fi import RheobaseTest, RheobaseTestP
from neuronunit.optimization import get_neab
from neuronunit.models.reduced import ReducedModel
from neuronunit import aibs
import os
dataset_id = 354190013 # Internal ID that AIBS uses for a particular Scnn1a-Tg2-Cre
# Primary visual area, layer 5 neuron.
observation = aibs.get_observation(dataset_id, 'rheobase')
rt = RheobaseTest(observation=observation)
rtp = RheobaseTestP(observation=observation)
model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend=('NEURON'))
#model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON')
self.score_p = rtp.judge(model, stop_on_error=False, deep_error=True)
self.predictionp = self.score_p.prediction
self.score_p = self.score_p.norm_score
#model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON')
serial_model = ReducedModel(get_neab.LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURON')
self.score_s = rt.judge(serial_model,
stop_on_error=False,
deep_error=True)
self.predictions = self.score_s.prediction
self.score_s = self.score_s.norm_score
import numpy as np
check_less_thresh = float(
np.abs(self.predictionp['value'] - self.predictions['value']))
self.assertLessEqual(check_less_thresh, 2.0)
def nunit_evaluation(dtc,error_criterion):
# Inputs single data transport container modules, and neuroelectro observations that
# inform test error error_criterion
# Outputs Neuron Unit evaluation scores over error criterion
dtc.model_path = path_params['model_path']
LEMS_MODEL_PATH = path_params['model_path']
assert dtc.rheobase is not None
from neuronunit.models.reduced import ReducedModel
#from neuronunit.optimization import get_neab
tests = error_criterion
model = ReducedModel(LEMS_MODEL_PATH,name=str('vanilla'),backend=('NEURON',{'DTC':dtc}))
model.set_attrs(dtc.attrs)
tests[0].prediction = dtc.rheobase
model.rheobase = dtc.rheobase['value']
from dask import dataframe as dd
if dtc.score is None:
dtc.score = {}
for k,t in enumerate(tests[1:-1]):
t.params = dtc.vtest[k]
print(t.params)
score = None
score = t.judge(model,stop_on_error = False, deep_error = False)
if score.sort_key is not None:
# dtc.scores.get(str(t), score.sort_key)
# dtc.score.get(str(t), score.sort_key-1)
dtc.scores[str(t)] = 1.0 - score.sort_key
print(str(t),score.sort_key)
if not hasattr(dtc,'score'):
dtc.score = {}
dtc.score[str(t)] = score.sort_key
else:
pass
return dtc
def dtc_to_rheo(dtc):
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
from neuronunit.optimization import evaluate_as_module
model = ReducedModel(get_neab.LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURON')
model.set_attrs(dtc.attrs)
#dtc.cell_name = model._backend.cell_name
#dtc.current_src_name = model._backend.current_src_name
dtc.scores = None
dtc.scores = {}
dtc.differences = None
dtc.differences = {}
score = get_neab.tests[0].judge(model,
stop_on_error=False,
deep_error=True)
observation = score.observation
prediction = score.prediction
delta = evaluate_as_module.difference(observation, prediction)
dtc.differences[str(get_neab.tests[0])] = delta
dtc.scores[str(get_neab.tests[0])] = score.sort_key
dtc.rheobase = score.prediction
return dtc
def nunit_evaluation(tuple_object): #,backend=None):
# Inputs single data transport container modules, and neuroelectro observations that
# inform test error error_criterion
# Outputs Neuron Unit evaluation scores over error criterion
dtc, tests = tuple_object
dtc = copy.copy(dtc)
dtc.model_path = path_params['model_path']
LEMS_MODEL_PATH = path_params['model_path']
assert dtc.rheobase is not None
backend = dtc.backend
if backend == 'glif':
model = glif.GC(
) #ReducedModel(LEMS_MODEL_PATH,name=str('vanilla'),backend=('NEURON',{'DTC':dtc}))
tests[0].prediction = dtc.rheobase
model.rheobase = dtc.rheobase['value']
else:
model = ReducedModel(LEMS_MODEL_PATH,
name=str('vanilla'),
backend=('NEURON', {
'DTC': dtc
}))
model.set_attrs(dtc.attrs)
tests[0].prediction = dtc.rheobase
model.rheobase = dtc.rheobase['value']
for k, t in enumerate(tests[1:-1]):
t.params = dtc.vtest[k]
score = None
score = t.judge(model, stop_on_error=False, deep_error=False)
dtc.score[str(t)] = {}
dtc.score[str(t)]['value'] = copy.copy(score.sort_key)
if hasattr(score, 'prediction'):
if type(score.prediction) is not type(None):
dtc.score[str(t)][str('prediction')] = score.prediction
dtc.score[str(t)][str('observation')] = score.observation
if 'mean' in score.observation.keys(
) and 'mean' in score.prediction.keys():
print(score.observation.keys())
dtc.score[str(t)][str('agreement')] = np.abs(
score.observation['mean'] - score.prediction['mean'])
else:
print(score, type(score))
if score.sort_key is not None:
##
# This probably does something different to what I thought.
##
#dtc.scores.get(str(t), 1.0 - score.sort_key)
dtc.scores[str(t)] = 1.0 - score.sort_key
else:
dtc.scores[str(t)] = 1.0
return dtc
def setUp(self):
self.predictions = None
self.predictionp = None
self.score_p = None
self.score_s = None
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
print(get_neab.LEMS_MODEL_PATH)
#def create_model():
# cannot be pickled.
self.model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='NEURON')
self.model = None
def test_frp(self):
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend=('NEURON'))
attrs = {'a':0.02, 'b':0.2, 'c':-65+15*0.5, 'd':8-0.5**2 }
from neuronunit.optimization.data_transport_container import DataTC
dtc = DataTC()
from neuronunit.tests import fi
model.set_attrs(attrs)
from neuronunit.optimization import get_neab
rtp = get_neab.tests[0]
rheobase = rtp.generate_prediction(model)
self.assertTrue(float(rheobase['value']))
def dtc_to_rheo(dtc):
from neuronunit.optimization import get_neab
dtc.scores = {}
from neuronunit.models.reduced import ReducedModel
model = ReducedModel(get_neab.LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURON')
model.set_attrs(dtc.attrs)
rbt = get_neab.tests[0]
score = rbt.judge(model, stop_on_error=False, deep_error=True)
dtc.scores[str(rbt)] = score.sort_key
observation = score.observation
dtc.rheobase = score.prediction
return dtc
def check_current(ampl, dtc):
'''
Inputs are an amplitude to test and a virtual model
output is an virtual model with an updated dictionary.
'''
import copy
import os
import quantities
from neuronunit.models.reduced import ReducedModel
import neuronunit
LEMS_MODEL_PATH = str(neuronunit.__path__[0]) + str(
'/models/NeuroML2/LEMS_2007One.xml')
dtc.model_path = LEMS_MODEL_PATH
model = ReducedModel(dtc.model_path,
name='vanilla',
backend=(str(dtc.backend), {
'DTC': dtc
}))
import copy
model.set_attrs(dtc.attrs)
DELAY = 100.0 * pq.ms
DURATION = 1000.0 * pq.ms
params = {
'injected_square_current': {
'amplitude': 100.0 * pq.pA,
'delay': DELAY,
'duration': DURATION
}
}
dtc = copy.copy(dtc)
ampl = float(ampl)
#print(dtc.lookup)
if ampl not in dtc.lookup or len(dtc.lookup) == 0:
current = params.copy()['injected_square_current']
uc = {'amplitude': ampl}
current.update(uc)
current = {'injected_square_current': current}
dtc.run_number += 1
model.set_attrs(dtc.attrs)
model.inject_square_current(current)
dtc.previous = ampl
n_spikes = model.get_spike_count()
dtc.lookup[float(ampl)] = n_spikes
if n_spikes == 1:
dtc.rheobase = float(ampl)
dtc.boolean = True
return dtc
return dtc
if float(ampl) in dtc.lookup:
return dtc
def dtc_to_rheo(xargs):
dtc,rtest = xargs
dtc.model_path = path_params['model_path']
LEMS_MODEL_PATH = path_params['model_path']
model = ReducedModel(LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON')
model.set_attrs(dtc.attrs)
dtc.scores = {}
dtc.score = {}
score = rtest.judge(model,stop_on_error = False, deep_error = True)
#if bool(model.get_spike_count() == 1 or model.get_spike_count() == 0)
if score.sort_key is not None:
dtc.scores[str(rtest)] = 1 - score.sort_key #pd.DataFrame([ ])
dtc.rheobase = score.prediction
#assert dtc.rheobase is not None
return dtc
def setUp(self):
self.predictions = None
self.predictionp = None
self.score_p = None
self.score_s = None
self.grid_points = grid_points()
dtcpop = self.grid_points
self.test_compute_score = test_compute_score
self.dtcpop = test_compute_score(dtcpop)
self.dtc = self.dtcpop[0]
self.rheobase = self.dtc.rheobase
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
self.standard_model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='NEURON')
self.model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='NEURON')
def use_dtc_to_plotting(dtcpop, minimagr):
from neuronunit.capabilities import spike_functions
import matplotlib.pyplot as plt
import numpy as np
plt.clf()
plt.style.use('ggplot')
fig, axes = plt.subplots(figsize=(10, 10), facecolor='white')
stored_min = []
stored_max = []
for dtc in dtcpop[1:-1]:
plt.plot(dtc.tvec, dtc.vm0, linewidth=3.5, color='grey')
stored_min.append(np.min(dtc.vm0))
stored_max.append(np.max(dtc.vm0))
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization.get_neab import tests as T
from neuronunit.optimization import get_neab
from neuronunit.optimization import evaluate_as_module
from neuronunit.optimization.evaluate_as_module import pre_format
model = ReducedModel(get_neab.LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURON')
import neuron
model._backend.reset_neuron(neuron)
model.set_attrs(minimagr.attrs)
model.rheobase = minimagr.rheobase['value']
minimagr = pre_format(minimagr)
parameter_list = list(minimagr.vtest.values())
model.inject_square_current(parameter_list[0])
model._backend.local_run()
assert model.get_spike_count() == 1
print(model.get_spike_count(), bool(model.get_spike_count() == 1))
brute_best = list(model.results['vm'])
plt.plot(dtcpop[0].tvec,
brute_best,
linewidth=1,
color='blue',
label='best candidate via grid') #+str(mini.scores))
plt.plot(dtcpop[0].tvec,
dtcpop[0].vm0,
linewidth=1,
color='red',
label='best candidate via GA') #+str(miniga.scores))
plt.legend()
plt.ylabel('$V_{m}$ mV')
plt.xlabel('ms')
plt.show()
def dtc_to_rheo(xargs):
dtc, rtest, backend = xargs
LEMS_MODEL_PATH = path_params['model_path']
model = ReducedModel(LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURON')
model.set_attrs(dtc.attrs)
dtc.scores = {}
dtc.score = {}
score = rtest.judge(model, stop_on_error=False, deep_error=True)
if score.sort_key is not None:
dtc.scores.get(str(rtest), 1 - score.sort_key)
dtc.scores[str(rtest)] = 1 - score.sort_key
dtc.rheobase = score.prediction
return dtc
def test_rheobase(self):
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
import copy
import unittest
dtc = copy.copy(self.dtc)
self.assertNotEqual(self.dtc, None)
dtc.scores = {}
size = len([v for v in dtc.attrs.values()])
assert size > 0
self.assertGreater(size, 0)
model = ReducedModel(get_neab.LEMS_MODEL_PATH,
name=str('vanilla'),
backend=('NEURON', {
'DTC': dtc
}))
temp = [v for v in model.attrs.values()]
assert len(temp) > 0
self.assertGreater(len(temp), 0)
rbt = get_neab.tests[0]
scoreN = rbt.judge(model, stop_on_error=False, deep_error=True)
import copy
dtc.scores[str(rbt)] = copy.copy(scoreN.norm_score)
assert scoreN.norm_score is not None
self.assertTrue(scoreN.norm_score is not None)
dtc.rheobase = copy.copy(scoreN.prediction)
return dtc
def dtc_to_model(self):
if self.backend is str("JULIA"):
from neuronunit.models import simple_with_current_injection
model = SimpleModel(attrs)
if self.backend is str('NEURON') or self.backend is str('jNEUROML'):
import neuronunit
LEMS_MODEL_PATH = str(neuronunit.__path__[0])+str('/models/NeuroML2/LEMS_2007One.xml')
self.model_path = LEMS_MODEL_PATH
from neuronunit.models.reduced import ReducedModel#, VeryReducedModel
model = ReducedModel(self.model_path,name='vanilla', backend=(self.backend, {'DTC':self}))
self.current_src_name = model._backend.current_src_name
assert type(self.current_src_name) is not type(None)
self.cell_name = model._backend.cell_name
model.attrs = self.attrs
else:
# The most likely outcome
from neuronunit.models.very_reduced_sans_lems import VeryReducedModel
model = VeryReducedModel(backend=self.backend)
model.backend = self.backend
model.attrs = self.attrs
model.rheobase = self.rheobase
try:
model.inj = self.params
except:
try:
model.inj = self.vparams
except:
model.inj = None
return model
def as_lems_model(self, backend=None):
glif_package = []
glif_package.append(self.metad)
glif_package.append(self.nc)
glif_package.append(self.get_sweeps)
lems_file_path = parse_glif.generate_lems(glif_package)
return ReducedModel(lems_file_path, backend=backend)
def test_4rheobase_setup(self):
from neuronunit.tests.fi import RheobaseTest, RheobaseTestP
from neuronunit.optimization import get_neab
from neuronunit.models import backends
from neuronunit.models.reduced import ReducedModel
import time
from neuronunit import aibs
import os
dataset_id = 354190013 # Internal ID that AIBS uses for a particular Scnn1a-Tg2-Cre
# Primary visual area, layer 5 neuron.
observation = aibs.get_observation(dataset_id,'rheobase')
#os.system('ipcluster start -n 8 --profile=default & sleep 25;')
rt = RheobaseTest(observation = observation)
rtp = RheobaseTestP(observation = observation)
get_neab.LEMS_MODEL_PATH = '/home/jovyan/neuronunit/neuronunit/optimization/NeuroML2/LEMS_2007One.xml'
model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON')
ticks = time.time()
self.score_p = rtp.judge(model,stop_on_error = False, deep_error = True)
self.predictionp = self.score_p.prediction
self.score_p = self.score_p.sort_key
tickp = time.time()
self.timed_p = tickp - ticks
self.score_s = rt.judge(model,stop_on_error = False, deep_error = True)
self.predictions = self.score_s.prediction
self.score_s = self.score_s.sort_key
self.timed_s = time.time() - tickp
print(' serial score {0} parallel score {1}'.format(self.score_s,self.score_p))
print(' serial time {0} parallel time {1}'.format(self.timed_s,self.timed_p))
def nrn_backend_works(self):
from neuronunit.optimization import get_neab
get_neab.LEMS_MODEL_PATH = '/home/jovyan/neuronunit/neuronunit/optimization/NeuroML2/LEMS_2007One.xml'
#from neuronunit.models import backends
from neuronunit.models.reduced import ReducedModel
model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON')
def test_10rheobase_setup(self):
from neuronunit.tests.fi import RheobaseTest, RheobaseTestP
from neuronunit.optimization import get_neab
from neuronunit.models.reduced import ReducedModel
from neuronunit import aibs
import os
dataset_id = 354190013 # Internal ID that AIBS uses for a particular Scnn1a-Tg2-Cre
# Primary visual area, layer 5 neuron.
observation = aibs.get_observation(dataset_id, 'rheobase')
rt = RheobaseTest(observation=observation)
rtp = RheobaseTestP(observation=observation)
model = ReducedModel(get_neab.LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURON')
self.score_p = rtp.judge(model, stop_on_error=False, deep_error=True)
self.predictionp = self.score_p.prediction
self.score_p = self.score_p.sort_key
self.score_s = rt.judge(model, stop_on_error=True, deep_error=True)
self.predictions = self.score_s.prediction
self.score_s = self.score_s.sort_key
print(' serial score {0} parallel score {1}'.format(
self.score_s, self.score_p))
self.assertEqual(int(self.score_s * 1000), int(self.score_p * 1000))
self.assertEqual(int(self.predictionp['value']),
int(self.predictions['value']))
def hack_judge(test_and_models):
(test, attrs) = test_and_models
model = None
obs = test.observation
LEMS_MODEL_PATH = path_params['model_path']
model = ReducedModel(LEMS_MODEL_PATH, name=str('vanilla'), backend=('RAW'))
model.set_attrs(attrs)
test.generate_prediction(model)
pred = test.generate_prediction(model)
score = test.compute_score(obs, pred)
try:
print(obs['value'], pred['value'])
except:
print(obs['mean'], pred['mean'])
return score
def test_2_backend_pyNN(self):
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
print(get_neab.LEMS_MODEL_PATH)
model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='pyNN')
print(model)
import pdb
pdb.set_trace()
def setUp(self):
#from neuronunit import neuroelectro
from neuronunit.models.reduced import ReducedModel
from .model_tests import ReducedModelTestCase
path = ReducedModelTestCase().path
self.model = ReducedModel(path, backend='jNeuroML')
if not is_neuroelectro_up():
return self.skipTest("Neuroelectro is down")
def parallel_method(item_of_iter_list):
from neuronunit.optimization import get_neab
get_neab.LEMS_MODEL_PATH = '/home/jovyan/neuronunit/neuronunit/optimization/NeuroML2/LEMS_2007One.xml'
#from neuronunit.models import backends
from neuronunit.models.reduced import ReducedModel
model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON')
model.set_attrs(item_of_iter_list)
get_neab.tests[0].prediction = dtc.rheobase
model.rheobase = dtc.rheobase['value']
scores = []
for k,t in enumerate(get_neab.tests):
if k>1:
t.params = dtc.vtest[k]
score = t.judge(model,stop_on_error = False, deep_error = True)
scores.append(score.sort_key,score)
return scores
def plot_vm(hof,ax,key):
ax.cla()
ax.set_title(' {0} vs $V_{M}$'.format(key[0]))
best_dtc = hof[0].dtc
best_rh = hof[0].dtc.rheobase
neuron = None
model = ReducedModel(path_params['model_path'],name = str('regular_spiking'),backend =('NEURON',{'DTC':best_dtc}))
params = {'injected_square_current':
{'amplitude': best_rh, 'delay':DELAY, 'duration':DURATION}}
results = modelrs.inject_square_current(params)
vm = model.get_membrane_potential()
times = vm.times
ax.plot(times,vm)
#ax.xlabel('ms')
#ax.ylabel('mV')
#ax.set_xlim(np.min(x),np.max(x))
#ax.set_ylim(np.min(z),np.max(z))
return ax
def test_neuron_set_attrs(self):
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
self.assertNotEqual(self.dtcpop,None)
dtc = self.dtcpop[0]
self.model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend=('NEURON',{'DTC':dtc}))
temp = [ v for v in self.model.attrs.values() ]
assert len(temp) > 0
self.assertGreater(len(temp),0)
def test_backend_inheritance(self):
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
print(get_neab.LEMS_MODEL_PATH)
model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='NEURON')
ma = list(dir(model))
if 'get_spike_train' in ma and 'rheobase' in ma:
return True
else:
return False
def dtc_to_rheo(dtc):
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
dtc.model_path = get_neab.LEMS_MODEL_PATH
dtc.LEMS_MODEL_PATH = get_neab.LEMS_MODEL_PATH
model = ReducedModel(dtc.LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURON')
model.set_attrs(dtc.attrs)
dtc.scores = {}
dtc.score = {}
score = get_neab.tests[0].judge(model,
stop_on_error=False,
deep_error=True)
#if bool(model.get_spike_count() == 1 or model.get_spike_count() == 0)
if score.sort_key is not None:
dtc.scores[str(
get_neab.tests[0])] = 1 - score.sort_key #pd.DataFrame([ ])
dtc.rheobase = score.prediction
#assert dtc.rheobase is not None
return dtc
def sanity_check_score(pop, td, tests):
'''
Used for debugging with fake models
'''
dtcpop = update_dtc_pop(pop, td)
for dtc in dtcpop:
dtc.scores = None
dtc.scores = {}
for t in tests:
for dtc in dtcpop:
LEMS_MODEL_PATH = path_params['model_path']
model = ReducedModel(LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURON')
model.set_attrs(dtc.attrs)
score = t.judge(model)
dtc.scores.get(str(t), 1.0)
if score.sort_key is not None:
dtc.scores[str(t)] = 1 - score.sort_key
return dtcpop
def check_current(ampl, dtc):
'''
Inputs are an amplitude to test and a virtual model
output is an virtual model with an updated dictionary.
'''
ampl = float(ampl)
import os
#from neuronunit.models import reduced
from neuronunit.models.reduced import ReducedModel
#assert os.path.isfile(dtc.model_path), "%s is not a file" % dtc.model_path
model = ReducedModel(dtc.model_path,
name='vanilla',
backend='NEURON')
#print(model)
#import pdb; pdb.set_trace()
DELAY = 100.0 * pq.ms
DURATION = 1000.0 * pq.ms
params = {
'injected_square_current': {
'amplitude': 100.0 * pq.pA,
'delay': DELAY,
'duration': DURATION
}
}
if ampl not in dtc.lookup or len(dtc.lookup) == 0:
current = params.copy()['injected_square_current']
uc = {'amplitude': ampl}
current.update(uc)
current = {'injected_square_current': current}
dtc.run_number += 1
#import ipyparallel as ipp
#model = ipp.Reference('model')
model.set_attrs(dtc.attrs)
model.name = dtc.attrs
model.inject_square_current(current)
dtc.previous = ampl
n_spikes = model.get_spike_count()
dtc.lookup[float(ampl)] = n_spikes
#name = str('rheobase {0} parameters {1}'.format(str(current),str(model.params)))
if n_spikes == 1:
dtc.rheobase = float(ampl)
dtc.boolean = True
return dtc
return dtc
if float(ampl) in dtc.lookup:
return dtc
def check_current(ampl,dtc):
'''
Inputs are an amplitude to test and a virtual model
output is an virtual model with an updated dictionary.
'''
import copy
import os
import quantities
from neuronunit.models.reduced import ReducedModel
import neuronunit
LEMS_MODEL_PATH = str(neuronunit.__path__[0])+str('/models/NeuroML2/LEMS_2007One.xml')
dtc.model_path = LEMS_MODEL_PATH
model = ReducedModel(dtc.model_path,name='vanilla', backend=(str(dtc.backend), {'DTC':dtc}))
import copy
model.set_attrs(dtc.attrs)
DELAY = 100.0*pq.ms
DURATION = 1000.0*pq.ms
params = {'injected_square_current':
{'amplitude':100.0*pq.pA, 'delay':DELAY, 'duration':DURATION}}
dtc = copy.copy(dtc)
ampl = float(ampl)
#print(dtc.lookup)
if ampl not in dtc.lookup or len(dtc.lookup) == 0:
current = params.copy()['injected_square_current']
uc = {'amplitude':ampl}
current.update(uc)
current = {'injected_square_current':current}
dtc.run_number += 1
model.set_attrs(dtc.attrs)
model.inject_square_current(current)
dtc.previous = ampl
n_spikes = model.get_spike_count()
dtc.lookup[float(ampl)] = n_spikes
if n_spikes == 1:
dtc.rheobase = float(ampl)
dtc.boolean = True
return dtc
return dtc
if float(ampl) in dtc.lookup:
return dtc