def trace_explore_widget(optimal_model_params=None):
'''
move this to utils file.
Allow app user to explore model behavior around the optimal,
by panning across parameters and then viewing resulting spike shapes.
'''
attrs = {k: np.mean(v) for k, v in MODEL_PARAMS["IZHI"].items()}
plt.clf()
cnt = 0
slider_value = st.slider("parameter a",
min_value=0.01,
max_value=0.1,
value=0.05,
step=0.001)
if optimal_model_params is None:
dtc = DataTC(backend="IZHI", attrs=attrs)
else:
dtc = DataTC(backend="IZHI", attrs=optimal_model_params)
dtc.attrs['a'] = slider_value
dtc = dtc_to_rheo(dtc)
temp_rh = dtc.rheobase
model = dtc.dtc_to_model()
model.attrs = model._backend.default_attrs
model.attrs.update(dtc.attrs)
uc = {'amplitude': temp_rh, 'duration': DURATION, 'delay': DELAY}
model._backend.inject_square_current(uc)
vm = model.get_membrane_potential()
plt.plot(vm.times, vm.magnitude)
cnt += 1
st.pyplot()
def test_opt_1(self):
cellmodel = "ADEXP"
if cellmodel == "IZHI":
model = model_classes.IzhiModel()
if cellmodel == "MAT":
model = model_classes.MATModel()
if cellmodel == "ADEXP":
model = model_classes.ADEXPModel()
dtc = DataTC()
dtc.backend = cellmodel
dtc._backend = model._backend
dtc.attrs = model.attrs
dtc.params = {
k: np.mean(v)
for k, v in MODEL_PARAMS[cellmodel].items()
}
other_params = BPO_PARAMS[cellmodel]
dtc = dtc_to_rheo(dtc)
assert dtc.rheobase is not None
self.assertIsNotNone(dtc.rheobase)
vm, plt, dtc = inject_and_plot_model(dtc, plotly=False)
self.assertIsNotNone(vm)
model = dtc.dtc_to_model()
self.assertIsNotNone(model)
def test_opt_1(self):
model_type = "ADEXP"
if model_type == "IZHI":
from jithub.models.model_classes import IzhiModel
cellmodel = IzhiModel()
# model = model_classes.IzhiModel()
#if cellmodel == "MAT":
# model = model_classes.MATModel()
if model_type == "ADEXP":
from jithub.models.model_classes import ADEXPModel
cellmodel = ADEXPModel()
# model = model_classes.ADEXPModel()
#dtc = DataTC(backend=cellmodel)
#assert dtc.backend == cellmodel
cellmodel.params = {
k: np.mean(v)
for k, v in MODEL_PARAMS[model_type].items()
}
#other_params = BPO_PARAMS[cellmodel]
cellmodel = dtc_to_rheo(cellmodel)
print(cellmodel.rheobase)
assert cellmodel.rheobase is not None
self.assertIsNotNone(cellmodel.rheobase)
vm, plt, cellmodel = inject_and_plot_model(cellmodel, plotly=False)
self.assertIsNotNone(vm)
#nt.assert_is_instance(vm, np.sum(fitnesses))
self.assertIsNotNone(cellmodel)
def _run_func(self, cell_model, param_values, sim=None):
"""Run protocols"""
try:
cell_model.freeze(param_values)
cell_model.instantiate(sim=sim)
try:
self.instantiate(sim=sim, icell=cell_model.icell)
except:
pass
try:
##
# The defualt NEURON SIM RUN
##
if not hasattr(cell_model, 'NU'):
self.cvode_active = False
sim.run(self.total_duration,
cvode_active=self.cvode_active)
else:
# first populate the dtc by frozen default attributes
# then update with dynamic gene attributes as appropriate.
if not hasattr(cell_model, '_backend'):
attrs = {}
else:
attrs = cell_model.default_attrs
attrs.update(copy.copy(param_values))
assert len(param_values)
assert attrs is not None
dtc = cell_model.model_to_dtc(attrs=attrs)
assert dtc.backend == cell_model.backend
dtc._backend = cell_model._backend
if hasattr(cell_model, 'allen'):
if hasattr(cell_model, 'seeded_current'):
dtc.seeded_current = cell_model.seeded_current
dtc.spk_count = cell_model.spk_count
from neuronunit.optimization.optimization_management import three_step_protocol
dtc = three_step_protocol(
dtc,
solve_for_current=cell_model.seeded_current)
if hasattr(dtc, 'everything'):
responses = {
'features': dtc.everything,
'name': 'rheobase_inj',
'dtc': dtc,
'model': cell_model,
'params': param_values
}
else:
responses = {
'model': dtc,
'rheobase': cell_model.rheobase,
'params': param_values
}
else:
dtc = three_step_protocol(dtc)
if hasattr(dtc, 'everything'):
responses = {
'features': dtc.everything,
'dtc': dtc,
'model': cell_model,
'params': param_values
}
else:
responses = {
'model': cell_model,
'rheobase': cell_model.rheobase,
'params': param_values
}
else:
from neuronunit.optimization.optimization_management import dtc_to_rheo
dtc = dtc_to_rheo(dtc, bind_vm=True)
#print(dtc.rheobase)
responses = {
'response': dtc.vmrh,
'model': dtc.dtc_to_model(),
'dtc': dtc,
'rheobase': dtc.rheobase,
'params': param_values
}
return responses
except (RuntimeError, simulators.NrnSimulatorException):
logger.debug(
'SweepProtocol: Running of parameter set {%s} generated '
'an exception, returning None in responses',
str(param_values))
responses = {
recording.name: None
for recording in self.recordings
}
else:
responses = {
recording.name: recording.response
for recording in self.recordings
}
self.destroy(sim=sim)
cell_model.destroy(sim=sim)
cell_model.unfreeze(param_values.keys())
return responses
except BaseException:
import sys
import traceback
raise Exception("".join(
traceback.format_exception(*sys.exc_info())))
def test_dtc_to_rheo(self):
from neuronunit.optimization import dtc_to_rheo
dtc_to_rheo(dtc)
seeds = pickle.load(f)
assert seeds is not None
except:
for local_attrs in grid:
store_glif_results[str(local_attrs.values())] = {}
dtc = DataTC()
dtc.tests = use_test
complete_params = {}
dtc.attrs = local_attrs
dtc.backend = 'GLIF'
dtc.cell_name = 'GLIF'
for key, use_test in test_frame.items():
dtc.tests = use_test
dtc = dtc_to_rheo(dtc)
dtc = format_test(dtc)
if dtc.rheobase is not None:
if dtc.rheobase!=-1.0:
dtc = nunit_evaluation(dtc)
print(dtc.get_ss())
store_glif_results[str(local_attrs.values())][key] = dtc.get_ss()
df = pd.DataFrame(store_glif_results)
best_params = {}
for index, row in df.iterrows():
best_params[index] = row == row.min()
best_params[index] = best_params[index].to_dict()
seeds = {}
for k,v in best_params.items():
def test_opt_1(self):
specimen_id = self.ids[1]
cellmodel = "ADEXP"
if cellmodel == "IZHI":
model = model_classes.IzhiModel()
if cellmodel == "MAT":
model = model_classes.MATModel()
if cellmodel == "ADEXP":
model = model_classes.ADEXPModel()
target_num_spikes = 8
dtc = DataTC()
dtc.backend = cellmodel
dtc._backend = model._backend
dtc.attrs = model.attrs
dtc.params = {
k: np.mean(v)
for k, v in MODEL_PARAMS[cellmodel].items()
}
dtc = dtc_to_rheo(dtc)
assert dtc.rheobase is not None
self.assertIsNotNone(dtc.rheobase)
vm, plt, dtc = inject_and_plot_model(dtc, plotly=False)
fixed_current = 122 * qt.pA
model, suite, nu_tests, target_current, spk_count = opt_setup(
specimen_id,
cellmodel,
target_num_spikes,
provided_model=model,
fixed_current=False,
cached=True)
model = dtc.dtc_to_model()
model.seeded_current = target_current['value']
model.allen = True
model.seeded_current
model.NU = True
cell_evaluator, simple_cell = opt_setup_two(model,
cellmodel,
suite,
nu_tests,
target_current,
spk_count,
provided_model=model)
NGEN = 15
MU = 12
mapping_funct = dask_map_function
final_pop, hall_of_fame, logs, hist = opt_exec(MU, NGEN, mapping_funct,
cell_evaluator)
opt, target = opt_to_model(hall_of_fame, cell_evaluator, suite,
target_current, spk_count)
best_ind = hall_of_fame[0]
fitnesses = cell_evaluator.evaluate_with_lists(best_ind)
assert np.sum(fitnesses) < 0.7
self.assertGreater(0.7, np.sum(fitnesses))
#obnames = [obj.name for obj in cell_evaluator.objectives]
gen_numbers = logs.select('gen')
min_fitness = logs.select('min')
max_fitness = logs.select('max')
avg_fitness = logs.select('avg')
plt.plot(gen_numbers, max_fitness, label='max fitness')
plt.plot(gen_numbers, avg_fitness, label='avg fitness')
plt.plot(gen_numbers, min_fitness, label='min fitness')
plt.plot(gen_numbers, min_fitness, label='min fitness')
plt.semilogy()
plt.xlabel('generation #')
plt.ylabel('score (# std)')
plt.legend()
plt.xlim(min(gen_numbers) - 1, max(gen_numbers) + 1)
#model = opt.dtc_to_model()
plt.plot(opt.vm15.times, opt.vm15)
plt.plot(opt.vm15.times, opt.vm15)
target.vm15 = suite.traces['vm15']
plt.plot(target.vm15.times, target.vm15)
target.vm15 = suite.traces['vm15']
check_bin_vm15(target, opt)
def test_dtc_to_rheo(self):
from neuronunit.optimization import dtc_to_rheo
dtc_to_rheo(dtc)
def test_opt(self):
ids = [
324257146, 325479788, 476053392, 623893177, 623960880, 482493761,
471819401
]
specimen_id = ids[1]
cellmodel = "MAT"
if cellmodel == "IZHI":
model = model_classes.IzhiModel()
if cellmodel == "MAT":
model = model_classes.MATModel()
if cellmodel == "ADEXP":
model = model_classes.ADEXPModel()
specific_filter_list = [
'ISI_log_slope_1.5x', 'mean_frequency_1.5x',
'adaptation_index2_1.5x', 'first_isi_1.5x', 'ISI_CV_1.5x',
'median_isi_1.5x', 'Spikecount_1.5x', 'all_ISI_values',
'ISI_values', 'time_to_first_spike', 'time_to_last_spike',
'time_to_second_spike', 'spike_times'
]
simple_yes_list = specific_filter_list
target_num_spikes = 8
dtc = DataTC()
dtc.backend = cellmodel
dtc._backend = model._backend
dtc.attrs = model.attrs
dtc.params = {
k: np.mean(v)
for k, v in MODEL_PARAMS[cellmodel].items()
}
dtc = dtc_to_rheo(dtc)
vm, plt, dtc = inject_and_plot_model(dtc, plotly=False)
fixed_current = 122 * qt.pA
model, suite, nu_tests, target_current, spk_count = opt_setup(
specimen_id,
cellmodel,
target_num_spikes,
provided_model=model,
fixed_current=False)
model = dtc.dtc_to_model()
model.seeded_current = target_current['value']
model.allen = True
model.seeded_current
model.NU = True
cell_evaluator, simple_cell = opt_setup_two(model,
cellmodel,
suite,
nu_tests,
target_current,
spk_count,
provided_model=model)
NGEN = 15
MU = 12
mapping_funct = dask_map_function
final_pop, hall_of_fame, logs, hist = opt_exec(MU, NGEN, mapping_funct,
cell_evaluator)
opt, target = opt_to_model(hall_of_fame, cell_evaluator, suite,
target_current, spk_count)
best_ind = hall_of_fame[0]
fitnesses = cell_evaluator.evaluate_with_lists(best_ind)
assert np.sum(fitnesses) < 0.7
self.assertGreater(0.7, np.sum(fitnesses))
#obnames = [obj.name for obj in cell_evaluator.objectives]
gen_numbers = logs.select('gen')
min_fitness = logs.select('min')
max_fitness = logs.select('max')
avg_fitness = logs.select('avg')
plt.plot(gen_numbers, max_fitness, label='max fitness')
plt.plot(gen_numbers, avg_fitness, label='avg fitness')
plt.plot(gen_numbers, min_fitness, label='min fitness')
plt.plot(gen_numbers, min_fitness, label='min fitness')
plt.semilogy()
plt.xlabel('generation #')
plt.ylabel('score (# std)')
plt.legend()
plt.xlim(min(gen_numbers) - 1, max(gen_numbers) + 1)
#model = opt.dtc_to_model()
plt.plot(opt.vm15.times, opt.vm15)
plt.plot(opt.vm15.times, opt.vm15)
target.vm15 = suite.traces['vm15']
plt.plot(target.vm15.times, target.vm15)
target.vm15 = suite.traces['vm15']
check_bin_vm15(target, opt)
