def main(config_path, params_id, output_file_name, verbose):
config_logging(verbose)
logger = utils.get_script_logger(os.path.basename(__file__))
eval_config = read_from_yaml(config_path,
include_loader=utils.IncludeLoader)
network_param_spec_src = eval_config['param_spec']
network_param_values = eval_config['param_values']
target_populations = eval_config['target_populations']
network_param_spec = make_param_spec(target_populations,
network_param_spec_src)
def from_param_list(x):
result = []
for i, (param_name, param_tuple) in enumerate(
zip(network_param_spec.param_names,
network_param_spec.param_tuples)):
param_range = param_tuple.param_range
# assert((x[i] >= param_range[0]) and (x[i] <= param_range[1]))
result.append((param_tuple, x[i]))
return result
x = network_param_values[params_id]
param_tuple_values = from_param_list(x)
def rec_dd():
return defaultdict(rec_dd)
def dd2dict(d):
for k, v in d.items():
if isinstance(v, dict):
d[k] = dd2dict(v)
return dict(d)
param_output_ddict = rec_dd()
for param_tuple, param_value in param_tuple_values:
if isinstance(param_tuple.param_path, tuple):
param_output_ddict[param_tuple.population][param_tuple.source][
param_tuple.sec_type][param_tuple.syn_name][
param_tuple.param_path[0]][
param_tuple.param_path[1]] = param_value
else:
param_output_ddict[param_tuple.population][param_tuple.source][
param_tuple.sec_type][param_tuple.syn_name][
param_tuple.param_path] = param_value
param_output_dict = dd2dict(param_output_ddict)
pprint.pprint(param_output_dict)
write_to_yaml(output_file_name, param_output_dict)
def main(config_path, params_id, output_file_name, verbose):
config_logging(verbose)
logger = utils.get_script_logger(os.path.basename(__file__))
eval_config = read_from_yaml(config_path,
include_loader=utils.IncludeLoader)
network_param_spec_src = eval_config['param_spec']
network_param_values = eval_config['param_values']
target_populations = eval_config['target_populations']
network_param_spec = make_param_spec(target_populations,
network_param_spec_src)
def from_param_list(x):
result = []
for i, (param_name, param_tuple) in enumerate(
zip(network_param_spec.param_names,
network_param_spec.param_tuples)):
param_range = param_tuple.param_range
# assert((x[i] >= param_range[0]) and (x[i] <= param_range[1]))
result.append((param_tuple, x[i]))
return result
params_id_list = []
if params_id is None:
params_id_list = list(network_param_values.keys())
else:
params_id_list = [params_id]
param_output_dict = dict()
for this_params_id in params_id_list:
x = network_param_values[this_params_id]
param_tuple_values = from_param_list(x)
this_param_list = []
for param_tuple, param_value in param_tuple_values:
this_param_list.append((param_tuple.population, param_tuple.source,
param_tuple.sec_type, param_tuple.syn_name,
param_tuple.param_path, param_value))
param_output_dict[this_params_id] = this_param_list
pprint.pprint(param_output_dict)
if output_file_name is not None:
write_to_yaml(output_file_name, param_output_dict)
def generate_param_lattice(config_path, n_samples, output_file_dir, output_file_name, maxiter=5, verbose=False):
from dmosopt import sampling
logger = utils.get_script_logger(os.path.basename(__file__))
output_path = None
if output_file_name is not None:
output_path = f'{output_file_dir}/{output_file_name}'
eval_config = read_from_yaml(config_path, include_loader=utils.IncludeLoader)
network_param_spec_src = eval_config['param_spec']
target_populations = eval_config['target_populations']
network_param_spec = make_param_spec(target_populations, network_param_spec_src)
param_tuples = network_param_spec.param_tuples
param_names = network_param_spec.param_names
n_params = len(param_tuples)
n_init = n_params * n_samples
Xinit = sampling.glp(n_init, n_params, maxiter=maxiter)
ub = []
lb = []
for param_name, param_tuple in zip(param_names, param_tuples):
param_range = param_tuple.param_range
ub.append(param_range[1])
lb.append(param_range[0])
ub = np.asarray(ub)
lb = np.asarray(lb)
for i in range(n_init):
Xinit[i,:] = Xinit[i,:] * (ub - lb) + lb
output_dict = {}
for i in range(Xinit.shape[0]):
output_dict[i] = list([float(x) for x in Xinit[i, :]])
if output_path is not None:
write_to_yaml(output_path, output_dict)
else:
pprint.pprint(output_dict)
def main(config_file, population, dt, gid, gid_selection_file, arena_id, trajectory_id, generate_weights,
t_max, t_min, nprocs_per_worker, n_epochs, n_initial, initial_maxiter, initial_method, optimizer_method, surrogate_method,
population_size, num_generations, resample_fraction, mutation_rate,
template_paths, dataset_prefix, config_prefix,
param_config_name, selectivity_config_name, param_type, recording_profile, results_file, results_path, spike_events_path,
spike_events_namespace, spike_events_t, input_features_path, input_features_namespaces, n_trials,
trial_regime, problem_regime, target_features_path, target_features_namespace, target_state_variable,
target_state_filter, use_coreneuron, cooperative_init, spawn_startup_wait):
"""
Optimize the input stimulus selectivity of the specified cell in a network clamp configuration.
"""
init_params = dict(locals())
comm = MPI.COMM_WORLD
size = comm.Get_size()
rank = comm.Get_rank()
results_file_id = None
if rank == 0:
results_file_id = generate_results_file_id(population, gid)
results_file_id = comm.bcast(results_file_id, root=0)
comm.barrier()
np.seterr(all='raise')
verbose = True
cache_queries = True
config_logging(verbose)
cell_index_set = set([])
if gid_selection_file is not None:
with open(gid_selection_file, 'r') as f:
lines = f.readlines()
for line in lines:
gid = int(line)
cell_index_set.add(gid)
elif gid is not None:
cell_index_set.add(gid)
else:
comm.barrier()
comm0 = comm.Split(2 if rank == 0 else 1, 0)
if rank == 0:
env = Env(**init_params, comm=comm0)
attr_info_dict = read_cell_attribute_info(env.data_file_path, populations=[population],
read_cell_index=True, comm=comm0)
cell_index = None
attr_name, attr_cell_index = next(iter(attr_info_dict[population]['Trees']))
cell_index_set = set(attr_cell_index)
comm.barrier()
cell_index_set = comm.bcast(cell_index_set, root=0)
comm.barrier()
comm0.Free()
init_params['cell_index_set'] = cell_index_set
del(init_params['gid'])
params = dict(locals())
env = Env(**params)
if size == 1:
configure_hoc_env(env)
init(env, population, cell_index_set, arena_id, trajectory_id, n_trials,
spike_events_path, spike_events_namespace=spike_events_namespace,
spike_train_attr_name=spike_events_t,
input_features_path=input_features_path,
input_features_namespaces=input_features_namespaces,
generate_weights_pops=set(generate_weights),
t_min=t_min, t_max=t_max)
if (population in env.netclamp_config.optimize_parameters[param_type]):
opt_params = env.netclamp_config.optimize_parameters[param_type][population]
else:
raise RuntimeError(f'optimize_selectivity: population {population} does not have optimization configuration')
if target_state_variable is None:
target_state_variable = 'v'
init_params['target_features_arena'] = arena_id
init_params['target_features_trajectory'] = trajectory_id
opt_state_baseline = opt_params['Targets']['state'][target_state_variable]['baseline']
init_params['state_baseline'] = opt_state_baseline
init_params['state_variable'] = target_state_variable
init_params['state_filter'] = target_state_filter
init_objfun_name = 'init_selectivity_objfun'
best = optimize_run(env, population, param_config_name, selectivity_config_name, init_objfun_name, problem_regime=problem_regime,
n_epochs=n_epochs, n_initial=n_initial, initial_maxiter=initial_maxiter, initial_method=initial_method,
optimizer_method=optimizer_method, surrogate_method=surrogate_method, population_size=population_size,
num_generations=num_generations, resample_fraction=resample_fraction, mutation_rate=mutation_rate,
param_type=param_type, init_params=init_params, results_file=results_file, nprocs_per_worker=nprocs_per_worker,
cooperative_init=cooperative_init, spawn_startup_wait=spawn_startup_wait, verbose=verbose)
opt_param_config = optimization_params(env.netclamp_config.optimize_parameters, [population], param_config_name, param_type)
if best is not None:
if results_path is not None:
run_ts = time.strftime("%Y%m%d_%H%M%S")
file_path = f'{results_path}/optimize_selectivity.{run_ts}.yaml'
param_names = opt_param_config.param_names
param_tuples = opt_param_config.param_tuples
if ProblemRegime[problem_regime] == ProblemRegime.every:
results_config_dict = {}
for gid, prms in viewitems(best):
n_res = prms[0][1].shape[0]
prms_dict = dict(prms)
this_results_config_dict = {}
for i in range(n_res):
results_param_list = []
for param_pattern, param_tuple in zip(param_names, param_tuples):
results_param_list.append((param_tuple.population,
param_tuple.source,
param_tuple.sec_type,
param_tuple.syn_name,
param_tuple.param_path,
float(prms_dict[param_pattern][i])))
this_results_config_dict[i] = results_param_list
results_config_dict[gid] = this_results_config_dict
else:
prms = best[0]
n_res = prms[0][1].shape[0]
prms_dict = dict(prms)
results_config_dict = {}
for i in range(n_res):
results_param_list = []
for param_pattern, param_tuple in zip(param_names, param_tuples):
results_param_list.append((param_tuple.population,
param_tuple.source,
param_tuple.sec_type,
param_tuple.syn_name,
param_tuple.param_path,
float(prms_dict[param_pattern][i])))
results_config_dict[i] = results_param_list
write_to_yaml(file_path, { population: results_config_dict } )
comm.barrier()
def main(config_path, target_features_path, target_features_namespace, optimize_file_dir, optimize_file_name, nprocs_per_worker, n_epochs, n_initial, initial_maxiter, initial_method, optimizer_method, population_size, num_generations, resample_fraction, mutation_rate, collective_mode, spawn_startup_wait, verbose):
network_args = click.get_current_context().args
network_config = {}
for arg in network_args:
kv = arg.split("=")
if len(kv) > 1:
k,v = kv
network_config[k.replace('--', '').replace('-', '_')] = v
else:
k = kv[0]
network_config[k.replace('--', '').replace('-', '_')] = True
run_ts = datetime.datetime.today().strftime('%Y%m%d_%H%M')
if optimize_file_name is None:
optimize_file_name=f"dmosopt.optimize_network_{run_ts}.h5"
operational_config = read_from_yaml(config_path)
operational_config['run_ts'] = run_ts
if target_features_path is not None:
operational_config['target_features_path'] = target_features_path
if target_features_namespace is not None:
operational_config['target_features_namespace'] = target_features_namespace
network_config.update(operational_config.get('kwargs', {}))
env = Env(**network_config)
objective_names = operational_config['objective_names']
param_config_name = operational_config['param_config_name']
target_populations = operational_config['target_populations']
opt_param_config = optimization_params(env.netclamp_config.optimize_parameters, target_populations, param_config_name)
opt_targets = opt_param_config.opt_targets
param_names = opt_param_config.param_names
param_tuples = opt_param_config.param_tuples
hyperprm_space = { param_pattern: [param_tuple.param_range[0], param_tuple.param_range[1]]
for param_pattern, param_tuple in
zip(param_names, param_tuples) }
init_objfun = 'init_network_objfun'
init_params = { 'operational_config': operational_config,
'opt_targets': opt_targets,
'param_tuples': [ param_tuple._asdict() for param_tuple in param_tuples ],
'param_names': param_names
}
init_params.update(network_config.items())
nworkers = env.comm.size-1
if resample_fraction is None:
resample_fraction = float(nworkers) / float(population_size)
if resample_fraction > 1.0:
resample_fraction = 1.0
if resample_fraction < 0.1:
resample_fraction = 0.1
# Create an optimizer
feature_dtypes = [(feature_name, np.float32) for feature_name in objective_names]
constraint_names = [f'{target_pop_name} positive rate' for target_pop_name in target_populations ]
dmosopt_params = {'opt_id': 'dentate.optimize_network',
'obj_fun_init_name': init_objfun,
'obj_fun_init_module': 'dentate.optimize_network',
'obj_fun_init_args': init_params,
'reduce_fun_name': 'compute_objectives',
'reduce_fun_module': 'dentate.optimize_network',
'reduce_fun_args': (operational_config, opt_targets),
'problem_parameters': {},
'space': hyperprm_space,
'objective_names': objective_names,
'feature_dtypes': feature_dtypes,
'constraint_names': constraint_names,
'n_initial': n_initial,
'initial_maxiter': initial_maxiter,
'initial_method': initial_method,
'optimizer': optimizer_method,
'n_epochs': n_epochs,
'population_size': population_size,
'num_generations': num_generations,
'resample_fraction': resample_fraction,
'mutation_rate': mutation_rate,
'file_path': f'{optimize_file_dir}/{optimize_file_name}',
'termination_conditions': True,
'save_surrogate_eval': True,
'save': True,
'save_eval': 5
}
#dmosopt_params['broker_fun_name'] = 'dmosopt_broker_init'
#dmosopt_params['broker_module_name'] = 'dentate.optimize_network'
best = dmosopt.run(dmosopt_params, spawn_workers=True, sequential_spawn=False,
spawn_startup_wait=spawn_startup_wait,
nprocs_per_worker=nprocs_per_worker,
collective_mode=collective_mode,
verbose=True, worker_debug=True)
if best is not None:
if optimize_file_dir is not None:
results_file_id = 'DG_optimize_network_%s' % run_ts
yaml_file_path = '%s/optimize_network.%s.yaml' % (optimize_file_dir, str(results_file_id))
prms = best[0]
prms_dict = dict(prms)
n_res = prms[0][1].shape[0]
results_config_dict = {}
for i in range(n_res):
result_param_list = []
for param_pattern, param_tuple in zip(param_names, param_tuples):
result_param_list.append([param_pattern, float(prms_dict[param_pattern][i])])
results_config_dict[i] = result_param_list
write_to_yaml(yaml_file_path, results_config_dict)