def make_param_spec(pop_names, param_dict): """Constructs a flat list representation of synaptic parameters.""" param_names = [] param_initial_dict = {} param_tuples = [] for pop_name in pop_names: param_specs = param_dict[pop_name] keyfun = lambda kv: str(kv[0]) for source, source_dict in sorted(viewitems(param_specs), key=keyfun): for sec_type, sec_type_dict in sorted(viewitems(source_dict), key=keyfun): for syn_name, syn_mech_dict in sorted(viewitems(sec_type_dict), key=keyfun): for param_fst, param_rst in sorted(viewitems(syn_mech_dict), key=keyfun): if isinstance(param_rst, dict): for const_name, const_range in sorted(viewitems(param_rst)): param_path = (param_fst, const_name) param_tuples.append(SynParam(pop_name, source, sec_type, syn_name, param_path, const_range)) param_key = '%s.%s.%s.%s.%s.%s' % (pop_name, str(source), sec_type, syn_name, param_fst, const_name) param_names.append(param_key) else: param_name = param_fst param_range = param_rst param_tuples.append(SynParam(pop_name, source, sec_type, syn_name, param_name, param_range)) param_key = '%s.%s.%s.%s.%s' % (pop_name, source, sec_type, syn_name, param_name) param_names.append(param_key) return ParamSpec(param_names=param_names, param_tuples=param_tuples)
def spike_density_estimate(population, spkdict, time_bins, arena_id=None, trajectory_id=None, output_file_path=None, progress=False, inferred_rate_attr_name='Inferred Rate Map', **kwargs): """ Calculates spike density function for the given spike trains. :param population: :param spkdict: :param time_bins: :param arena_id: str :param trajectory_id: str :param output_file_path: :param progress: :param inferred_rate_attr_name: str :param kwargs: dict :return: dict """ if progress: from tqdm import tqdm analysis_options = copy.copy(default_baks_analysis_options) analysis_options.update(kwargs) def make_spktrain(lst, t_start, t_stop): spkts = np.asarray(lst, dtype=np.float32) return spkts[(spkts >= t_start) & (spkts <= t_stop)] t_start = time_bins[0] t_stop = time_bins[-1] spktrains = {ind: make_spktrain(lst, t_start, t_stop) for (ind, lst) in viewitems(spkdict)} baks_args = dict() baks_args['a'] = analysis_options['BAKS Alpha'] baks_args['b'] = analysis_options['BAKS Beta'] if progress: seq = tqdm(viewitems(spktrains)) else: seq = viewitems(spktrains) spk_rate_dict = {ind: baks(spkts / 1000., time_bins / 1000., **baks_args)[0].reshape((-1,)) if len(spkts) > 1 else np.zeros(time_bins.shape) for ind, spkts in seq} if output_file_path is not None: if arena_id is None or trajectory_id is None: raise RuntimeError('spike_density_estimate: arena_id and trajectory_id required to write Spike Density' 'Function namespace') namespace = 'Spike Density Function %s %s' % (arena_id, trajectory_id) attr_dict = {ind: {inferred_rate_attr_name: np.asarray(spk_rate_dict[ind], dtype='float32')} for ind in spk_rate_dict} write_cell_attributes(output_file_path, population, attr_dict, namespace=namespace) result = {ind: {'rate': rate, 'time': time_bins} for ind, rate in viewitems(spk_rate_dict)} result = { ind: { 'rate': rate, 'time': time_bins } for ind, rate in viewitems(spk_rate_dict) } return result
def choose_synapse_projection(ranstream_syn, syn_layer, swc_type, syn_type, population_dict, projection_synapse_dict, log=False): """ Given a synapse projection, SWC synapse location, and synapse type, chooses a projection from the given projection dictionary based on 1) whether the projection properties match the given synapse properties and 2) random choice between all the projections that satisfy the given criteria. :param ranstream_syn: random state object :param syn_layer: synapse layer :param swc_type: SWC location for synapse (soma, axon, apical, basal) :param syn_type: synapse type (excitatory, inhibitory, neuromodulatory) :param population_dict: mapping of population names to population indices :param projection_synapse_dict: mapping of projection names to a tuple of the form: <type, layers, swc sections, proportions> """ ivd = {v: k for k, v in viewitems(population_dict)} projection_lst = [] projection_prob_lst = [] for k, (syn_config_type, syn_config_layers, syn_config_sections, syn_config_proportions, syn_config_contacts) in viewitems(projection_synapse_dict): if (syn_type == syn_config_type) and (swc_type in syn_config_sections): ord_indices = list_find_all(lambda x: x == swc_type, syn_config_sections) for ord_index in ord_indices: if syn_layer == syn_config_layers[ord_index]: projection_lst.append(population_dict[k]) projection_prob_lst.append( syn_config_proportions[ord_index]) if len(projection_lst) > 1: candidate_projections = np.asarray(projection_lst) candidate_probs = np.asarray(projection_prob_lst) if log: logger.info("candidate_projections: %s candidate_probs: %s" % \ (str(candidate_projections), str(candidate_probs))) projection = ranstream_syn.choice(candidate_projections, 1, p=candidate_probs)[0] elif len(projection_lst) > 0: projection = projection_lst[0] else: projection = None if projection is None: logger.error('Projection is none for syn_type = %s syn_layer = %s swc_type = %s' % \ (str(syn_type), str(syn_layer), str(swc_type))) logger.error(str(projection_synapse_dict)) if projection is not None: return ivd[projection] else: return None
def spatial_coactive_sets(population, spkdict, time_bins, trajectory, return_tree=False): """ Estimates spatially co-active activity ensembles from the given spike dictionary. """ import sklearn from sklearn.neighbors import BallTree x, y, d, t = trajectory pch_x = interpolate.pchip(t, x) pch_y = interpolate.pchip(t, y) spatial_bins = np.column_stack( [pch_x(time_bins[:-1]), pch_y(time_bins[:-1])]) acv_dict = { gid: np.histogram(np.asarray(lst), bins=time_bins)[0] for (gid, lst) in viewitems(spkdict[population]) if len(lst) > 1 } n_features = len(time_bins) - 1 n_samples = len(acv_dict) active_gid = {} active_bins = np.zeros((n_samples, n_features), dtype=np.bool) for i, (gid, acv) in enumerate(viewitems(acv_dict)): active_bins[i, :] = acv > 0 active_gid[i] = gid tree = BallTree(active_bins, metric='jaccard') qbins = np.zeros((n_features, n_features), dtype=np.bool) for ibin in range(n_features): qbins[ibin, ibin] = True nnrs, nndists = tree.query_radius(qbins, r=1, return_distance=True) fnnrs = [] fnndists = [] for i, (nns, nndist) in enumerate(zip(nnrs, nndists)): inds = [ inn for inn, nn in enumerate(nns) if np.any(np.logical_and(active_bins[nn, :], active_bins[i, :])) ] fnns = np.asarray([nns[inn] for inn in inds]) fdist = np.asarray([nndist[inn] for inn in inds]) fnnrs.append(fnns) fnndists.append(fdist) if return_tree: return n_samples, spatial_bins, fnnrs, fnndists, (tree, active_gid) else: return n_samples, spatial_bins, fnnrs, fnndists
def selectivity_optimization_params(optimization_config, pop_names, param_config_name): """Constructs a flat list representation of selectivity optimization parameters.""" mask_param_tuples = [] mask_param_names = [] if param_config_name is None: return None for pop_name in pop_names: if pop_name in optimization_config['selectivity']: opt_params = optimization_config['selectivity'][pop_name] structured_weights_masks = opt_params['Structured weights masks'][ param_config_name] else: raise RuntimeError( "selectivity_optimization_params: population %s does not have optimization configuration" % pop_name) keyfun = lambda kv: str(kv[0]) for source, source_dict in sorted(viewitems(structured_weights_masks), key=keyfun): for sec_type, sec_type_dict in sorted(viewitems(source_dict), key=keyfun): for syn_name, syn_mech_dict in sorted(viewitems(sec_type_dict), key=keyfun): for param_fst, param_rst in sorted( viewitems(syn_mech_dict), key=keyfun): if isinstance(param_rst, dict): for const_name, const_value in sorted( viewitems(param_rst)): param_path = (param_fst, const_name) param_key = '%s.%s.%s.%s.%s.%s' % ( pop_name, str(source), sec_type, syn_name, param_fst, const_name) mask_param_names.append(param_key) mask_param_tuples.append( SynParam(pop_name, source, sec_type, syn_name, param_path, const_value)) else: param_name = param_fst param_value = param_rst param_key = '%s.%s.%s.%s.%s' % (pop_name, source, sec_type, syn_name, param_name) mask_param_names.append(param_key) mask_param_tuples.append( SynParam(pop_name, source, sec_type, syn_name, param_name, param_value)) return SelectivityOptConfig(mask_param_names=mask_param_names, mask_param_tuples=mask_param_tuples)
def spike_covariate(population, spkdict, time_bins, nbins_before, nbins_after): """ Creates the spike covariate matrix. X: a matrix of size nbins x nadj x ncells """ spk_matrix = np.column_stack([ np.histogram(np.asarray(lst), bins=time_bins)[0] for i, (gid, lst) in enumerate(viewitems(spkdict[population])) if len(lst) > 1 ]) nbins = spk_matrix.shape[0] ncells = spk_matrix.shape[1] nadj = nbins_before + nbins_after + 1 X = np.empty([nbins, nadj, ncells]) X[:] = np.NaN start_idx = 0 for i in range(nbins - nbins_before - nbins_after): end_idx = start_idx + nadj X[i + nbins_before, :, :] = spk_matrix[start_idx:end_idx, :] start_idx = start_idx + 1 return X
def exchange_input_features(comm, requested_gids, input_features_attr_dict): my_gids = list(input_features_attr_dict.keys()) requested_gids_per_rank = comm.allgather(requested_gids) gid_rank_map = defaultdict(list) for rank, gids in enumerate(requested_gids_per_rank): for gid in gids: gid_rank_map[gid].append(rank) nranks = comm.size input_features_sendbuf = [list() for i in range(nranks)] for gid, features_dict in viewitems(input_features_attr_dict): if gid in gid_rank_map: for dst_rank in gid_rank_map[gid]: input_features_sendbuf[dst_rank].append((gid, features_dict)) input_features_recvbuf = comm.alltoall(input_features_sendbuf) comm.barrier() result_input_features_attr_dict = {} for l in input_features_recvbuf: for gid, features_dict in l: result_input_features_attr_dict[gid] = features_dict return result_input_features_attr_dict
def f(pp, **kwargs): if problem_regime == ProblemRegime.every: results_dict = eval_problem_fun(pp, **kwargs) result = results_dict elif problem_regime == ProblemRegime.mean: mpp = { gid: pp for gid in cell_index_set } results_dict = eval_problem_fun(mpp, **kwargs) result = np.mean([ v for k,v in viewitems(results_dict) ]) elif problem_regime == ProblemRegime.max: mpp = { gid: pp for gid in cell_index_set } results_dict = eval_problem_fun(mpp, **kwargs) result = np.max([ v for k,v in viewitems(results_dict) ]) else: raise RuntimeError("opt_eval_fun: unknown problem regime %s" % str(problem_regime)) return result
def plot(self, axes=None, show=True): """ """ import matplotlib.pyplot as plt from dentate.plot import clean_axes if len(self.recs) == 0: return if axes is None: fig, axes = plt.subplots() else: fig = axes.get_figure() for name, rec_dict in viewitems(self.recs): description = str(rec_dict['description']) axes.plot(self.tvec, rec_dict['vec'], label='%s: %s(%.2f) %s' % (name, rec_dict['node'].name, rec_dict['loc'], description)) axes.set_xlabel('Time (ms)') axes.set_ylabel('%s (%s)' % (rec_dict['ylabel'], rec_dict['units'])) axes.legend(loc='best', frameon=False, framealpha=0.5) title = None if 'title' in self.parameters: title = self.parameters['title'] if 'description' in self.parameters: if title is not None: title = title + '; ' + self.parameters['description'] else: title = self.parameters['description'] if title is not None: axes.set_title(title) clean_axes(axes) if show: fig.tight_layout() fig.show() else: return axes
def determine_cell_participation(gid_module_assignments): input_config = context.env.inputConfig[context.stimulus_id] feature_type_dict = input_config['feature type'] feature_seed_offset = int( context.env.modelConfig['Random Seeds']['Input Spatial Selectivity']) feature_type_random = np.random.RandomState(feature_seed_offset - 1) num_field_random = np.random.RandomState(feature_seed_offset - 1) gid_attributes = {} module_probabilities = [ calculate_field_distribution(pi, pr) for (pi, pr) in zip(module_pi, module_pr) ] population_ranges = context.population_ranges total_num_fields = 0 for population in ['MPP', 'LPP']: gid_attributes[population] = {} population_start = population_ranges[population][0] population_count = population_ranges[population][1] feature_type_values_lst = [] feature_type_prob_lst = [] for t, p in viewitems(feature_type_dict[population]): feature_type_values_lst.append(t) feature_type_prob_lst.append(p) feature_type_values = np.asarray(feature_type_values_lst) feature_type_probs = np.asarray(feature_type_prob_lst) feature_types = feature_type_random.choice(feature_type_values, p=feature_type_probs, size=(population_count, )) population_end = population_start + population_count gids = np.arange(population_start, population_end, 1) for (i, gid) in enumerate(gids): num_field_random.seed(feature_seed_offset + gid) cell = {} module = gid_module_assignments[gid] cell['Module'] = np.array([module], dtype='uint8') cell['Feature Type'] = np.array([feature_types[i]], dtype='uint8') nfields = 1 if feature_types[i] == feature_grid: cell['Num Fields'] = np.array([nfields], dtype='uint8') elif feature_types[i] == feature_place: field_probabilities = module_probabilities[module - 1] field_set = [i for i in xrange(field_probabilities.shape[0])] nfields = num_field_random.choice(field_set, p=field_probabilities, size=(10, ))[-1] cell['Num Fields'] = np.array([nfields], dtype='uint8') gid_attributes[population][gid] = cell total_num_fields += nfields logger.info('Rank %i: computed features for gid %i' % (context.env.comm.rank, gid)) return total_num_fields, gid_attributes
def network_features(env, target_trj_rate_map_dict, t_start, t_stop, target_populations): features_dict = dict() temporal_resolution = float(env.stimulus_config['Temporal Resolution']) time_bins = np.arange(t_start, t_stop, temporal_resolution) pop_spike_dict = spikedata.get_env_spike_dict(env, include_artificial=False) for pop_name in target_populations: has_target_trj_rate_map = pop_name in target_trj_rate_map_dict n_active = 0 sum_mean_rate = 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']) sum_mean_rate += mean_rate if mean_rate > 0.: n_active += 1 n_total = len(env.cells[pop_name]) - len( env.artificial_cells[pop_name]) n_target_rate_map = 0 sum_target_rate_dist_residual = None if has_target_trj_rate_map: pop_target_trj_rate_map_dict = target_trj_rate_map_dict[pop_name] n_target_rate_map = len(pop_target_trj_rate_map_dict) target_rate_dist_residuals = [] for gid in pop_target_trj_rate_map_dict: target_trj_rate_map = pop_target_trj_rate_map_dict[gid] rate_map_len = len(target_trj_rate_map) if gid in spike_density_dict: residual = np.abs( np.sum(target_trj_rate_map - spike_density_dict[gid]['rate'][:rate_map_len])) else: residual = np.abs(np.sum(target_trj_rate_map)) target_rate_dist_residuals.append(residual) sum_target_rate_dist_residual = np.sum(target_rate_dist_residuals) pop_features_dict = {} pop_features_dict['n_total'] = n_total pop_features_dict['n_active'] = n_active pop_features_dict['n_target_rate_map'] = n_target_rate_map pop_features_dict['sum_mean_rate'] = sum_mean_rate pop_features_dict[ 'sum_target_rate_dist_residual'] = sum_target_rate_dist_residual features_dict[pop_name] = pop_features_dict return features_dict
def parse_syn_mechparams(self, mechparams_dict): res = {} for mech_name, mech_params in viewitems(mechparams_dict): mech_params1 = {} for k, v in viewitems(mech_params): if isinstance(v, dict): if 'expr' in v: mech_params1[k] = ExprClosure([v['parameter']], v['expr'], v.get('const', None), ['x']) else: raise RuntimeError( 'parse_syn_mechparams: unknown parameter type %s' % str(v)) else: mech_params1[k] = v res[mech_name] = mech_params1 return res
def interspike_intervals(spkdict): """ Calculates interspike intervals from the given spike dictionary. """ isi_dict = {} for ind, lst in viewitems(spkdict): if len(lst) > 1: isi_dict[ind] = np.diff(np.asarray(lst)) else: isi_dict[ind] = np.asarray([], dtype=np.float32) return isi_dict
def spike_bin_counts(spkdict, time_bins): bin_dict = {} for (ind, lst) in viewitems(spkdict): if len(lst) > 0: spkts = np.asarray(lst, dtype=np.float32) bins, bin_edges = np.histogram(spkts, bins=time_bins) bin_dict[ind] = bins return bin_dict
def generate_gap_junctions(connection_prob, coupling_coeffs, coupling_params, ranstream_gj, gids_a, gids_b, gj_probs, gj_distances, cell_dict_a, cell_dict_b, gj_dict): k = int(round(connection_prob * len(gj_distances))) selected = ranstream_gj.choice(np.arange(0, len(gj_distances)), size=k, replace=False, p=gj_probs) count = len(selected) gid_dict = defaultdict(list) for i in selected: gid_a = gids_a[i] gid_b = gids_b[i] gid_dict[gid_a].append(gid_b) for gid_a, gids_b in viewitems(gid_dict): sections_a = [] positions_a = [] sections_b = [] positions_b = [] couplings_a = [] couplings_b = [] cell_a = cell_dict_a[gid_a] for gid_b in gids_b: cell_b = cell_dict_b[gid_b] section_a, position_a, distance_a, section_b, position_b, distance_b = \ choose_gj_locations(ranstream_gj, cell_a, cell_b) sections_a.append(section_a) positions_a.append(position_a) sections_b.append(section_b) positions_b.append(position_b) coupling_weight_a = np.polyval(coupling_params, distance_a) coupling_weight_b = np.polyval(coupling_params, distance_b) coupling_a = coupling_coeffs * coupling_weight_a coupling_b = coupling_coeffs * coupling_weight_b couplings_a.append(coupling_a) couplings_b.append(coupling_b) if len(gids_b) > 0: gj_dict[gid_a] = (np.asarray(gids_b, dtype=np.uint32), {'Location': {'Source section': np.asarray(sections_a, dtype=np.uint32), 'Source position': np.asarray(positions_a, dtype=np.float32), 'Destination section': np.asarray(sections_b, dtype=np.uint32), 'Destination position': np.asarray(positions_b, dtype=np.float32)}, 'Coupling strength': {'Source': np.asarray(couplings_a, dtype=np.float32), 'Destination': np.asarray(couplings_b, dtype=np.float32)}}) return count
def parse_stimulus_config(self): stimulus_dict = self.model_config['Stimulus'] stimulus_config = {} for k, v in viewitems(stimulus_dict): if k == 'Selectivity Type Probabilities': selectivity_type_prob_dict = {} for (pop, dvals) in viewitems(v): pop_selectivity_type_prob_dict = {} for (selectivity_type_name, selectivity_type_prob) in viewitems(dvals): pop_selectivity_type_prob_dict[int(self.selectivity_types[selectivity_type_name])] = \ float(selectivity_type_prob) selectivity_type_prob_dict[ pop] = pop_selectivity_type_prob_dict stimulus_config[ 'Selectivity Type Probabilities'] = selectivity_type_prob_dict elif k == 'Peak Rate': peak_rate_dict = {} for (pop, dvals) in viewitems(v): pop_peak_rate_dict = {} for (selectivity_type_name, peak_rate) in viewitems(dvals): pop_peak_rate_dict[int( self.selectivity_types[selectivity_type_name] )] = float(peak_rate) peak_rate_dict[pop] = pop_peak_rate_dict stimulus_config['Peak Rate'] = peak_rate_dict elif k == 'Arena': stimulus_config['Arena'] = {} for arena_id, arena_val in viewitems(v): arena_properties = {} arena_domain = None arena_trajectories = {} for kk, vv in viewitems(arena_val): if kk == 'Domain': arena_domain = self.parse_arena_domain(vv) elif kk == 'Trajectory': for name, trajectory_config in viewitems(vv): trajectory = self.parse_arena_trajectory( trajectory_config) arena_trajectories[name] = trajectory else: arena_properties[kk] = vv stimulus_config['Arena'][arena_id] = ArenaConfig( arena_id, arena_domain, arena_trajectories, arena_properties) else: stimulus_config[k] = v self.stimulus_config = stimulus_config
def spike_rates(spkdict): """ Calculates firing rates based on interspike intervals computed from the given spike dictionary. """ rate_dict = {} isidict = interspike_intervals(spkdict) for ind, isiv in viewitems(isidict): if isiv.size > 0: rate = 1.0 / (np.mean(isiv) / 1000.0) else: rate = 0.0 rate_dict[ind] = rate return rate_dict
def uvl_in_bounds(uvl_coords, layer_extents, pop_layers): for layer, count in viewitems(pop_layers): if count > 0: min_extent = layer_extents[layer][0] max_extent = layer_extents[layer][1] result = (uvl_coords[0] < (max_extent[0] + 0.001)) and \ (uvl_coords[0] > (min_extent[0] - 0.001)) and \ (uvl_coords[1] < (max_extent[1] + 0.001)) and \ (uvl_coords[1] > (min_extent[1] - 0.001)) and \ (uvl_coords[2] < (max_extent[2] + 0.001)) and \ (uvl_coords[2] > (min_extent[2] - 0.001)) if result: return True return False
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 write_params(output_path, pop_params_dict): output_pop_parameters = {} param_key_list = [] for population in pop_params_dict: this_pop_output_parameters = {} for gid in pop_params_dict[population]: this_gid_param_dicts = pop_params_dict[population][gid] this_output_params = {} for pd in this_gid_param_dicts: param_key = f'{pd["population"]}.{pd["source"]}.{pd["sec_type"]}.{pd["syn_name"]}.{pd["param_path"]}' param_val = pd["param_val"] param_key_list.append(param_key) this_output_params[param_key] = param_val this_pop_output_parameters[f'{gid}'] = this_output_params output_pop_parameters[population] = this_pop_output_parameters param_keys = set(param_key_list) output_file = h5py.File(output_path, 'a') param_mapping = {name: idx for (idx, name) in enumerate(param_keys)} parameters_grp = h5_get_group(output_file, 'Parameters') if 'parameters_type' not in parameters_grp: dt = h5py.enum_dtype(param_mapping, basetype=np.uint16) parameters_grp['parameter_enum'] = dt dt = np.dtype([("parameter", parameters_grp['parameter_enum']), ("value", np.float32)]) parameters_grp['parameters_type'] = dt for population in output_pop_parameters: pop_grp = h5_get_group(parameters_grp, population) this_pop_output_parameters = output_pop_parameters[population] for id_str in this_pop_output_parameters: this_output_params = this_pop_output_parameters[id_str] dset = h5_get_dataset( pop_grp, id_str, maxshape=(len(this_output_params), ), dtype=parameters_grp['parameters_type'].dtype) dset.resize((len(this_output_params), )) a = np.zeros(len(this_output_params), dtype=parameters_grp['parameters_type'].dtype) for idx, (parm, val) in enumerate(viewitems(this_output_params)): a[idx]["parameter"] = param_mapping[parm] a[idx]["value"] = val dset[:] = a output_file.close()
def assign_cells_to_module(gid_normed_distances, p_width=2. / 3, displace=0.1): offsets = np.linspace(-displace, 1. + displace, 10) positions = np.linspace(0., 1., 1000) p_module = lambda width, offset: lambda x: np.exp(-( (x - offset) / (width / 3. / np.sqrt(2.)))**2.) p_modules = np.array([ p_module(p_width, offset)(positions) for (i, offset) in enumerate(offsets) ], dtype='float32') p_sum = np.sum(p_modules, axis=0) p_density = np.divide(p_modules, p_sum) # 10 x 1000 #p_modules_max = np.max(p_density, axis=1) #mean_peak = np.mean(p_modules_max[1:-1]) left_offset = 0 right_offset = len(positions) valid_indices = np.arange(left_offset, right_offset, 1) valid_positions = positions[valid_indices] renormalized_positions = (valid_positions - np.min(valid_positions)) / ( np.max(valid_positions) - np.min(valid_positions)) #plt.figure() #for i in xrange(len(p_density)): # plt.plot(renormalized_positions, p_density[i][valid_indices]) feature_seed_offset = int( context.env.modelConfig['Random Seeds']['Input Spatial Selectivity']) local_random = np.random.RandomState() gid_module_assignments = dict() for gid, (u, _, _, _) in viewitems(gid_normed_distances): local_random.seed(gid + feature_seed_offset) interpolated_density_values = [] for i in xrange(len(p_density)): module_density = p_density[i][valid_indices] interpolated_density_values.append( np.interp(u, renormalized_positions, module_density)) remaining_density = 1. - np.sum(interpolated_density_values) max_density_index = np.argmax(interpolated_density_values) interpolated_density_values[max_density_index] += remaining_density module = local_random.choice(np.arange(len(p_density)) + 1, p=interpolated_density_values, size=(1, )) gid_module_assignments[gid] = module[0] return gid_module_assignments
def optimize_inverse_uvl_coords(xyz_coords, rotate, layer_extents, pop_layers, optiter=100): import dlib f_uvl_distance = make_uvl_distance(xyz_coords, rotate=rotate) for layer, count in viewitems(pop_layers): if count > 0: min_extent = layer_extents[layer][0] max_extent = layer_extents[layer][1] uvl_coords, dist = dlib.find_min_global(f_uvl_distance, min_extent, max_extent, optiter) if uvl_in_bounds(uvl_coords, layer_extents, {layer: count}): return uvl_coords return None
def save_to_h5(cell_attributes): for population in cell_attributes.keys(): place_cells, grid_cells = {}, {} for gid, cell in viewitems(cell_attributes[population]): if cell['Feature Type'][0] == feature_grid: grid_cells[gid] = cell elif cell['Feature Type'][0] == feature_place: place_cells[gid] = cell append_cell_attributes(context.output_path, population, grid_cells, namespace='Grid Selectivity',\ comm=context.comm, io_size=context.io_size, chunk_size=context.chunk_size,\ value_chunk_size=context.value_chunk_size) append_cell_attributes(context.output_path, population, place_cells, namespace='Place Selectivity',\ comm=context.comm, io_size=context.io_size, chunk_size=context.chunk_size,\ value_chunk_size=context.value_chunk_size)
def clear(self): self.gidset = set([]) self.gjlist = [] self.cells = defaultdict(list) self.artificial_cells = defaultdict(dict) self.biophys_cells = defaultdict(dict) self.recording_sets = {} if self.pc is not None: self.pc.gid_clear() if self.t_vec is not None: self.t_vec.resize(0) if self.id_vec is not None: self.id_vec.resize(0) if self.t_rec is not None: self.t_rec.resize(0) self.recs_dict = {} for pop_name, _ in viewitems(self.Populations): self.recs_dict[pop_name] = defaultdict(list)
def optimization_params(optimization_config, pop_names, param_config_name, param_type='synaptic'): """Constructs a flat list representation of synaptic optimization parameters based on network clamp optimization configuration.""" param_bounds = {} param_names = [] param_initial_dict = {} param_tuples = [] opt_targets = {} for pop_name in pop_names: if param_type == 'synaptic': if pop_name in optimization_config['synaptic']: opt_params = optimization_config['synaptic'][pop_name] param_ranges = opt_params['Parameter ranges'][param_config_name] else: raise RuntimeError( "optimization_params: population %s does not have optimization configuration" % pop_name) for target_name, target_val in viewitems(opt_params['Targets']): opt_targets['%s %s' % (pop_name, target_name)] = target_val keyfun = lambda kv: str(kv[0]) for source, source_dict in sorted(viewitems(param_ranges), key=keyfun): for sec_type, sec_type_dict in sorted(viewitems(source_dict), key=keyfun): for syn_name, syn_mech_dict in sorted(viewitems(sec_type_dict), key=keyfun): for param_fst, param_rst in sorted(viewitems(syn_mech_dict), key=keyfun): if isinstance(param_rst, dict): for const_name, const_range in sorted(viewitems(param_rst)): param_path = (param_fst, const_name) param_tuples.append(SynParam(pop_name, source, sec_type, syn_name, param_path, const_range)) param_key = '%s.%s.%s.%s.%s.%s' % (pop_name, str(source), sec_type, syn_name, param_fst, const_name) param_initial_value = (const_range[1] - const_range[0]) / 2.0 param_initial_dict[param_key] = param_initial_value param_bounds[param_key] = const_range param_names.append(param_key) else: param_name = param_fst param_range = param_rst param_tuples.append(SynParam(pop_name, source, sec_type, syn_name, param_name, param_range)) param_key = '%s.%s.%s.%s.%s' % (pop_name, source, sec_type, syn_name, param_name) param_initial_value = (param_range[1] - param_range[0]) / 2.0 param_initial_dict[param_key] = param_initial_value param_bounds[param_key] = param_range param_names.append(param_key) else: raise RuntimeError("optimization_params: unknown parameter type %s" % param_type) return OptConfig(param_bounds=param_bounds, param_names=param_names, param_initial_dict=param_initial_dict, param_tuples=param_tuples, opt_targets=opt_targets)
def get_total_extents(layer_extents): min_u = float('inf') max_u = 0.0 min_v = float('inf') max_v = 0.0 min_l = float('inf') max_l = 0.0 for layer, extent in viewitems(layer_extents): min_u = min(extent[0][0], min_u) min_v = min(extent[0][1], min_v) min_l = min(extent[0][2], min_l) max_u = max(extent[1][0], max_u) max_v = max(extent[1][1], max_v) max_l = max(extent[1][2], max_l) return ((min_u, max_u), (min_v, max_v), (min_l, max_l))
def parse_netclamp_config(self): """ :return: """ netclamp_config_dict = self.model_config['Network Clamp'] weight_generator_dict = netclamp_config_dict['Weight Generator'] template_param_rules_dict = netclamp_config_dict[ 'Template Parameter Rules'] opt_param_rules_dict = {} if 'Synaptic Optimization' in netclamp_config_dict: opt_param_rules_dict['synaptic'] = netclamp_config_dict[ 'Synaptic Optimization'] template_params = {} for (template_name, params) in viewitems(template_param_rules_dict): template_params[template_name] = params self.netclamp_config = NetclampConfig(template_params, weight_generator_dict, opt_param_rules_dict)
def histogram_autocorrelation(spkdata, bin_size=1., lag=1, quantity='count'): """Compute autocorrelation coefficients of the spike count or firing rate histogram of each population. """ spkpoplst = spkdata['spkpoplst'] spkindlst = spkdata['spkindlst'] spktlst = spkdata['spktlst'] num_cell_spks = spkdata['num_cell_spks'] pop_active_cells = spkdata['pop_active_cells'] tmin = spkdata['tmin'] tmax = spkdata['tmax'] bins = np.arange(tmin, tmax, bin_size) corr_dict = {} for subset, spkinds, spkts in zip(spkpoplst, spkindlst, spktlst): i = 0 spk_dict = defaultdict(list) for spkind, spkt in zip(np.nditer(spkinds), np.nditer(spkts)): spk_dict[int(spkind)].append(spkt) x_lst = [] for ind, lst in viewitems(spk_dict): spkts = np.asarray(lst) if quantity == 'rate': q = akde(spkts / 1000., time_bins / 1000.)[0] else: count, bin_edges = np.histogram(spkts, bins=bins) q = count x_lst.append(q) i = i + 1 x_matrix = np.matrix(x_lst) corr_matrix = np.apply_along_axis(lambda y: autocorr(y, lag), 1, x_matrix) corr_dict[subset] = corr_matrix return corr_dict
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 assign_cells_to_normalized_position(): rank = context.comm.rank population_distances = [] gid_arc_distance = dict() gid_normed_distances = dict() for population in ['MPP', 'LPP']: #(population_start, population_count) = context.population_ranges[population] attr_gen = NeuroH5CellAttrGen(context.coords_path, population, namespace=context.distances_namespace, comm=context.comm, io_size=context.io_size, cache_size=context.cache_size) for (gid, distances_dict) in attr_gen: if gid is None: break arc_distance_u = distances_dict['U Distance'][0] arc_distance_v = distances_dict['V Distance'][0] gid_arc_distance[gid] = (arc_distance_u, arc_distance_v) population_distances.append((arc_distance_u, arc_distance_v)) population_distances = np.asarray(population_distances, dtype='float32') min_u, max_u = np.min(population_distances[:, 0]), np.max( population_distances[:, 0]) min_v, max_v = np.min(population_distances[:, 1]), np.max( population_distances[:, 1]) for (gid, (arc_distance_u, arc_distance_v)) in viewitems(gid_arc_distance): normalized_u = (arc_distance_u - min_u) / (max_u - min_u) normalized_v = (arc_distance_v - min_v) / (max_v - min_v) gid_normed_distances[gid] = (normalized_u, normalized_v, arc_distance_u, arc_distance_v) return gid_normed_distances