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)