def testRandomizeDelays(self):
# The probability of having two consecutive delays vector that are equal should be 0
prj1 = neuron.Projection(self.source, self.target,
neuron.AllToAllConnector())
prj2 = neuron.Projection(self.source, self.target,
neuron.AllToAllConnector())
prj1.randomizeDelays(self.distrib_Numpy)
prj2.randomizeDelays(self.distrib_Native)
d1 = []
d2 = []
d3 = []
d4 = []
hoc_list1 = getattr(h, prj1.hoc_label)
hoc_list2 = getattr(h, prj2.hoc_label)
for connection_id in prj1.connections:
#d1.append(HocToPy.get('%s.object(%d).delay' % (prj1.hoc_label, prj1.connections.index(connection_id))))
#d2.append(HocToPy.get('%s.object(%d).delay' % (prj2.hoc_label, prj1.connections.index(connection_id))))
d1.append(
hoc_list1.object(prj1.connections.index(connection_id)).delay)
d2.append(
hoc_list2.object(prj2.connections.index(connection_id)).delay)
prj1.randomizeDelays(self.distrib_Numpy)
prj2.randomizeDelays(self.distrib_Native)
for connection_id in prj1.connections:
#d3.append(HocToPy.get('%s.object(%d).delay' % (prj1.hoc_label, prj1.connections.index(connection_id))))
#d4.append(HocToPy.get('%s.object(%d).delay' % (prj2.hoc_label, prj1.connections.index(connection_id))))
d3.append(
hoc_list1.object(prj1.connections.index(connection_id)).delay)
d4.append(
hoc_list2.object(prj2.connections.index(connection_id)).delay)
self.assertNotEqual(d1, d3) and self.assertNotEqual(d2, d4)
def testRandomizeWeights(self):
# The probability of having two consecutive weights vector that are equal should be 0
prj1 = neuron.Projection(self.source, self.target,
neuron.AllToAllConnector())
prj2 = neuron.Projection(self.source, self.target,
neuron.AllToAllConnector())
prj1.randomizeWeights(self.distrib_Numpy)
prj2.randomizeWeights(self.distrib_Native)
w1 = []
w2 = []
w3 = []
w4 = []
hoc_list1 = getattr(h, prj1.hoc_label)
hoc_list2 = getattr(h, prj2.hoc_label)
for connection_id in prj1.connections:
#w1.append(HocToPy.get('%s.object(%d).weight' % (prj1.hoc_label, prj1.connections.index(connection_id))))
#w2.append(HocToPy.get('%s.object(%d).weight' % (prj2.hoc_label, prj1.connections.index(connection_id))))
w1.append(
hoc_list1.object(
prj1.connections.index(connection_id)).weight[0])
w2.append(
hoc_list2.object(
prj2.connections.index(connection_id)).weight[0])
prj1.randomizeWeights(self.distrib_Numpy)
prj2.randomizeWeights(self.distrib_Native)
for connection_id in prj1.connections:
#w3.append(HocToPy.get('%s.object(%d).weight' % (prj1.hoc_label, prj1.connections.index(connection_id))))
#w4.append(HocToPy.get('%s.object(%d).weight' % (prj2.hoc_label, prj1.connections.index(connection_id))))
w3.append(
hoc_list1.object(
prj1.connections.index(connection_id)).weight[0])
w4.append(
hoc_list2.object(
prj2.connections.index(connection_id)).weight[0])
self.assertNotEqual(w1, w3) and self.assertNotEqual(w2, w4)
def testFixedNumberPost(self):
c1 = neuron.FixedNumberPostConnector(10)
c2 = neuron.FixedNumberPostConnector(3)
c3 = neuron.FixedNumberPostConnector(
random.RandomDistribution('poisson', [5]))
for srcP in [self.source5, self.source22]:
for tgtP in [self.target6, self.target33]:
for c in c1, c2:
prj1 = neuron.Projection(srcP, tgtP, c)
self.assertEqual(len(prj1.connections), c.n * len(srcP))
prj2 = neuron.Projection(
srcP, tgtP,
c3) # just a test that no Exceptions are raised
def testFixedProbability(self):
"""For all connections created with "fixedProbability"..."""
for srcP in [self.source5, self.source22]:
for tgtP in [self.target6, self.target33]:
prj2 = neuron.Projection(srcP,
tgtP,
FixedProbabilityConnector(0.5),
rng=NativeRNG(12345))
prj3 = neuron.Projection(srcP,
tgtP,
FixedProbabilityConnector(0.5),
rng=NumpyRNG(12345))
assert (0 < len(prj2) < len(srcP)*len(tgtP)) \
and (0 < len(prj3) < len(srcP)*len(tgtP))
def testRandomizeDelaysWithSTDP(self):
stdp_model = neuron.STDPMechanism(
timing_dependence=neuron.SpikePairRule(tau_plus=20.0,
tau_minus=20.0),
weight_dependence=neuron.AdditiveWeightDependence(w_min=0,
w_max=2.0,
A_plus=0.1,
A_minus=0.0),
dendritic_delay_fraction=0.0)
connector = neuron.AllToAllConnector(weights=1.0, delays=2.0)
prj1 = neuron.Projection(
self.source,
self.target,
connector,
synapse_dynamics=neuron.SynapseDynamics(slow=stdp_model))
pre2wa = getattr(h, '%s_pre2wa' % prj1.hoc_label)
post2wa = getattr(h, '%s_post2wa' % prj1.hoc_label)
nc_list = getattr(h, prj1.hoc_label)
assert pre2wa[0].delay == 2.0
assert post2wa[0].delay == 0.0
prj1.randomizeDelays(self.distrib_Native)
assert pre2wa[
0].delay != 2.0 # check it is equal to the actual synaptic delay
assert post2wa[0].delay == 0.0
delay0 = nc_list.object(0).delay
assert pre2wa[0].delay == delay0
prj1.randomizeDelays(self.distrib_Numpy)
assert pre2wa[
0].delay != delay0 # check it is equal to the actual synaptic delay
assert post2wa[0].delay == 0.0
assert pre2wa[0].delay == nc_list.object(0).delay
def testSettingDelays(self):
"""Delays should be set correctly when using a Connector object."""
for srcP in [self.source5, self.source22]:
for tgtP in [self.target6, self.target33]:
prj1 = neuron.Projection(
srcP, tgtP, neuron.AllToAllConnector(delays=0.321))
hoc_list = getattr(neuron.h, prj1.hoc_label)
assert hoc_list.object(
0
).delay == 0.321, "Delay should be 0.321, actually %g" % hoc_list.object(
0).delay
def testAllToAll(self):
"""For all connections created with "allToAll" it should be possible to
obtain the weight using the top-level HocObject"""
for srcP in [self.source5, self.source22]:
for tgtP in [self.target6, self.target33]:
prj1 = neuron.Projection(srcP, tgtP,
neuron.AllToAllConnector())
prj2 = neuron.Projection(srcP, tgtP,
neuron.AllToAllConnector())
prj1.setWeights(1.234)
prj2.setWeights(1.234)
for prj in prj1, prj2:
hoc_list = getattr(h, prj.hoc_label)
weights = []
for connection_id in prj.connections:
weights.append(
hoc_list.object(
prj.connections.index(
connection_id)).weight[0])
assert weights == [1.234] * len(prj)
def testSaveAndLoad(self):
prj1 = neuron.Projection(self.source33, self.target33,
neuron.OneToOneConnector())
prj1.setDelays(1)
prj1.setWeights(1.234)
prj1.saveConnections("connections.tmp", gather=False)
#prj2 = neuron.Projection(self.source33, self.target33, 'fromFile',"connections.tmp")
if neuron.num_processes() > 1:
distributed = True
else:
distributed = False
prj3 = neuron.Projection(
self.source33, self.target33,
neuron.FromFileConnector("connections.tmp",
distributed=distributed))
w1 = []
w2 = []
w3 = []
d1 = []
d2 = []
d3 = []
# For a connections scheme saved and reloaded, we test if the connections, their weights and their delays
# are equal.
hoc_list1 = getattr(h, prj1.hoc_label)
#hoc_list2 = getattr(h, prj2.hoc_label)
hoc_list3 = getattr(h, prj3.hoc_label)
for connection_id in prj1.connections:
w1.append(
hoc_list1.object(
prj1.connections.index(connection_id)).weight[0])
#w2.append(hoc_list2.object(prj2.connections.index(connection_id)).weight[0])
w3.append(
hoc_list3.object(
prj3.connections.index(connection_id)).weight[0])
d1.append(
hoc_list1.object(prj1.connections.index(connection_id)).delay)
#d2.append(hoc_list2.object(prj2.connections.index(connection_id)).delay)
d3.append(
hoc_list3.object(prj3.connections.index(connection_id)).delay)
#assert (w1 == w2 == w3) and (d1 == d2 == d3)
assert (w1 == w3) and (d1 == d3)
def testSetDelays(self):
prj1 = neuron.Projection(self.source, self.target,
neuron.AllToAllConnector())
prj1.setDelays(2.345)
delays = []
hoc_list = getattr(h, prj1.hoc_label)
for connection_id in prj1.connections:
#delays.append(HocToPy.get('%s.object(%d).delay' % (prj1.hoc_label, prj1.connections.index(connection_id))))
delays.append(
hoc_list.object(prj1.connections.index(connection_id)).delay)
result = 2.345 * numpy.ones(len(prj1.connections))
assert (delays == result.tolist())
def testDistanceDependentProbability(self):
"""For all connections created with "distanceDependentProbability"..."""
# Test should be improved..."
for rngclass in (NumpyRNG, NativeRNG):
for expr in ('exp(-d)', 'd < 0.5'):
prj = neuron.Projection(
self.source33,
self.target33,
neuron.DistanceDependentProbabilityConnector(
d_expression=expr),
rng=rngclass(12345))
assert (0 < len(prj) < len(self.source33) * len(self.target33))
def testSetTopographicDelay(self):
# We fix arbitrarily the positions of 2 cells in 2 populations and check
# the topographical delay between them is linked to the distance
self.source[0, 0].position = (0, 0, 0)
self.target[2, 2].position = (0, 10, 0)
prj1 = neuron.Projection(self.source, self.target,
neuron.AllToAllConnector())
rule = "5.432*d"
prj1.setTopographicDelays(rule)
hoc_list = getattr(h, prj1.hoc_label)
for connection_id in range(len(prj1.connections)):
src = prj1.connections[connection_id][0]
tgt = prj1.connections[connection_id][1]
if (src == self.source[0, 0]) and (tgt == self.target[2, 2]):
delay = hoc_list.object(
prj1.connections.index(
prj1.connections[connection_id])).delay
assert (delay == 54.32), delay
def testSTDP(self):
self.target.record()
self.source.record()
self.target.record_v()
stdp_model = neuron.STDPMechanism(
timing_dependence=neuron.SpikePairRule(tau_plus=20.0,
tau_minus=20.0),
weight_dependence=neuron.AdditiveWeightDependence(w_min=0,
w_max=2.0,
A_plus=0.1,
A_minus=0.0),
dendritic_delay_fraction=0.0)
connector = neuron.AllToAllConnector(weights=1.0, delays=2.0)
prj1 = neuron.Projection(
self.source,
self.target,
connector,
synapse_dynamics=neuron.SynapseDynamics(slow=stdp_model))
#prj1.setDelays(2)
#prj1.setWeights(1.0)
mean_weight_before = 0
hoc_list = getattr(h, prj1.hoc_label)
for connection_id in prj1.connections:
mean_weight_before += hoc_list.object(
prj1.connections.index(connection_id)).weight[0]
mean_weight_before = float(mean_weight_before / len(prj1.connections))
simtime = 100
neuron.running = False
run(simtime)
mean_weight_after = 0
self.target.print_v("tmp.v")
source_spikes = self.source.meanSpikeCount()
target_spikes = self.target.meanSpikeCount()
if neuron.myid == 0:
assert source_spikes > 0
assert target_spikes > 0
for connection_id in prj1.connections:
mean_weight_after += hoc_list.object(
prj1.connections.index(connection_id)).weight[0]
mean_weight_after = float(mean_weight_after / len(prj1.connections))
assert (mean_weight_before < mean_weight_after
), "%g !< %g" % (mean_weight_before, mean_weight_after)
def testSetDelaysWithSTDP(self):
stdp_model = neuron.STDPMechanism(
timing_dependence=neuron.SpikePairRule(tau_plus=20.0,
tau_minus=20.0),
weight_dependence=neuron.AdditiveWeightDependence(w_min=0,
w_max=2.0,
A_plus=0.1,
A_minus=0.0),
dendritic_delay_fraction=0.0)
connector = neuron.AllToAllConnector(weights=1.0, delays=2.0)
prj1 = neuron.Projection(
self.source,
self.target,
connector,
synapse_dynamics=neuron.SynapseDynamics(slow=stdp_model))
pre2wa = getattr(h, '%s_pre2wa' % prj1.hoc_label)
post2wa = getattr(h, '%s_post2wa' % prj1.hoc_label)
assert pre2wa[0].delay == 2.0
assert post2wa[0].delay == 0.0
prj1.setDelays(3.0)
assert pre2wa[0].delay == 3.0
assert post2wa[0].delay == 0.0
def testOneToOne(self):
"""For all connections created with "OneToOne" ..."""
prj = neuron.Projection(self.source33, self.target33,
neuron.OneToOneConnector())
assert len(prj.connections) == len(
self.target33.gidlist), prj.connections
