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 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 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 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 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)
data['conductivity']['medium'] = float(conductivity_medium)
data['permittivity']['medium'] = float(permittivity_medium)
data['permittivity']['dish'] = float(permittivity_dish)
data['solver']['linear_solver'] = 'mumps'
with open('parameters_griffin2011mesh.yml', 'w') as stream:
yaml.dump(data, stream)
model = Simulation('parameters_griffin2011mesh.yml')
model.set_log_level("DEBUG")
model.run()
field = model.fenics_study.normEr(0.05, 0.05, 0.01101)
print("Solved for conductivity of medium: ", data['conductivity']['medium'])
print("Solved for permittivity of medium: ", data['permittivity']['medium'])
print("Solved for conductivity of dish: ", data['conductivity']['dish'])
print("Got field: ", field)
return 1, field
parameters = {'conductivity_medium': cp.Uniform(1.0, 1.5),
'permittivity_medium': cp.Uniform(60, 80),
'permittivity_dish': cp.Uniform(2.5, 4.0)
}
uq_model = un.Model(griffinmodel, labels=[r"Electric Field Strength [V/m]"])
UQ = un.UncertaintyQuantification(model=uq_model, parameters=parameters, CPUs=None)
data = UQ.quantify(seed=42, method="pc")
# 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)
ax.fill_between(time, percentile_5, percentile_95, color=(0.45, 0.65, 0.9))
plt.savefig("hh_prediction.pdf")
plt.show()
super(NeuronModelBahl, self).__init__(adaptive=True,
path="bahl_neuron_model",
stimulus_start=stimulus_start,
stimulus_end=stimulus_end)
# Reimplement the set_parameters method used by run
def set_parameters(self, parameters):
for parameter in parameters:
self.h(parameter + " = " + str(parameters[parameter]))
# These commands must be added for this specific
# model to recalculate the parameters after they have been set
self.h("recalculate_passive_properties()")
self.h("recalculate_channel_densities()")
# Initialize the model with the start and end time of the stimulus
model = NeuronModelBahl(stimulus_start=100, stimulus_end=600)
# Define a parameter list and use it directly
parameters = {"e_pas": -80, cp.Uniform(-60, -85),
"apical Ra": 261, cp.Uniform(150, 300)}
# Initialize the features
features = un.SpikingFeatures()
# Perform the uncertainty quantification
UQ = un.UncertaintyQuantification(model=model,
parameters=parameters,
features=features)
data = UQ.quantify()
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)
if location == 'gangles21':
params = ['IE', 'A_I', 'Z', 'T_F', 'DX']
else:
params = ['IE', 'A_I', 'A_S', 'A_DECAY', 'T_PPT', 'Z', 'T_F', 'DX']
parameters_full = setup_params_dist(params)
# Create the parameters
for k, v in parameters_full.items():
print(k, v)
parameters_single = un.Parameters({k: v})
# Initialize the model
model = UQ_Icestupa(location=location)
# Set up the uncertainty quantification
UQ = un.UncertaintyQuantification(
model=model,
parameters=parameters_single,
features=features,
# CPUs=3,
)
# Perform the uncertainty quantification using # polynomial chaos with point collocation (by default) data =
data = UQ.quantify(
seed=10,
data_folder=FOLDER["sim"],
figure_folder=FOLDER["sim"],
filename=k,
)
# parameters = {"gbar_Na": cp.Uniform(100, 140), # 120
# "gbar_K": cp.Uniform(32, 40), # 36
# "gbar_l": cp.Uniform(0.2, 0.4)} # 0.3
parameters = {
"gbar_Na": cp.Uniform(60, 180), # 120
"gbar_K": cp.Uniform(18, 54), # 36
"gbar_l": cp.Uniform(0.15, 0.45)
} # 0.3
# Initialize the model
model = HodgkinHuxley()
# Perform the uncertainty quantification
UQ = un.UncertaintyQuantification(model=model,
parameters=parameters,
features=un.SpikingFeatures())
data = UQ.quantify(plot=None, nr_pc_mc_samples=10**3, save=False)
###############################
# Plot prediction interval #
###############################
time = data["HodgkinHuxley"].time
mean = data["HodgkinHuxley"].mean
variance = data["HodgkinHuxley"].variance
percentile_95 = data["HodgkinHuxley"].percentile_95
percentile_5 = data["HodgkinHuxley"].percentile_5
sobol = data["HodgkinHuxley"].sobol_first
ax = prettyPlot(time,
