def main(arena_id, cell_selection_path, config_file, template_paths, hoc_lib_path, dataset_prefix, config_prefix, results_path, results_id, node_rank_file, io_size, recording_fraction, recording_profile, coredat, trajectory_id, tstop, v_init, stimulus_onset, max_walltime_hours, checkpoint_clear_data, checkpoint_interval, results_write_time, spike_input_path, spike_input_namespace, spike_input_attr, dt, ldbal, lptbal, cleanup, profile_memory, write_selection, verbose, debug, dry_run): profile_time = False comm = MPI.COMM_WORLD np.seterr(all='raise') params = dict(locals()) env = Env(**params) if profile_time: from dentate.network import init, run import cProfile cProfile.runctx('init(env)', None, locals(), filename='dentate_profile_init') if not dry_run: cProfile.runctx('run(env)', None, locals(), filename='dentate_profile_run') else: network.init(env) if not dry_run: network.run(env)
def eval_network(env, network_config, from_param_list, from_param_dict, network_params, network_param_values, params_id, target_trj_rate_map_dict, t_start, t_stop, target_populations, output_path): param_tuple_values = None if params_id is not None: x = network_param_values[params_id] if isinstance(x, list): param_tuple_values = from_param_list(x) elif isinstance(x, dict): param_tuple_values = from_param_dict(x) else: raise RuntimeError(f"eval_network: invalid input parameters argument {x}") if env.comm.rank == 0: logger.info("*** Updating network parameters ...") logger.info(pprint.pformat(param_tuple_values)) update_network_params(env, param_tuple_values) env.checkpoint_clear_data = False env.checkpoint_interval = None env.tstop = t_stop network.run(env, output=network_config.get('output_results', False), shutdown=False) for pop_name in target_trj_rate_map_dict: append_cell_attributes(env.results_file_path, pop_name, target_trj_rate_map_dict[pop_name], namespace='Target Trajectory Rate Map', comm=env.comm, io_size=env.io_size) local_features = network_features(env, target_trj_rate_map_dict, t_start, t_stop, target_populations) return collect_network_features(env, local_features, target_populations, output_path, params_id, param_tuple_values)
def network_objfun(env, operational_config, opt_targets, target_trj_rate_map_dict, from_param_dict, t_start, t_stop, target_populations, x): param_tuple_values = from_param_dict(x) update_network_params(env, param_tuple_values) env.tstop = t_stop network.run(env, output=False, shutdown=False) return network_features(env, target_trj_rate_map_dict, t_start, t_stop, target_populations)
def compute_features_firing_rate_fraction_active(x, export=False): """ :param x: array :param export: bool :return: dict """ results = dict() update_source_contexts(x, context) context.env.results_file_id = '%s_%s' % \ (context.interface.worker_id, datetime.datetime.today().strftime('%Y%m%d_%H%M%S')) network.run(context.env, output=context.output_results, shutdown=False) pop_spike_dict = spikedata.get_env_spike_dict(context.env, include_artificial=False) t_start = 250. t_stop = context.env.tstop time_bins = np.arange(t_start, t_stop, context.bin_size) for pop_name in context.target_populations: mean_rate_sum = 0. spike_density_dict = spikedata.spike_density_estimate (pop_name, pop_spike_dict[pop_name], time_bins) for gid, dens_dict in utils.viewitems(spike_density_dict): mean_rate_sum += np.mean(dens_dict['rate']) mean_rate_sum = context.env.comm.allreduce(mean_rate_sum, op=MPI.SUM) n_total = context.env.comm.allreduce(len(context.env.cells[pop_name]) - len(context.env.artificial_cells[pop_name]), op=MPI.SUM) n_active = context.env.comm.allreduce(len(spike_density_dict), op=MPI.SUM) if n_active > 0: mean_rate = mean_rate_sum / n_active else: mean_rate = 0. if n_total > 0: fraction_active = n_active / n_total else: fraction_active = 0. rank = int(context.env.pc.id()) if rank == 0: context.logger.info('population %s: n_active = %d n_total = %d' % (pop_name, n_active, n_total)) results['%s firing rate' % pop_name] = mean_rate results['%s fraction active' % pop_name] = fraction_active return results
def main(config_file, template_paths, hoc_lib_path, dataset_prefix, config_prefix, results_path, results_id, input_path, input_namespace, target_cell, tstop, v_init, stimulus_onset, max_walltime_hours, results_write_time, dt, ldbal, lptbal, verbose, dry_run): """ :param config_file: str; model configuration file name :param template_paths: str; colon-separated list of paths to directories containing hoc cell templates :param hoc_lib_path: str; path to directory containing required hoc libraries :param dataset_prefix: str; path to directory containing required neuroh5 data files :param config_prefix: str; path to directory containing network and cell mechanism config files :param results_path: str; path to directory to export output files :param results_id: str; label for neuroh5 namespaces to write spike and voltage trace data :param tstop: int; physical time to simulate (ms) :param v_init: float; initialization membrane potential (mV) :param stimulus_onset: float; starting time of stimulus (ms) :param max_walltime_hours: float; maximum wall time (hours) :param results_write_time: float; time to write out results at end of simulation :param dt: float; simulation time step :param verbose: bool; print verbose diagnostic messages while constructing the network :param dry_run: bool; whether to actually execute simulation after building network """ comm = MPI.COMM_WORLD np.seterr(all='raise') vrecord_fraction = 1.0 env = Env(comm, config_file, template_paths, hoc_lib_path, dataset_prefix, config_prefix, results_path, results_id, vrecord_fraction, target_cell, tstop, v_init, stimulus_onset, max_walltime_hours, results_write_time, dt, cell_selection=target_cell, spike_input_path=input_path, spike_input_ns=input_namespace, verbose=verbose) network.init(env) if not dry_run: network.run(env)
def compute_features_network_walltime(x, export=False): """ :param x: array :param export: bool :return: dict """ results = dict() start_time = time.time() update_source_contexts(x, context) results['modify_network_time'] = time.time() - start_time start_time = time.time() context.env.results_file_id = '%s_%s' % \ (context.interface.worker_id, datetime.datetime.today().strftime('%Y%m%d_%H%M%S')) network.run(context.env, output=context.output_results, shutdown=False) results['sim_network_time'] = time.time() - start_time return results
def main(cell_selection_path, config_file, template_paths, hoc_lib_path, dataset_prefix, config_prefix, results_path, results_id, node_rank_file, io_size, vrecord_fraction, coredat, tstop, v_init, stimulus_onset, max_walltime_hours, results_write_time, spike_input_path, spike_input_namespace, dt, ldbal, lptbal, cleanup, verbose, run_test): """ :param cell_selection_path: str; name of file specifying subset of cells gids to be instantiated :param config_file: str; model configuration file name :param template_paths: str; colon-separated list of paths to directories containing hoc cell templates :param hoc_lib_path: str; path to directory containing required hoc libraries :param dataset_prefix: str; path to directory containing required neuroh5 data files :param config_prefix: str; path to directory containing network and cell mechanism config files :param results_path: str; path to directory to export output files :param results_id: str; label for neuroh5 namespaces to write spike and voltage trace data :param node_rank_file: str; name of file specifying assignment of node gids to MPI ranks :param io_size: int; the number of MPI ranks to be used for I/O operations :param vrecord_fraction: float; fraction of cells to record intracellular voltage from :param coredat: bool; Save CoreNEURON data :param tstop: int; physical time to simulate (ms) :param v_init: float; initialization membrane potential (mV) :param stimulus_onset: float; starting time of stimulus (ms) :param max_walltime_hours: float; maximum wall time (hours) :param results_write_time: float; time to write out results at end of simulation :param spike_input_path: str; path to file for input spikes when cell selection is specified :param spike_input_namespace: str; :param dt: float; simulation time step :param ldbal: bool; estimate load balance based on cell complexity :param lptbal: bool; calculate load balance with LPT algorithm :param cleanup: bool; whether to delete from memory the synapse attributes metadata after specifying connections :param verbose: bool; print verbose diagnostic messages while constructing the network :param run_test: bool; whether to actually execute simulation after building network """ comm = MPI.COMM_WORLD np.seterr(all='raise') params = dict(locals()) env = Env(**params) network.init(env) if run_test: network.run(env, output=False)
def compute_features_firing_rate(x, export=False): """ :param x: array :param export: bool :return: dict """ results = dict() update_source_contexts(x, context) context.env.results_id = '%s_%s' % \ (context.interface.worker_id, datetime.datetime.today().strftime('%Y%m%d_%H%M%S')) network.run(context.env, output=context.output_results, shutdown=False) pop_spike_dict = spikedata.get_env_spike_dict(context.env) t_start = 0. t_stop = context.env.tstop time_bins = np.arange(t_start, t_stop, context.bin_size) pop_name = 'GC' mean_rate_sum = 0. spike_density_dict = spikedata.spike_density_estimate( pop_name, pop_spike_dict[pop_name], time_bins) for gid, dens_dict in utils.viewitems(spike_density_dict): mean_rate_sum += np.mean(dens_dict['rate']) n = len(spike_density_dict) if n > 0: mean_rate = mean_rate_sum / n else: mean_rate = 0. results['firing_rate'] = mean_rate return results
def compute_network_features(x, model_id=None, export=False): """ :param x: array :param export: bool :return: dict """ results = dict() update_source_contexts(x, context) # TODO: Do you want this to be identical on all ranks in a subworld? You can use context.comm.bcast context.env.results_file_id = '%s_%s' % \ (context.interface.worker_id, datetime.datetime.today().strftime('%Y%m%d_%H%M%S')) temporal_resolution = float( context.env.stimulus_config['Temporal Resolution']) time_bins = np.arange(context.t_start, context.t_stop, temporal_resolution) context.env.tstop = context.t_stop network.run(context.env, output=context.output_results, shutdown=False) pop_spike_dict = spikedata.get_env_spike_dict(context.env, include_artificial=False) for pop_name in context.target_populations: n_active_local = 0 mean_rate_sum_local = 0. spike_density_dict = spikedata.spike_density_estimate( pop_name, pop_spike_dict[pop_name], time_bins) for gid, dens_dict in utils.viewitems(spike_density_dict): mean_rate = np.mean(dens_dict['rate']) mean_rate_sum_local += mean_rate if mean_rate > 0.: n_active_local += 1 mean_rate_sum = context.env.comm.allreduce(mean_rate_sum_local, op=MPI.SUM) context.env.comm.barrier() n_local = len(context.env.cells[pop_name]) - len( context.env.artificial_cells[pop_name]) n_total = context.env.comm.allreduce(n_local, op=MPI.SUM) n_active = context.env.comm.allreduce(n_active_local, op=MPI.SUM) context.env.comm.barrier() if n_active > 0: mean_rate = mean_rate_sum / n_active else: mean_rate = 0. if n_total > 0: fraction_active = n_active / n_total else: fraction_active = 0. mean_target_rate_dist_residual = None if n_active > 0: pop_name_is_in_network = pop_name in context.target_trj_rate_map_dict and \ len(context.target_trj_rate_map_dict[pop_name] > 0) pop_name_is_in_network_list = context.env.comm.gather( pop_name_is_in_network, root=0) if context.env.comm.rank == 0: if any(pop_name_is_in_network_list): pop_name_is_in_network = True pop_name_is_in_network = context.env.comm.bcast( pop_name_is_in_network, root=0) if pop_name_is_in_network: mean_target_rate_dist_residual = 0. target_rate_dist_residuals = [] if pop_name in context.target_trj_rate_map_dict: target_trj_rate_map_dict = context.target_trj_rate_map_dict[ pop_name] for gid in target_trj_rate_map_dict: target_trj_rate_map = target_trj_rate_map_dict[gid] rate_map_len = len(target_trj_rate_map) if gid in spike_density_dict: residual = np.sum( target_trj_rate_map - spike_density_dict[gid]['rate'][:rate_map_len]) else: residual = np.sum(target_trj_rate_map) target_rate_dist_residuals.append(residual) residual_sum_local = np.sum(target_rate_dist_residuals) residual_sum = context.env.comm.allreduce(residual_sum_local, op=MPI.SUM) mean_target_rate_dist_residual = residual_sum / len( target_trj_rate_map_dict) context.env.comm.barrier() rank = int(context.env.pc.id()) if context.env.comm.rank == 0: context.logger.info( 'population %s: n_active = %d n_total = %d mean rate = %s' % (pop_name, n_active, n_total, str(mean_rate))) results['%s firing rate' % pop_name] = mean_rate results['%s fraction active' % pop_name] = fraction_active if mean_target_rate_dist_residual is not None: results['%s target rate dist residual' % pop_name] = mean_target_rate_dist_residual return results
def compute_network_features(x, model_id=None, export=False): """ :param x: array :param export: bool :return: dict """ results = dict() update_source_contexts(x, context) # TODO: Do you want this to be identical on all ranks in a subworld? You can use context.comm.bcast context.env.results_file_id = '%s_%s' % \ (context.interface.worker_id, datetime.datetime.today().strftime('%Y%m%d_%H%M%S')) temporal_resolution = float( context.env.stimulus_config['Temporal Resolution']) time_bins = np.arange(context.t_start, context.t_stop, temporal_resolution) context.env.tstop = context.t_stop network.run(context.env, output=context.output_results, shutdown=False) local_network_features = network_features(context.env, context.target_trj_rate_map_dict, context.t_start, context.t_stop, context.target_populations) results = {} for pop_name in context.target_populations: n_active_local = local_network_features[pop_name]['n_active'] n_total_local = local_network_features[pop_name]['n_total'] sum_mean_rate_local = local_network_features[pop_name]['sum_mean_rate'] n_target_rate_map_local = local_network_features[pop_name][ 'n_target_rate_map'] n_total = context.env.comm.allreduce(n_total_local, op=MPI.SUM) n_active = context.env.comm.allreduce(n_active_local, op=MPI.SUM) mean_rate_sum = context.env.comm.allreduce(sum_mean_rate_local, op=MPI.SUM) n_target_rate_map = context.env.comm.allreduce(n_target_rate_map_local, op=MPI.SUM) has_target_rate_map = n_target_rate_map > 0 if has_target_rate_map: sum_target_rate_dist_residual_local = local_network_features[ pop_name]['sum_target_rate_dist_residual'] sum_target_rate_dist_residual = context.env.comm.allreduce( sum_target_rate_dist_residual_local, op=MPI.SUM) context.env.comm.barrier() if n_active > 0: mean_rate = mean_rate_sum / n_active else: mean_rate = 0. if n_total > 0: fraction_active = n_active / n_total else: fraction_active = 0. mean_target_rate_dist_residual = None if has_target_rate_map: mean_target_rate_dist_residual = sum_target_rate_dist_residual / n_target_rate_map rank = int(context.env.pc.id()) if context.env.comm.rank == 0: context.logger.info( 'population %s: n_active = %d n_total = %d mean rate = %s' % (pop_name, n_active, n_total, str(mean_rate))) results['%s fraction active' % pop_name] = fraction_active results['%s firing rate' % pop_name] = mean_rate if mean_target_rate_dist_residual is not None: results['%s target rate dist residual' % pop_name] = mean_target_rate_dist_residual return results