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
"""
simple_neuron = Neuron(
parameters="r=1.0"
)
eq_set = Synapse(
equations="""
glob_var = 0.1 : projection
semi_glob_var = 0.2 : postsynaptic
w = t + glob_var + semi_glob_var
"""
)
pop0 = Population(3, simple_neuron)
pop1 = Population(1, simple_neuron)
proj = Projection(pop0, pop1, "exc", eq_set)
proj.connect_all_to_all(weights=0.0)
cls.test_net = Network()
cls.test_net.add([pop0, pop1, proj])
cls.test_net.compile(silent=True)
def setUpClass(self):
"""
Compile the network for this test
"""
neuron = Neuron(parameters="tau = 10", equations="r += 1/tau * t")
neuron2 = Neuron(parameters="tau = 10: population",
equations="r += 1/tau * t: init = 1.0")
Oja = Synapse(parameters="""
tau = 5000.0 : postsynaptic
alpha = 8.0
""",
equations="""
tau * dw/dt = pre.r * post.r - alpha * post.r^2 * w
""")
pop1 = Population(5, neuron)
pop2 = Population(8, neuron2)
proj = Projection(pre=pop1, post=pop2, target="exc", synapse=Oja)
proj.connect_all_to_all(weights=1.0)
self.test_net = Network()
self.test_net.add([pop1, pop2, proj])
self.test_net.compile(silent=True)
self.net_proj = self.test_net.get(proj)
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(self):
"""
Compile the network for this test
"""
neuron = Neuron(
equations = "r = transfer_function(sum(exc), 0.0)",
functions = "transfer_function(x, t) = if x > t: if x > 2*t : (x - 2*t)^2 else: x - t else: 0."
)
neuron2 = Neuron(
equations = "r = glob_pos(sum(exc))"
)
synapse = Synapse(
equations="w += hebb(pre.r, post.r)",
functions="hebb(x, y) = x * y"
)
pop = Population(10, neuron)
pop2 = Population(10, neuron2)
proj = Projection(pop, pop, 'exc', synapse).connect_all_to_all(1.0)
self.test_net = Network()
self.test_net.add([pop, pop2, proj])
self.test_net.compile(silent=True)
self.net_pop = self.test_net.get(pop)
self.net_proj = self.test_net.get(proj)
def setUpClass(self):
"""
Compile the network for this test
"""
neuron = Neuron(parameters="""
r=0
""")
cov = Synapse(parameters="""
tau = 5000.0
""",
equations="""
tau * dw/dt = (pre.r - mean(pre.r) ) * (post.r - mean(post.r) )
""")
pre = Population(6, neuron)
post = Population(1, neuron)
proj = Projection(pre, post, "exc",
synapse=cov).connect_all_to_all(weights=1.0)
self.test_net = Network()
self.test_net.add([pre, post, proj])
self.test_net.compile(silent=True)
self.net_pop = self.test_net.get(post)
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 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
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
"""
def my_diagonal(pre, post, weight):
synapses = CSR()
for post_rk in post.ranks:
pre_ranks = []
delays = []
if post_rk - 1 in pre.ranks:
pre_ranks.append(post_rk - 1)
if post_rk in pre.ranks:
pre_ranks.append(post_rk)
if post_rk + 1 in pre.ranks:
pre_ranks.append(post_rk + 1)
synapses.add(post_rk, pre_ranks, [weight] * len(pre_ranks),
[0] * len(pre_ranks))
return synapses
def my_diagonal_with_uniform_delay(pre, post, weight, delay):
synapses = CSR()
for post_rk in post.ranks:
pre_ranks = []
delays = []
if post_rk - 1 in pre.ranks:
pre_ranks.append(post_rk - 1)
if post_rk in pre.ranks:
pre_ranks.append(post_rk)
if post_rk + 1 in pre.ranks:
pre_ranks.append(post_rk + 1)
synapses.add(post_rk, pre_ranks, [weight] * len(pre_ranks),
[delay] * len(pre_ranks))
return synapses
def my_diagonal_with_non_uniform_delay(pre, post, weight, delay):
synapses = CSR()
for post_rk in post.ranks:
pre_ranks = []
delays = []
if post_rk - 1 in pre.ranks:
pre_ranks.append(post_rk - 1)
if post_rk in pre.ranks:
pre_ranks.append(post_rk)
if post_rk + 1 in pre.ranks:
pre_ranks.append(post_rk + 1)
synapses.add(post_rk, pre_ranks, [weight] * len(pre_ranks),
delay.get_values(len(pre_ranks)))
return synapses
neuron = Neuron(equations="r = 1")
neuron2 = Neuron(equations="r = sum(exc)")
pop1 = Population(5, neuron)
pop2 = Population(5, neuron2)
proj1 = Projection(pre=pop1, post=pop2, target="exc")
proj1.connect_with_func(method=my_diagonal, weight=0.1)
proj2 = Projection(pre=pop1, post=pop2, target="exc2")
proj2.connect_with_func(method=my_diagonal_with_uniform_delay,
weight=0.1,
delay=2)
proj3 = Projection(pre=pop1, post=pop2, target="exc3")
proj3.connect_with_func(method=my_diagonal_with_non_uniform_delay,
weight=0.1,
delay=DiscreteUniform(1, 5))
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)
equations="""
v_old = v_new
tau * dv/dt = 1.0 - cos(v_old) + (1.0 + cos(v_old))*(eta + J*g_syn*tau) : init=6.2832, min=0.0
tau_s * dg_syn/dt = g_exc*tau_s - g_syn
v_tmp = v/(2*pi) : int
v_new = (v/(2*pi) - v_tmp)*2*pi
""",
spike="(v_new > pi)*(v_old < pi)")
# population setup
pop1 = Population(N, neuron=Theta, name="ThetaPop1")
pop1.eta = eta + D * np.tan(
(np.pi / 2) * (2 * np.arange(1, N + 1) - N - 1) / (N + 1))
# projection setup
proj = Projection(pre=pop1, post=pop1, target='exc', name='fb')
proj.connect_all_to_all(100.0 / N, allow_self_connections=False)
# monitoring
obs = Monitor(pop1, variables=['spike', 'v_new'], start=True, period=0.01)
# simulation
compile()
simulate(duration=T)
# conversion to pyrates
theta = pyrates_from_annarchy(monitors=[obs],
vars=['v_new'],
pop_average=False)
rate = pyrates_from_annarchy(monitors=[obs], vars=['spike'], pop_average=True)
## Connection of the V4 Populations, L2/3 => L4 (spatial supp.) # A difference of Gaussians is used as weight wPos = Gaussian2D(1.0, [13, 13], [3, 3]) wNeg = Gaussian2D(2.0, [13, 13], [1.0, 1.0]) wDoG = (positive(wPos - wNeg) / np.sum(positive(wPos - wNeg)))[:, :, None] #V4L23_V4L4SUR = Convolution(V4L23, V4L4, target='S_SUR')####################################NEW #V4L23_V4L4SUR.connect_filter(weights=wDoG, subsampling=ssList24, keep_last_dimension=True)##NEW ## Connection from V4 L2/3 to FEF visual (excitatory) # The auxiliary population is used to pool the down-sampled V4L23 Population. # Afterwards it could be up-sampled again. The combination of the two is # currently not possible in ANNarchy ssList2v = ssList24[9::params['V4L4_shape'][-1]] V4L23_AuxE = Pooling(V4L23, AuxE, target='exc', operation='max') V4L23_AuxE.connect_pooling(extent=(1, 1) + params['PFC_shape']) AuxE_FEFv = Projection(AuxE, FEFv, target='exc', synapse=StandardSynapse) AuxE_FEFv.connect_with_func(con_scale, factor=2, delays=params['FEFv_delay']) ## Connections from FEF visual to FEF visuo-motoric(excitatory and suppressive) # A lowered Gaussian is used to simulate the combined responses G = Gaussian2D(1.0, changed['RFsizev_vm'], changed['RFsigmav_vm']) v_vm_shape = (params['FEFvm_shape'][-1], 1, 1) wvvm = np.tile((G - params['vSv2'])[None, :, :], v_vm_shape) wvvm *= params['dogScalingFactor_FEFvm']**np.arange(6)[:, None, None] # The plus sign(+) is needed, so that wvvm will not be overwritten FEFv_FEFvmE = Convolution(FEFv, FEFvm, target='E_v') FEFv_FEFvmE.connect_filters(weights=positive(+wvvm)) FEFv_FEFvmS = Convolution(FEFv, FEFvm, target='S_v') FEFv_FEFvmS.connect_filters(weights=positive(-wvvm)) ## Connection from FEF visuo-motoric to V4 L4 (amplification)
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
import unittest
import numpy
from ANNarchy import Izhikevich, Population, Projection, Network
pop1 = Population((3, 3), Izhikevich)
pop2 = Population((3, 3), Izhikevich)
proj = Projection(
pre = pop1,
post = pop2,
target = "exc",
)
proj.connect_all_to_all(weights = 0.1, storage_format="csr")
# TODO: PopulationViews
class test_CSRConnectivity(unittest.TestCase):
"""
This class tests the functionality of the connectivity patterns within *Projections*.
"""
@classmethod
def setUpClass(self):
"""
Compile the network for this test
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
import unittest
import numpy
from ANNarchy import Izhikevich, Population, Projection, Network
pop1 = Population((3, 3), Izhikevich)
pop2 = Population((3, 3), Izhikevich)
proj = Projection(
pre=pop1,
post=pop2,
target="exc",
)
proj.connect_all_to_all(weights=0.1, storage_format="csr")
# TODO: PopulationViews
class test_CSRConnectivity(unittest.TestCase):
"""
This class tests the functionality of the connectivity patterns within *Projections*.
"""
@classmethod
def setUpClass(self):
"""
GPe = Population(name='GPe', geometry=nBG, neuron=LinearNeuron)
GPe.phi = changed['noise_GPe']
GPe.B = params['baseline_GPe']
# MD
MD = Population(name='MD', geometry=nBG, neuron=LinearNeuron)
MD.phi = changed['noise_MD']
MD.B = changed['baseline_MD']
#####################################################
######## PROJECTIONS ##############################
#####################################################
############# FROM INPUT #############
ITPFC = Projection(pre=IT, post=PFC, target='exc', synapse=PostCovariance)
ITPFC.connect_all_to_all(
weights=changed['ITPFC.connect_all_to_all']) #Normal(0.3,0.1) )
ITStrD1 = Projection(pre=IT,
post=StrD1,
target='exc',
synapse=DAPostCovarianceNoThreshold)
ITStrD1.connect_all_to_all(weights=Uniform(0, 0.3)) #Normal(0.15,0.15))
ITStrD2 = Projection(pre=IT,
post=StrD2,
target='exc',
synapse=DAPostCovarianceNoThreshold)
ITStrD2.connect_all_to_all(weights=Uniform(0, 0.3)) #Normal(0.15,0.15))
ITStrD2.DA_type = -1
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)
def setUpClass(cls):
"""
Define and compile the network for this test.
"""
input_neuron = Neuron(parameters="r=0.0")
output_neuron = Neuron(equations="""
r = sum(p1) + sum(p2)
""")
syn_max = Synapse(psp="pre.r * w", operation="max")
syn_min = Synapse(psp="pre.r * w", operation="min")
syn_mean = Synapse(psp="pre.r * w", operation="mean")
pop1 = Population((3, 3), neuron=input_neuron)
pop2 = Population(4, neuron=output_neuron)
proj1 = Projection(pop1, pop2, target="p1", synapse=syn_max)
proj1.connect_all_to_all(weights=1.0)
proj2 = Projection(pop1, pop2, target="p2", synapse=syn_min)
proj2.connect_all_to_all(weights=1.0)
proj3 = Projection(pop1, pop2, target="p3", synapse=syn_mean)
proj3.connect_all_to_all(weights=1.0)
cls.test_net = Network()
cls.test_net.add([pop1, pop2, proj1, proj2, proj3])
cls.test_net.compile(silent=True)
cls.net_pop1 = cls.test_net.get(pop1)
cls.net_pop2 = cls.test_net.get(pop2)
def setUpClass(cls):
"""
Build up the network
"""
simple_emit = Neuron(spike="t==1", )
simple_recv = Neuron(equations="""
g_exc1 = 0
g_exc2 = 0
g_exc3 = 0
""",
spike="g_exc1>30")
# simple in/out populations
in_pop = Population(5, neuron=simple_emit)
out_pop = Population(2, neuron=simple_recv)
# create the projections for the test cases (TC)
# TC: no delay
proj = Projection(pre=in_pop, post=out_pop, target="exc1")
proj.connect_all_to_all(weights=1.0)
# TC: uniform delay
proj_u = Projection(pre=in_pop, post=out_pop, target="exc2")
proj_u.connect_all_to_all(weights=1.0, delays=2.0)
# TC: non-uniform delay
proj_nu = Projection(pre=in_pop, post=out_pop, target="exc3")
proj_nu.connect_all_to_all(weights=1.0, delays=Uniform(2, 10))
# Monitor to record the currents
m = Monitor(out_pop, ["g_exc1", "g_exc2", "g_exc3"])
# build network and store required object
# instances
net = Network()
net.add([in_pop, out_pop, proj, proj_u, proj_nu, m])
cls.test_net = net
cls.test_net.compile(silent=True)
cls.test_g_exc_m = net.get(m)
cls.test_proj = net.get(proj_nu)
tau_m * dv/dt = (v_rest - v + delta_T * exp((v-v_thresh)/delta_T)) + tau_m/cm*(I - w) : init=-70.6
tau_w * dw/dt = a * (v - v_rest) / 1000.0 - w
tau_syn_E * dg_exc/dt = - g_exc : exponential
tau_syn_I * dg_inh/dt = - g_inh : exponential
"""
# population setup
pop = Population(Ne + Ni, neuron=neuron)
E = pop[:Ne]
I = pop[Ne:]
# projection setup
C_ei = Projection(pre=E, post=I, target='exc', name='EI')
C_ie = Projection(pre=I, post=E, target='inh', name='IE')
#C_ee = Projection(E, E, 'exc', name='EE')
#C_ii = Projection(I, I, 'inh', name='II')
C_ei.connect_fixed_probability(0.1, weights=Uniform(c_min, c_max))
C_ie.connect_fixed_probability(0.1, weights=Uniform(c_min, c_max))
#C_ee.connect_fixed_probability(0.3, weights=Uniform(c_min, c_max))
#C_ii.connect_fixed_probability(0.3, weights=Uniform(c_min, c_max))
# input
#steps = int(T/dt)
#I_e_tmp = 5.0 + np.random.randn(steps, Ne) * 50.0 * np.sqrt(dt) # input current for excitatory neurons
#I_i_tmp = 4.0 + np.random.randn(steps, Ni) * 44.0 * np.sqrt(dt) # input current for inhibitory neurons
#I_e = TimedArray(rates=I_e_tmp, name="E_inp")
#I_i = TimedArray(rates=I_i_tmp, name="I_inp")
#inp_e = Projection(pre=I_e, post=E, target='exc')
