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(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 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 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 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 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.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 = t.judge(model,stop_on_error = False, deep_error = False)
dtc.score.get(str(t), score)
dtc.score[str(t)][str('prediction')] = score.prediction
dtc.score[str(t)][str('observation')] = score.observation
if score.sort_key is not None:
if not hasattr(dtc,'score'):
dtc.score = score
print(dtc.score.prediction)
print(dtc.score.observation)
dtc.scores.get(str(t), 1.0 - score.sort_key)
else:
dtc.scores[str(t)] = 1.0
return dtc
def parallel_method(dtc):
from neuronunit.models.reduced import ReducedModel
#try:
from neuronunit.optimization import get_neab
tests = get_neab.tests
#dtc.cell_name
#dtc.current_src_name
#model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON',cell_name = dtc.cell_name, current_src_name = dtc.current_src_name)
model = ReducedModel(get_neab.LEMS_MODEL_PATH,
name=str('vanilla'),
backend='NEURON')
model.set_attrs(dtc.attrs)
tests[0].prediction = dtc.rheobase
model.rheobase = dtc.rheobase['value']
from neuronunit.optimization import evaluate_as_module
dtc = evaluate_as_module.pre_format(dtc)
for k, t in enumerate(tests):
if k > 0 and float(dtc.rheobase['value']) > 0:
t.params = dtc.vtest[k]
score = t.judge(model, stop_on_error=False, deep_error=False)
dtc.scores[str(t)] = score.sort_key
return dtc
def dtc_to_plotting(dtc):
'''
Inputs a data transport container, containing either no recording vectors,
or existing recording vectors that are intended to be over written with fresh ones.
outputs a data transport container with recording vectors added.
'''
import copy
dtc = copy.copy(dtc)
dtc.t = None
from neuronunit.models.reduced import ReducedModel
from neuronunit.optimization import get_neab
model = ReducedModel(get_neab.LEMS_MODEL_PATH,
name=str('vanilla'),
backend=('NEURON', {
'DTC': dtc
}))
model.set_attrs(dtc.attrs)
model.rheobase = dtc.rheobase['value']
score = get_neab.tests[-1].judge(model,
stop_on_error=False,
deep_error=True)
dtc.vm = list(model.results['vm'])
dtc.t = list(model.results['time'])
return dtc