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
