def setUpClass(cls): """ Compile the network for this test """ neuron = Neuron( equations="r = 1" ) neuron2 = Neuron( equations="r = sum(exc)" ) pop1 = Population((3, 3), neuron) pop2 = Population((3, 3), neuron2) proj1 = Projection(pre=pop1, post=pop2, target="exc") proj2 = Projection(pre=pop1, post=pop2, target="exc") proj3 = Projection(pre=pop1, post=pop2, target="exc") proj1.connect_one_to_one(weights=0.1) proj2.connect_all_to_all(weights=0.1) proj3.connect_fixed_number_pre(3, weights=0.1) cls.test_net = Network() cls.test_net.add([pop1, pop2, proj1, proj2, proj3]) cls.test_net.compile(silent=True) cls.test_proj1 = cls.test_net.get(proj1) cls.test_proj2 = cls.test_net.get(proj2) cls.test_proj3 = cls.test_net.get(proj3)
def setUpClass(cls): """ Compile the network for this test """ neuron = Neuron(equations="r = 1") neuron2 = Neuron(equations="r = sum(exc)") pop1 = Population((3, 3), neuron) pop2 = Population((3, 3), neuron2) proj1 = Projection(pre=pop1, post=pop2, target="exc") proj2 = Projection(pre=pop1, post=pop2, target="exc") proj3 = Projection(pre=pop1, post=pop2, target="exc") proj1.connect_one_to_one(weights=0.1) proj2.connect_all_to_all(weights=0.1) proj3.connect_fixed_number_pre(3, weights=0.1) cls.test_net = Network() cls.test_net.add([pop1, pop2, proj1, proj2, proj3]) cls.test_net.compile(silent=True) cls.test_proj1 = cls.test_net.get(proj1) cls.test_proj2 = cls.test_net.get(proj2) cls.test_proj3 = cls.test_net.get(proj3)
def setUpClass(cls): """ Compile the network for this test. The input_neuron will generate a sequence of values: r_t = [-1, 0, 2, 5, 9, 14, 20, ...] """ input_neuron = Neuron(equations=""" r = r + t : init = -1 """) neuron2 = Neuron(equations=""" r = sum(ff) """) pop1 = Population((3), input_neuron) pop2 = Population((3), neuron2) # A projection with non-uniform delay proj = Projection(pop1, pop2, target="ff") proj.connect_one_to_one(weights=1.0, delays=Uniform(1, 5)) # Build up network cls.test_net = Network() cls.test_net.add([pop1, pop2, proj]) cls.test_net.compile(silent=True) # Store references for easier usage in test cases cls.net_proj = cls.test_net.get(proj) cls.net_pop1 = cls.test_net.get(pop1) cls.net_pop2 = cls.test_net.get(pop2)
def setUpClass(cls): """ Compile the network for this test. The input_neuron will generate a sequence of values: r_t = [-1, 0, 2, 5, 9, 14, 20, ...] one time as global (glob_r) and one time as local variable (r). """ input_neuron = Neuron(equations=""" glob_r = glob_r + t : init = -1, population r = r + t : init = -1 """) neuron2 = Neuron(equations=""" r = sum(ff) """) synapse_glob = Synapse(psp="pre.glob_r * w") pop1 = Population((3), input_neuron) pop2 = Population((3), neuron2) # A projection with uniform delay proj = Projection(pre=pop1, post=pop2, target="ff") proj.connect_one_to_one(weights=1.0, delays=10.0) # A projection with uniform delay proj2 = Projection(pre=pop1, post=pop2, target="ff_glob", synapse=synapse_glob) proj2.connect_one_to_one(weights=1.0, delays=10.0) # Build up network cls.test_net = Network() cls.test_net.add([pop1, pop2, proj, proj2]) cls.test_net.compile(silent=True) # Store references for easier usage in test cases cls.net_proj = cls.test_net.get(proj) cls.net_proj2 = cls.test_net.get(proj2) cls.net_pop1 = cls.test_net.get(pop1) cls.net_pop2 = cls.test_net.get(pop2)
def setUpClass(cls): """ Compile the network for this test """ neuron = Neuron(parameters="r=0.0") out1 = Neuron(equations=""" r = sum(one2one) """) out2 = Neuron(equations=""" r = sum(all2all) + sum(fnp) """) pop1 = Population((17, 17), neuron) pop2 = Population((17, 17), out1) pop3 = Population(4, out2) proj = Projection(pre=pop1, post=pop2, target="one2one") proj.connect_one_to_one( weights=0.0, force_multiple_weights=True) # weights set in the test proj2 = Projection(pre=pop1, post=pop3, target="all2all") proj2.connect_all_to_all(weights=Uniform(0, 1)) proj3 = Projection(pre=pop1, post=pop3, target="fnp") proj3.connect_fixed_number_pre(5, weights=Uniform(0, 1)) cls.test_net = Network() cls.test_net.add([pop1, pop2, pop3, proj, proj2, proj3]) cls.test_net.compile(silent=True) cls.net_pop1 = cls.test_net.get(pop1) cls.net_pop2 = cls.test_net.get(pop2) cls.net_pop3 = cls.test_net.get(pop3) cls.net_proj = cls.test_net.get(proj) cls.net_proj2 = cls.test_net.get(proj2) cls.net_proj3 = cls.test_net.get(proj3)
target='exc', synapse=DAPostCovarianceNoThreshold) ITStrD2.connect_all_to_all(weights=Uniform(0, 0.3)) #Normal(0.15,0.15)) ITStrD2.DA_type = -1 ITSTN = Projection(pre=IT, post=STN, target='exc', synapse=DAPostCovarianceNoThreshold) ITSTN.connect_all_to_all(weights=Uniform(0, 0.3)) #Normal(0.15,0.15)) ITSTN.DA_type = 1 ############### OUTPUT ######################## SNrMD = Projection(pre=SNr, post=MD, target='inh', synapse=StandardSynapse) SNrMD.connect_one_to_one(weights=changed['SNrMD.connect_one_to_one']) ################ REWARD ####################### PPTNSNc = Projection(pre=PPTN, post=SNc, target='exc', synapse=StandardSynapse) PPTNSNc.connect_all_to_all(weights=1.0) StrD1SNc = Projection(pre=StrD1, post=SNc, target='inh', synapse=DAPrediction) StrD1SNc.connect_all_to_all(weights=0.5) #statt 1.0 SNcStrD1 = Projection(pre=SNc, post=StrD1, target='dopa', synapse=StandardSynapse) SNcStrD1.connect_all_to_all(weights=1.0)
def grid_search_annarchy(param_grid: dict, param_map: dict, dt: float, simulation_time: float, inputs: dict, outputs: dict, sampling_step_size: Optional[float] = None, permute_grid: bool = False, circuit=None, **kwargs) -> DataFrame: """Function that runs multiple parametrizations of the same circuit in parallel and returns a combined output. Parameters ---------- param_grid Key-value pairs for each circuit parameter that should be altered over different circuit parametrizations. param_map Key-value pairs that map the keys of param_grid to concrete circuit variables. dt Simulation step-size in s. simulation_time Simulation time in s. inputs Inputs as provided to the `run` method of `:class:ComputeGraph`. outputs Outputs as provided to the `run` method of `:class:ComputeGraph`. sampling_step_size Sampling step-size as provided to the `run` method of `:class:ComputeGraph`. permute_grid If true, all combinations of the provided param_grid values will be realized. If false, the param_grid values will be traversed pairwise. circuit Instance of ANNarchy network. kwargs Additional keyword arguments passed to the `:class:ComputeGraph` initialization. Returns ------- DataFrame Simulation results stored in a multi-index data frame where each index lvl refers to one of the parameters of param_grid. """ from ANNarchy import Population, Projection, Network, TimedArray, Monitor, ANNarchyException # linearize parameter grid if necessary if type(param_grid) is dict: param_grid = linearize_grid(param_grid, permute_grid) # create annarchy net if necessary if circuit is None: circuit = Network(everything=True) # assign parameter updates to each circuit and combine them to unconnected network circuit_names = [] param_info = [] param_split = "__" val_split = "--" comb = "_" populations, projections = {}, {} for n in range(param_grid.shape[0]): # copy and re-parametrize populations try: for p in circuit.get_populations(): name = f'net{n}/{p.name}' p_new = Population(geometry=p.geometry, neuron=p.neuron_type, name=name, stop_condition=p.stop_condition, storage_order=p._storage_order, copied=False) p_new = adapt_pop(p_new, param_grid.iloc[n, :], param_map) populations[name] = p_new # add input to population for node, inp in inputs.items(): if node in name: inp_name = f'{name}_inp' inp = TimedArray(rates=inp, name=inp_name) proj = Projection(pre=inp, post=p_new, target='exc') proj.connect_one_to_one(1.0) populations[inp_name] = inp projections[inp_name] = proj except ANNarchyException: pass # copy and re-parametrize projections try: for c in circuit.get_projections(): source = c.pre if type(c.pre) is str else c.pre.name target = c.post if type(c.post) is str else c.post.name source = f'net{n}/{source}' target = f'net{n}/{target}' name = f'{source}/{target}/{c.name}' c_new = Projection(pre=source, post=target, target=c.target, synapse=c.synapse_type, name=name, copied=False) c_new._store_connectivity(c._connection_method, c._connection_args, c._connection_delay, c._storage_format) c_new = adapt_proj(c_new, param_grid.iloc[n, :], param_map) projections[name] = c_new except ANNarchyException: pass # collect parameter and circuit name infos circuit_names.append(f'net{n}') param_names = list(param_grid.columns.values) param_info_tmp = [f"{param_names[i]}{val_split}{val}" for i, val in enumerate(param_grid.iloc[n, :])] param_info.append(param_split.join(param_info_tmp)) net = Network() for p in populations.values(): net.add(p) for c in projections.values(): net.add(c) # adjust output of simulation to combined network nodes = [p.name for p in circuit.get_populations()] out_names, var_names, out_lens, monitors, monitor_names = [], [], [], [], [] for out_key, out in outputs.copy().items(): out_names_tmp, out_lens_tmp = [], [] if out[0] in nodes: for i, name in enumerate(param_info): out_tmp = list(out) out_tmp[0] = f'{circuit_names[i]}/{out_tmp[0]}' p = net.get_population(out_tmp[0]) monitors.append(Monitor(p, variables=out_tmp[-1], period=sampling_step_size, start=True, net_id=net.id)) monitor_names.append(f'{name}{param_split}out_var{val_split}{out_key}{comb}{out[0]}') var_names.append(out_tmp[-1]) out_names_tmp.append(f'{out_key}{comb}{out[0]}') out_lens_tmp.append(p.geometry[0]) elif out[0] == 'all': for node in nodes: for i, name in enumerate(param_info): out_tmp = list(out) out_tmp[0] = f'{circuit_names[i]}/{node}' p = net.get_population(out_tmp[0]) monitors.append(Monitor(p, variables=out_tmp[-1], period=sampling_step_size, start=True, net_id=net.id)) monitor_names.append(f'{name}{param_split}out_var{val_split}{out_key}{comb}{node}') var_names.append(out_tmp[-1]) out_names_tmp.append(f'{out_key}{comb}{node}') out_lens_tmp.append(p.geometry[0]) else: node_found = False for node in nodes: if out[0] in node: node_found = True for i, name in enumerate(param_info): out_tmp = list(out) out_tmp[0] = f'{circuit_names[i]}/{node}' p = net.get_population(out_tmp[0]) monitors.append(Monitor(p, variables=out_tmp[-1], period=sampling_step_size, start=True, net_id=net.id)) monitor_names.append(f'{name}{param_split}out_var{val_split}{out_key}{comb}{node}') var_names.append(out_tmp[-1]) out_names_tmp.append(f'{out_key}{comb}{node}') out_lens_tmp.append(p.geometry[0]) if not node_found: raise ValueError(f'Invalid output identifier in output: {out_key}. ' f'Node {out[0]} is not part of this network') out_names += list(set(out_names_tmp)) out_lens += list(set(out_lens_tmp)) #net.add(monitors) # simulate the circuits behavior net.compile() net.simulate(duration=simulation_time) # transform output into pyrates-compatible data format results = pyrates_from_annarchy(monitors, vars=list(set(var_names)), monitor_names=monitor_names, **kwargs) # transform results into long-form dataframe with changed parameters as columns multi_idx = [param_grid[key].values for key in param_grid.keys()] n_iters = len(multi_idx[0]) outs = [] for out_name, out_len in zip(out_names, out_lens): outs += [f'{out_name}_n{i}' for i in range(out_len)] * n_iters multi_idx_final = [] for idx in multi_idx: for val in idx: for out_len in out_lens: multi_idx_final += [val]*len(out_names)*out_len index = MultiIndex.from_arrays([multi_idx_final, outs], names=list(param_grid.keys()) + ["out_var"]) index = MultiIndex.from_tuples(list(set(index)), names=list(param_grid.keys()) + ["out_var"]) results_final = DataFrame(columns=index, data=np.zeros_like(results.values), index=results.index) for col in results.keys(): params = col.split(param_split) indices = [None] * len(results_final.columns.names) for param in params: var, val = param.split(val_split)[:2] idx = list(results_final.columns.names).index(var) try: indices[idx] = float(val) except ValueError: indices[idx] = val results_final.loc[:, tuple(indices)] = results[col].values return results_final