def generate_data_monte_carlo_single(): # pragma: no cover parameter_list = [["a", 1, None], ["b", 2, None]] parameters = un.Parameters(parameter_list) parameters.set_all_distributions(un.uniform(0.5)) model = TestingModel1d() features = TestingFeatures(features_to_run=["feature0d", "feature1d", "feature2d"]) test = un.UncertaintyQuantification(model, features=features, parameters=parameters, verbose_level="error") test.monte_carlo_single(filename="TestingModel1d_MC", data_folder=test_data_dir, seed=seed, nr_samples=10, plot=None)
def setUp(self): self.output_test_dir = ".tests/" self.seed = 10 self.difference_treshold = 1e-10 if os.path.isdir(self.output_test_dir): shutil.rmtree(self.output_test_dir) os.makedirs(self.output_test_dir) self.parameter_list = [["a", 1, None], ["b", 2, None]] self.parameters = Parameters(self.parameter_list) self.parameters.set_all_distributions(uniform(0.5)) self.model = TestingModel1d() features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.uncertainty = UncertaintyQuantification( self.model, parameters=self.parameters, features=features, verbose_level="error") self.figureformat = ".png" self.nr_mc_samples = 10**1
def generate_data_uncertainty_calculations(): # pragma: no cover np.random.seed(seed) parameter_list = [["a", 1, None], ["b", 2, None]] parameters = un.Parameters(parameter_list) parameters.set_all_distributions(un.uniform(0.5)) model = TestingModel1d() features = TestingFeatures( features_to_run=["feature0d_var", "feature1d_var", "feature2d_var"]) uncertainty_calculations = un.core.UncertaintyCalculations( model=model, features=features, parameters=parameters) data = uncertainty_calculations.polynomial_chaos(uncertain_parameters="a", seed=seed) data.save(os.path.join(test_data_dir, "UncertaintyCalculations_a.h5")) np.random.seed(seed) data = uncertainty_calculations.polynomial_chaos(uncertain_parameters="b", seed=seed) data.save(os.path.join(test_data_dir, "UncertaintyCalculations_b.h5"))
def test_PC_plot(self): parameter_list = [["a", 1, None], ["b", 2, None]] parameters = Parameters(parameter_list) parameters.set_all_distributions(uniform(0.5)) model = TestingModel1d() features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.uncertainty = UncertaintyQuantification(model, features=features, parameters=parameters, verbose_level="error") self.uncertainty.polynomial_chaos(plot="condensed_first", data_folder=self.output_test_dir, figure_folder=self.output_test_dir, seed=self.seed) self.compare_plot("TestingModel1d_mean-variance") self.compare_plot("TestingModel1d_prediction-interval") self.compare_plot("TestingModel1d_sobol_first_grid") self.compare_plot("feature1d_mean-variance") self.compare_plot("feature1d_prediction-interval") self.compare_plot("feature1d_sobol_first_grid") self.compare_plot("feature0d_sobol_first") self.compare_plot("sobol_first_sum_grid")
def generate_data_PC_spectral(): # pragma: no cover parameter_list = [["a", 1, None], ["b", 2, None]] parameters = un.Parameters(parameter_list) parameters.set_all_distributions(un.uniform(0.5)) model = TestingModel1d() features = TestingFeatures(features_to_run=["feature0d", "feature1d", "feature2d"]) test = un.UncertaintyQuantification(model, features=features, parameters=parameters, verbose_level="error") test.polynomial_chaos(method="spectral", polynomial_order=6, filename="TestingModel1d_spectral", seed=seed, data_folder=test_data_dir, plot=None)
def uq_medaka(): """ Perform the uncertainty quantification and sensitivity analysis of the medaka model. Returns ------- data : uncertainpy.Data A data object that contains the results from the uncertainty quantification of the rat model. """ parameters = { "g_K": 4.18e-4, "g_Ca": 6.25e-5, "g_SK": 4e-4, "g_l": 2e-5, "g_BK": 3.13e-4, "g_Na": 2.19e-2, } parameters = un.Parameters(parameters) # Set all parameters to have a uniform distribution # within a +/- 50% interval around their original value parameters.set_all_distributions(un.uniform(1)) # Set full g_BK distribution parameters["g_BK"].distribution = cp.Uniform(0, 3.13e-4) # Initialize the features features = un.SpikingFeatures( new_features=[is_bursting, is_regular, is_not_spiking], features_to_run=features_to_run, logger_level="error", strict=False, threshold=0.55, end_threshold=-0.1, normalize=True, trim=False, min_amplitude=min_spike_amplitude, ) # Initialize the model and defining default options model = un.NeuronModel(file="medaka.py", name="medaka", ignore=True) # Perform the uncertainty quantification UQ = un.UncertaintyQuantification(model, parameters=parameters, features=features) # We set the seed to easier be able to reproduce the result data = UQ.quantify( seed=10, filename="medaka", polynomial_order=polynomial_order, save=True, plot=None, ) return data
def perform_uncertainty_analysis(): """ Perform an uncertainty quantification and sensitivity analysis of the model. Returns ------- data : uncertainpy.Data object The results from the uncertainty quantification. """ parameters = { "g_K": scale_conductance(G_K), "g_Ca": scale_conductance(G_Ca), "g_SK": scale_conductance(G_SK), "g_l": scale_conductance(G_l), "g_BK": scale_conductance(0.67) } # Temporary value parameters = un.Parameters(parameters) # Set all conductances to have a uniform distribution # within a +/- 50% interval around their original value parameters.set_all_distributions(un.uniform(1)) parameters["g_BK"].distribution = cp.Uniform(scale_conductance(0), scale_conductance(1)) # Initialize features with the correct algorithm features = un.SpikingFeatures(new_features=burstiness_factor, strict=False, logger_level="error", features_to_run=features_to_run, threshold=0.55, end_threshold=-0.1, normalize=True, trim=False, min_amplitude=min_spike_amplitude) # Initialize the model and define default options model = un.NeuronModel(file="tabak.py", name="tabak", discard=discard, noise_amplitude=noise_amplitude, simulation_time=simulation_time, ignore=True) # Perform the uncertainty quantification UQ = un.UncertaintyQuantification(model, parameters=parameters, features=features) # We set the seed to be able to reproduce the result data = UQ.quantify(seed=10, plot=None, data_folder=data_folder, polynomial_order=polynomial_order) return data
def test_monte_carlo_single(self): parameter_list = [["a", 1, None], ["b", 2, None]] parameters = Parameters(parameter_list) parameters.set_all_distributions(uniform(0.5)) model = TestingModel1d() features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.uncertainty = UncertaintyQuantification(model, features=features, parameters=parameters, verbose_level="error") data_dict = self.uncertainty.monte_carlo_single( filename="TestingModel1d_MC", plot=None, data_folder=self.output_test_dir, seed=self.seed, nr_samples=self.nr_mc_samples) self.assertIsInstance(data_dict["a"], Data) self.assertIsInstance(data_dict["b"], Data) folder = os.path.dirname(os.path.realpath(__file__)) compare_file = os.path.join( folder, "data/TestingModel1d_MC_single-parameter-a.h5") filename = os.path.join(self.output_test_dir, "TestingModel1d_MC_single-parameter-a.h5") self.assertTrue(os.path.isfile(filename)) result = subprocess.call([ "h5diff", "-d", str(self.difference_treshold), filename, compare_file ]) self.assertEqual(result, 0) compare_file = os.path.join( folder, "data/TestingModel1d_MC_single-parameter-b.h5") filename = os.path.join(self.output_test_dir, "TestingModel1d_MC_single-parameter-b.h5") self.assertTrue(os.path.isfile(filename)) result = subprocess.call([ "h5diff", "-d", str(self.difference_treshold), filename, compare_file ]) self.assertEqual(result, 0)
def generate_data_PC_model_function(): # pragma: no cover parameter_list = [["a", 1, None], ["b", 2, None]] parameters = un.Parameters(parameter_list) parameters.set_all_distributions(un.uniform(0.5)) features = TestingFeatures( features_to_run=["feature0d_var", "feature1d_var", "feature2d_var"]) test = un.UncertaintyQuantification(model_function, features=features, parameters=parameters, logger_level="error", logger_filename=None) test.polynomial_chaos(data_folder=test_data_dir, seed=seed, plot=None)
def set_up_test_calculations(self): parameter_list = [["a", 1, None], ["b", 2, None]] parameters = Parameters(parameter_list) parameters.set_all_distributions(uniform(0.5)) model = TestingModel1d() features = TestingFeatures(features_to_run=None) self.uncertainty = UncertaintyQuantification( model, parameters=parameters, features=features, uncertainty_calculations=TestingUncertaintyCalculations(model), verbose_level="error")
def go(parameter_list=[["a", 0.02, None], ["b", 0.2, None], ["c", -65, None], ["d", 8, None]]): # Create the parameters parameters = un.Parameters(parameter_list) # Set all parameters to have a uniform distribution # within a 50% interval around their fixed value parameters.set_all_distributions(un.uniform(0.5)) # Create a model from coffee_cup function and add labels model = un.Model(izhikevich, labels=["Time (ms)", "Voltage (mV)"]) # Initialize features features = un.SpikingFeatures(features_to_run="all") # Perform the uncertainty quantification UQ = un.UncertaintyQuantification(model=model, parameters=parameters, features=features) data = UQ.quantify()
def generate_data_PC_0D(): # pragma: no cover parameter_list = [["a", 1, None], ["b", 2, None]] parameters = un.Parameters(parameter_list) parameters.set_all_distributions(un.uniform(0.5)) model = TestingModel0d() features = TestingFeatures(features_to_run=None) test = un.UncertaintyQuantification(model, features=features, parameters=parameters, verbose_level="error") test.polynomial_chaos(data_folder=test_data_dir, seed=seed, plot=None)
def generate_data_PC_rosenblatt_spectral(): # pragma: no cover parameter_list = [["a", 1, None], ["b", 2, None]] parameters = un.Parameters(parameter_list) parameters.set_all_distributions(un.uniform(0.5)) model = TestingModel1d() features = TestingFeatures( features_to_run=["feature0d_var", "feature1d_var", "feature2d_var"]) test = un.UncertaintyQuantification(model, features=features, parameters=parameters, logger_level="error", logger_filename=None) test.polynomial_chaos(rosenblatt=True, method="spectral", filename="TestingModel1d_Rosenblatt_spectral", data_folder=test_data_dir, plot=None, seed=seed)
# set_xlabel("Time (ms)") # set_ylabel("Voltage (mv)") # plt.xlim([10, 55]) # plt.savefig("hh.pdf") # plt.show() # Define a parameter list parameter_list = [["gbar_Na", 120], ["gbar_K", 36], ["gbar_l", 0.3]] # Create the parameters parameters = un.Parameters(parameter_list) # Set all parameters to have a uniform distribution # within a 50% interval around their fixed value parameters.set_all_distributions(un.uniform(0.25)) # Initialize the model model = HodgkinHuxley() # Perform the uncertainty quantification UQ = un.UncertaintyQuantification(model=model, parameters=parameters) UQ.quantify(plot=None, nr_pc_mc_samples=10**2) time = UQ.data["HodgkinHuxley"].time mean = UQ.data["HodgkinHuxley"].mean percentile_95 = UQ.data["HodgkinHuxley"].percentile_95 percentile_5 = UQ.data["HodgkinHuxley"].percentile_5 ax = prettyPlot(time, mean, color=0, palette="deep", linewidth=2)
def main(): # Read sensitivity analysis config file sens_config_file = sys.argv[-1] sens_config_dict = utility.load_json(sens_config_file) cell_id = sens_config_dict['Cell_id'] cpu_count = sens_config_dict['cpu_count'] if 'cpu_count'\ in sens_config_dict.keys() else mp.cpu_count() perisomatic_sa = sens_config_dict.get('run_peri_analysis',False) # Parameters to vary (All-active) select_aa_param_path = sens_config_dict['select_aa_param_path'] # knobs # Parameters to vary (Perisomatic) if perisomatic_sa: select_peri_param_path = sens_config_dict['select_peri_param_path'] # knobs select_feature_path = sens_config_dict['select_feature_path'] # knobs param_mod_range = sens_config_dict.get('param_mod_range',.1) # knobs mechanism_path = sens_config_dict['mechanism'] # config files with all the paths for Bluepyopt sim lr = lims.LimsReader() morph_path = lr.get_swc_path_from_lims(int(cell_id)) model_base_path='/allen/aibs/mat/ateam_shared/' \ 'Mouse_Model_Fit_Metrics/{}'.format(cell_id) opt_config_file = os.path.join(model_base_path,'config_file.json') if not os.path.exists(opt_config_file): opt_config = { "morphology": "", "parameters": "config/{}/parameters.json".format(cell_id), "mechanism": "config/{}/mechanism.json".format(cell_id), "protocols": "config/{}/protocols.json".format(cell_id), "all_protocols": "config/{}/all_protocols.json".format(cell_id), "features": "config/{}/features.json".format(cell_id), "peri_parameters": "config/{}/peri_parameters.json".format(cell_id), "peri_mechanism": "config/{}/peri_mechanism.json".format(cell_id) } opt_config_file = os.path.join(os.getcwd(),'config_file.json') utility.save_json(opt_config_file,opt_config) # optimized parameters around which select parameters are varied optim_param_path_aa = '/allen/aibs/mat/ateam_shared/Mouse_Model_Fit_Metrics/'\ '{cell_id}/fitted_params/optim_param_unformatted_{cell_id}.json'.\ format(cell_id = cell_id) if not os.path.exists(optim_param_path_aa): optim_param_path_aa = '/allen/aibs/mat/ateam_shared/Mouse_Model_Fit_Metrics/'\ '{cell_id}/fitted_params/optim_param_{cell_id}_bpopt.json'.\ format(cell_id = cell_id) SA_obj_aa = SA_helper(optim_param_path_aa,select_aa_param_path,param_mod_range, opt_config_file) _,protocol_path,mech_path,feature_path,\ param_bound_path = SA_obj_aa.load_config(model_base_path) # Make sure to get the parameter bounds big enough for BluePyOpt sim sens_param_bound_write_path_aa = "param_sensitivity_aa.json" optim_param_aa = SA_obj_aa.create_sa_bound(param_bound_path, sens_param_bound_write_path_aa) param_dict_uc_aa = SA_obj_aa.create_sens_param_dict() parameters_aa ={key:optim_param_aa[val] for key,val in param_dict_uc_aa.items()} eval_handler_aa = Bpopt_Evaluator(protocol_path, feature_path, morph_path, sens_param_bound_write_path_aa, mech_path, ephys_dir=None, timed_evaluation = False) evaluator_aa = eval_handler_aa.create_evaluator() opt_aa = bpopt.optimisations.DEAPOptimisation(evaluator=evaluator_aa) stim_protocols = utility.load_json(protocol_path) stim_protocols = {key:val for key,val in stim_protocols.items() \ if 'LongDC' in key} stim_dict = {key:val['stimuli'][0]['amp'] \ for key,val in stim_protocols.items()} sorted_stim_tuple= sorted(stim_dict.items(), key=operator.itemgetter(1)) stim_name= sorted_stim_tuple[-1][0] # knobs (the max amp) # Copy compiled modfiles if not os.path.isdir('x86_64'): raise Exception('Compiled modfiles do not exist') efel_features = utility.load_json(select_feature_path) un_features = un.EfelFeatures(features_to_run=efel_features) un_parameters_aa = un.Parameters(parameters_aa) un_parameters_aa.set_all_distributions(un.uniform(param_mod_range)) un_model_aa = un.Model(run=nrnsim_bpopt, interpolate=True, labels=["Time (ms)", "Membrane potential (mV)"], opt=opt_aa,stim_protocols =stim_protocols, param_dict_uc = param_dict_uc_aa, stim_name=stim_name, optim_param=optim_param_aa) # Perform the uncertainty quantification UQ_aa = un.UncertaintyQuantification(un_model_aa, parameters=un_parameters_aa, features=un_features) data_folder = 'sensitivity_data' sa_filename_aa = 'sa_allactive_%s.h5'%cell_id sa_filename_aa_csv = 'sa_allactive_%s.csv'%cell_id sa_data_path_aa = os.path.join(data_folder,sa_filename_aa) sa_aa_csv_path = os.path.join(data_folder,sa_filename_aa_csv) UQ_aa.quantify(seed=0,CPUs=cpu_count,data_folder=data_folder, filename= sa_filename_aa) _ = SA_obj_aa.save_analysis_data(sa_data_path_aa, filepath=sa_aa_csv_path) cell_data_aa = un.Data(sa_data_path_aa) SA_obj_aa.plot_sobol_analysis(cell_data_aa,analysis_path = \ 'figures/sa_analysis_aa_%s.pdf'%cell_id, palette='Set1') # Perisomatic model if perisomatic_sa: try: optim_param_path_peri = None SA_obj_peri = SA_helper(optim_param_path_peri,select_peri_param_path,param_mod_range, opt_config_file) _,_,mech_path_peri,_,\ param_bound_path_peri = SA_obj_peri.load_config(model_base_path, perisomatic=True) sens_param_bound_write_path_peri = "param_sensitivity_peri.json" optim_param_peri = SA_obj_peri.create_sa_bound_peri(param_bound_path_peri, sens_param_bound_write_path_peri) param_dict_uc_peri = SA_obj_peri.create_sens_param_dict() parameters_peri ={key:optim_param_peri[val] for key,val in param_dict_uc_peri.items()} eval_handler_peri = Bpopt_Evaluator(protocol_path, feature_path, morph_path, sens_param_bound_write_path_peri, mech_path_peri, ephys_dir=None, timed_evaluation = False) evaluator_peri = eval_handler_peri.create_evaluator() opt_peri = bpopt.optimisations.DEAPOptimisation(evaluator=evaluator_peri) un_parameters_peri= un.Parameters(parameters_peri) un_parameters_peri.set_all_distributions(un.uniform(param_mod_range)) un_model_peri = un.Model(run=nrnsim_bpopt, interpolate=True, labels=["Time (ms)", "Membrane potential (mV)"], opt=opt_peri,stim_protocols =stim_protocols, param_dict_uc = param_dict_uc_peri, stim_name=stim_name, optim_param=optim_param_peri) UQ_peri = un.UncertaintyQuantification(un_model_peri, parameters=un_parameters_peri, features=un_features) sa_filename_peri = 'sa_perisomatic_%s.h5'%cell_id sa_filename_peri_csv = 'sa_perisomatic_%s.csv'%cell_id sa_data_path_peri = os.path.join(data_folder,sa_filename_peri) sa_peri_csv_path = os.path.join(data_folder,sa_filename_peri_csv) UQ_peri.quantify(seed=0,CPUs=cpu_count,data_folder=data_folder, filename= sa_filename_peri) _ = SA_obj_peri.save_analysis_data(sa_data_path_peri, filepath=sa_peri_csv_path) cell_data_peri = un.Data(sa_data_path_peri) SA_obj_peri.plot_sobol_analysis(cell_data_peri,analysis_path = \ 'figures/sa_analysis_peri_%s.pdf'%cell_id, palette='Set2') except Exception as e: print(e)
def test_uniform_error(self): dist = uniform(0.1) with self.assertRaises(ValueError): dist(0)
def test_uniform(self): dist = uniform(0.1) self.assertIsInstance(dist(5), cp.Dist)