def testRSetNative2(self):
"""Population.rset(): with native rng."""
rd1 = random.RandomDistribution(rng=random.NativeRNG(seed=98765),
distribution='uniform',
parameters=[0.9, 1.1])
rd2 = random.RandomDistribution(rng=random.NativeRNG(seed=98765),
distribution='uniform',
parameters=[0.9, 1.1])
self.net.rset('cm', rd1)
output_values_1 = numpy.zeros((3, 3), numpy.float)
output_values_2 = numpy.zeros((3, 3), numpy.float)
hoc_net = getattr(h, self.net.label)
print hoc_net.count()
for i in 0, 1, 2:
for j in 0, 1, 2:
id = 3 * i + j
if id in self.net.gidlist:
list_index = self.net.gidlist.index(id)
output_values_1[i, j] = hoc_net.object(list_index).cell(
0.5).cm
self.net.rset('cm', rd2)
for i in 0, 1, 2:
for j in 0, 1, 2:
id = 3 * i + j
if id in self.net.gidlist:
list_index = self.net.gidlist.index(id)
output_values_2[i, j] = hoc_net.object(list_index).cell(
0.5).cm
output_values_1 = output_values_1.reshape((9, ))
output_values_2 = output_values_2.reshape((9, ))
for i in range(9):
self.assertAlmostEqual(output_values_1[i],
output_values_2[i],
places=5)
def setUp(self):
setup()
self.target = Population((3,3),IF_curr_alpha)
self.target = Population((3,3),IF_curr_alpha)
self.source = Population((3,3),SpikeSourcePoisson,{'rate': 100})
self.distrib_Numpy = random.RandomDistribution('uniform',(0,1),random.NumpyRNG(12345))
self.distrib_Native= random.RandomDistribution('Uniform',(0,1),NativeRNG(12345))
def test_boundaries(self):
rd = random.RandomDistribution(distribution='uniform',
parameters=[-1.0, 1.0],
rng=self.rnglist[0],
boundaries=[0.0, 1.0],
constrain="clip")
vals = rd.next(1000)
assert vals.min() == 0
assert vals.max() < 1.0
assert abs(vals.mean() - 0.25) < 0.05
rd = random.RandomDistribution(distribution='uniform',
parameters=[-1.0, 1.0],
rng=self.rnglist[0],
boundaries=[0.0, 1.0],
constrain="redraw")
vals = rd.next(1000)
assert vals.min() >= 0
assert vals.max() < 1.0
assert abs(vals.mean() - 0.5) < 0.05, vals.mean()
val = rd.next(1)
rd = random.RandomDistribution(distribution='uniform',
parameters=[-1.0, 1.0],
rng=self.rnglist[0],
boundaries=[0.0, 1.0],
constrain=None)
self.assertRaises(Exception, rd.next)
def test_columnwise_iteration_with_random_array_parallel_safe_with_mask():
orig_get_mpi_config = random.get_mpi_config
mask = np.array([False, False, True])
# first, with a single MPI node
random.get_mpi_config = lambda: (0, 2)
input = random.RandomDistribution('uniform', (0, 1),
rng=MockRNG(parallel_safe=True))
m = LazyArray(input, shape=(4, 3))
cols_np1 = [col for col in m.by_column(mask=mask)]
# now, on one node of two
random.get_mpi_config = lambda: (0, 2)
input = random.RandomDistribution('uniform', (0, 1),
rng=MockRNG(parallel_safe=True))
m = LazyArray(input, shape=(4, 3))
cols_np2_0 = [col for col in m.by_column(mask=mask)]
# now, on the other node of two
random.get_mpi_config = lambda: (1, 2)
input = random.RandomDistribution('uniform', (0, 1),
rng=MockRNG(parallel_safe=True))
m = LazyArray(input, shape=(4, 3))
cols_np2_1 = [col for col in m.by_column(mask=mask)]
assert_equal(len(cols_np1), 1)
assert_equal(len(cols_np2_0), 1)
assert_equal(len(cols_np2_1), 1)
assert_array_equal(cols_np1[0], cols_np2_0[0])
random.get_mpi_config = orig_get_mpi_config
def testRSetNumpy(self):
"""Population.rset(): with numpy rng."""
rd1 = random.RandomDistribution(rng=random.NumpyRNG(seed=98765),
distribution='uniform',
parameters=[0.9, 1.1])
rd2 = random.RandomDistribution(rng=random.NumpyRNG(seed=98765),
distribution='uniform',
parameters=[0.9, 1.1])
self.net.rset('cm', rd1)
output_values = numpy.zeros((3, 3), numpy.float)
hoc_net = getattr(h, self.net.label)
for i in 0, 1, 2:
for j in 0, 1, 2:
id = 3 * i + j
if id in self.net.gidlist:
list_index = self.net.gidlist.index(id)
output_values[i,
j] = hoc_net.object(list_index).cell(0.5).cm
input_values = rd2.next(9)
output_values = output_values.reshape((9, ))
for i in range(9):
if i in self.net.gidlist:
self.assertAlmostEqual(input_values[i],
output_values[i],
places=5)
def testDistantDependentProbability(self):
"""For all connections created with "distanceDependentProbability" ..."""
# Test should be improved..."
distrib_Numpy = random.RandomDistribution('uniform',(0,1),random.NumpyRNG(12345))
distrib_Native= random.RandomDistribution('Uniform',(0,1),NativeRNG(12345))
prj1 = Projection(self.source33, self.target33, DistanceDependentProbabilityConnector([ 0.1, 2]), distrib_Numpy)
prj2 = Projection(self.source33, self.target33, DistanceDependentProbabilityConnector([ 0.1, 3]), distrib_Native)
assert (0 < len(prj1) < len(self.source33)*len(self.target33)) and (0 < len(prj2) < len(self.source33)*len(self.target33))
def test_columnwise_iteration_with_random_array_parallel_safe_no_mask():
random.mpi_rank = 0
random.num_processes = 2
input = random.RandomDistribution(rng=MockRNG(parallel_safe=True))
copy_input = random.RandomDistribution(rng=MockRNG(parallel_safe=True))
m = LazyArray(input, shape=(4, 3))
cols = [col for col in m.by_column()]
assert_array_equal(cols[0], copy_input.next(4, mask_local=False))
assert_array_equal(cols[1], copy_input.next(4, mask_local=False))
assert_array_equal(cols[2], copy_input.next(4, mask_local=False))
def test_columnwise_iteration_with_random_array_parallel_safe_with_mask():
random.mpi_rank = 0
random.num_processes = 2
input = random.RandomDistribution(rng=MockRNG(parallel_safe=True))
copy_input = random.RandomDistribution(rng=MockRNG(parallel_safe=True))
m = LazyArray(input, shape=(4, 3))
mask = np.array([False, False, True])
cols = [col for col in m.by_column(mask=mask)]
assert_equal(len(cols), 1)
assert_array_almost_equal(cols[0],
copy_input.next(12, mask_local=False)[8:], 15)
def test_columnwise_iteration_with_random_array_parallel_safe_no_mask():
orig_get_mpi_config = random.get_mpi_config
random.get_mpi_config = lambda: (0, 2)
input = random.RandomDistribution(rng=MockRNG(parallel_safe=True))
copy_input = random.RandomDistribution(rng=MockRNG(parallel_safe=True))
m = LazyArray(input, shape=(4, 3))
cols = [col for col in m.by_column()]
assert_array_equal(cols[0], copy_input.next(4, mask_local=False))
assert_array_equal(cols[1], copy_input.next(4, mask_local=False))
assert_array_equal(cols[2], copy_input.next(4, mask_local=False))
random.get_mpi_config = orig_get_mpi_config
def test_columnwise_iteration_with_random_array_parallel_safe_with_mask():
orig_get_mpi_config = random.get_mpi_config
random.get_mpi_config = lambda: (0, 2)
input = random.RandomDistribution('uniform', (0, 1), rng=MockRNG(parallel_safe=True))
copy_input = random.RandomDistribution('gamma', (2, 3), rng=MockRNG(parallel_safe=True))
m = LazyArray(input, shape=(4, 3))
mask = np.array([False, False, True])
cols = [col for col in m.by_column(mask=mask)]
assert_equal(len(cols), 1)
assert_array_almost_equal(cols[0], copy_input.next(12, mask_local=False)[8:], 15)
random.get_mpi_config = orig_get_mpi_config
def testRSetNumpy(self):
"""Population.rset(): with numpy rng."""
rd1 = random.RandomDistribution(rng=random.NumpyRNG(seed=98765),
distribution='uniform',
parameters=[0.9,1.1])
rd2 = random.RandomDistribution(rng=random.NumpyRNG(seed=98765),
distribution='uniform',
parameters=[0.9,1.1])
self.net.rset('cm', rd1)
output_values = self.net.get('cm', as_array=True)
input_values = rd2.next(9).reshape(self.net.dim)
assert numpy.equal(input_values, output_values).all()
def testRSetNumpy(self):
"""Population.rset(): with numpy rng."""
rd1 = random.RandomDistribution(rng=random.NumpyRNG(seed=98765),
distribution='uniform',
parameters=[0.9, 1.1])
rd2 = random.RandomDistribution(rng=random.NumpyRNG(seed=98765),
distribution='uniform',
parameters=[0.9, 1.1])
self.net.rset('cm', rd1)
output_values = self.net.get('cm', as_array=True)
input_values = rd2.next(9)
for i in range(9):
self.assertAlmostEqual(input_values[i], output_values[i], places=5)
def test_uniform(self):
rd = random.RandomDistribution(distribution='uniform', parameters=[-1.0, 3.0], rng=self.rnglist[0])
vals = rd.next(100)
assert vals.min() >= -1.0
assert vals.max() < 3.0
assert abs(vals.mean() - 1.0) < 0.2
if random.have_gsl:
# GSL uniform is always between 0 and 1
rd = random.RandomDistribution(distribution='uniform', parameters=[], rng=self.rnglist[1])
vals = rd.next(100)
assert vals.min() >= 0.0
assert vals.max() < 1.0
assert abs(vals.mean() - 0.5) < 0.05
def test_gaussian(self):
mean = 1.0
std = 1.0
rd1 = random.RandomDistribution(distribution='normal', parameters=[mean, std], rng=self.rnglist[0])
vals_list = [rd1.next(100)]
if random.have_gsl:
# GSL gaussian is always centred on zero
rd2 = random.RandomDistribution(distribution='gaussian', parameters=[std], rng=self.rnglist[1])
vals_list.append(mean + rd2.next(100))
for vals in vals_list:
assert vals.min() > mean-4*std
assert vals.min() < mean+4*std
assert abs(vals.mean() - mean) < 0.2, abs(vals.mean() - mean)
def test_boundaries(self):
rd = random.RandomDistribution('normal_clipped_to_boundary',
mu=0, sigma=1, low=-0.5, high=0.5,
rng=self.rnglist[0])
vals = rd.next(1000)
assert vals.min() == -0.5
assert vals.max() == 0.5
assert abs(vals.mean()) < 0.05, vals.mean()
rd = random.RandomDistribution(distribution='normal_clipped',
mu=0, sigma=1, low=0, high=1,
rng=self.rnglist[0])
vals = rd.next(1000)
assert vals.min() >= 0
assert vals.max() < 1.0
def test_connect_with_random_weights_parallel_safe(self):
rd_w = random.RandomDistribution(rng=MockRNG(delta=1.0, parallel_safe=True))
rd_d = random.RandomDistribution(rng=MockRNG(start=1.0, delta=0.1, parallel_safe=True))
syn = sim.StaticSynapse(weight=rd_w, delay=rd_d)
connections = numpy.array([
[0, 1, 1, 0],
[1, 1, 0, 1],
[0, 0, 1, 0],
])
C = connectors.ArrayConnector(connections, safe=False)
prj = sim.Projection(self.p1, self.p2, C, syn)
self.assertEqual(prj.get(["weight", "delay"], format='list', gather=False), # use gather False because we are faking the MPI
[(1, 0, 0.0, 1.0),
(0, 2, 3.0, 1.3),
(2, 2, 4.0, 1.4000000000000001)]) # better to do an "almost-equal" check
def test_connect_with_random_weights_parallel_safe(self, sim=sim):
rd = random.RandomDistribution(
'uniform', (0, 1), rng=MockRNG(delta=1.0, parallel_safe=True))
syn = sim.StaticSynapse(weight=rd, delay=0.5)
C = connectors.AllToAllConnector(safe=False)
prj = sim.Projection(self.p1, self.p2, C, syn)
# note that the outer loop is over the post-synaptic cells, the inner loop over the pre-synaptic
self.assertEqual(prj.get(["weight", "delay"], format='list'),
[(0, 0, 0.0, 0.5),
(1, 0, 1.0, 0.5),
(2, 0, 2.0, 0.5),
(3, 0, 3.0, 0.5),
(0, 1, 4.0, 0.5),
(1, 1, 5.0, 0.5),
(2, 1, 6.0, 0.5),
(3, 1, 7.0, 0.5),
(0, 2, 8.0, 0.5),
(1, 2, 9.0, 0.5),
(2, 2, 10.0, 0.5),
(3, 2, 11.0, 0.5),
(0, 3, 12.0, 0.5),
(1, 3, 13.0, 0.5),
(2, 3, 14.0, 0.5),
(3, 3, 15.0, 0.5),
(0, 4, 16.0, 0.5),
(1, 4, 17.0, 0.5),
(2, 4, 18.0, 0.5),
(3, 4, 19.0, 0.5)])
assert_array_almost_equal(prj.get('weight', format='array'),
np.array([[0., 4., 8., 12., 16.],
[1., 5., 9., 13., 17.],
[2., 6., 10., 14., 18.],
[3., 7., 11., 15., 19.]]),
9)
def test_positional_args(self):
for rng in self.rnglist:
rd1 = random.RandomDistribution('normal', (0.5, 0.2), rng)
self.assertEqual(rd1.parameters, {'mu': 0.5, 'sigma': 0.2})
self.assertEqual(rd1.rng, rng)
self.assertRaises(ValueError, random.RandomDistribution, 'normal', (0.5,))
self.assertRaises(ValueError, random.RandomDistribution, 'normal', (0.5, 0.2), mu=0.5, sigma=0.2)
def testRSetNative(self):
self.popul1.rset('tau_m',
random.RandomDistribution(rng=NativeRNG(),
distribution='Uniform',
parameters=[10.0, 30.0]))
self.assertNotEqual(simulator.net.object(self.popul1.getObjectID(3)).taum,
simulator.net.object(self.popul1.getObjectID(6)).taum)
def __init__(self,
projection,
weights=0.0,
delays=None,
allow_self_connections=True,
space=Space(),
safe=True):
Connector.__init__(self, weights, delays, space, safe)
if isinstance(projection.rng, random.NativeRNG):
raise Exception("Use of NativeRNG not implemented.")
else:
self.rng = projection.rng
self.N = projection.pre.size
idx = numpy.arange(self.N * rank(), self.N * (rank() + 1))
self.M = num_processes() * self.N
self.local = numpy.ones(self.N, bool)
self.local_long = numpy.zeros(self.M, bool)
self.local_long[idx] = True
self.weights_generator = WeightGenerator(weights, self.local_long,
projection, safe)
self.delays_generator = DelayGenerator(delays, self.local_long, safe)
self.probas_generator = ProbaGenerator(
random.RandomDistribution('uniform', (0, 1), rng=self.rng),
self.local_long)
self.distance_matrix = DistanceMatrix(projection.pre.positions,
self.space, self.local)
self.projection = projection
self.candidates = projection.pre.all_cells
self.allow_self_connections = allow_self_connections
def test_rset(self):
p = sim.Population(17, sim.EIF_cond_exp_isfa_ista())
pv = p[::4]
pv.set = Mock()
v_rest = random.RandomDistribution('uniform', low=-70.0, high=-60.0)
pv.rset("v_rest", v_rest)
pv.set.assert_called_with(v_rest=v_rest)
def test_rset(self):
p = sim.Population(17, sim.IF_cond_alpha())
pv = p[::4]
pv.set = Mock()
v_rest = random.RandomDistribution('uniform', [-70.0, -60.0])
pv.rset("v_rest", v_rest)
pv.set.assert_called_with(v_rest=v_rest)
def test_get_plasticity_attribute_as_list(self, sim=sim):
U_distr = random.RandomDistribution('uniform',
low=0.4,
high=0.6,
rng=MockRNG(start=0.5,
delta=0.001))
depressing = sim.TsodyksMarkramSynapse(U=U_distr,
tau_rec=lambda d: 80.0 + d,
tau_facil=0.0)
prj = sim.Projection(self.p1,
self.p2,
connector=self.all2all,
synapse_type=depressing)
U = prj.get("U", format="list")
U = _sort_by_column(U, 1)[:5]
U_target = numpy.array([
(0, 0, 0.5),
(1, 0, 0.501),
(2, 0, 0.502),
(3, 0, 0.503),
(4, 0, 0.504),
])
assert_array_equal(U, U_target)
tau_rec = prj.get("tau_rec", format="list")
tau_rec = _sort_by_column(tau_rec, 1)[:5]
tau_rec_target = numpy.array([
(0, 0, 80),
(1, 0, 81),
(2, 0, 82),
(3, 0, 83),
(4, 0, 84),
])
assert_array_equal(tau_rec, tau_rec_target)
def testRSetNative2(self):
"""Population.rset(): with native rng."""
rd1 = random.RandomDistribution(rng=random.NativeRNG(seed=98765),
distribution='uniform',
parameters=[0.9,1.1])
rd2 = random.RandomDistribution(rng=random.NativeRNG(seed=98765),
distribution='uniform',
parameters=[0.9,1.1])
self.net.rset('cm', rd1)
output_values_1 = numpy.zeros((3,3), numpy.float)
for i in 0,1,2:
for j in 0,1,2:
id = self.net[i,j]
output_values_1[i, j] = id._cell(0.5).cm
self.net.rset('cm', rd2)
output_values_2 = self.net.get('cm', as_array=True)
assert numpy.equal(output_values_1, output_values_2).all()
def test_connect_with_random_weights(self):
rd = random.RandomDistribution(rng=MockRNG(delta=1.0))
syn = sim.StaticSynapse(weight=rd, delay=0.5)
C = connectors.OneToOneConnector(safe=False)
prj = sim.Projection(self.p1, self.p2, C, syn)
self.assertEqual(prj.get(["weight", "delay"], format='list', gather=False), # use gather False because we are faking the MPI
[(1, 1, 1.0, 0.5),
(3, 3, 3.0, 0.5)])
def test_set(self):
p = sim.Population(4, sim.IF_cond_exp, {'tau_m': 12.3, 'cm': 0.987, 'i_offset': -0.21})
rng = MockRNG(start=1.21, delta=0.01, parallel_safe=True)
p.set(cm=random.RandomDistribution('uniform', rng=rng), tau_m=9.87)
tau_m, cm, i_offset = p.get(('tau_m', 'cm', 'i_offset'), gather=True)
assert_array_equal(cm, numpy.array([1.21, 1.22, 1.23, 1.24]))
assert_array_equal(tau_m, 9.87*numpy.ones((4,)))
assert_array_equal(i_offset, -0.21*numpy.ones((4,)))
def test_parameter_StaticSynapse_random_distribution(self, sim=sim):
weight = random.RandomDistribution('uniform',
low=0.005,
high=0.015,
rng=MockRNG(start=0.01,
delta=0.001))
syn = sim.StaticSynapse(weight=weight)
self.assertEqual(weight.next(), 0.01)
def test_gamma(self):
a = 2.0
b = 0.5
for rng in self.rnglist:
rd = random.RandomDistribution('gamma', k=a, theta=1 / b, rng=rng)
vals = rd.next(100)
# need to check vals are as expected
str(rd) # should be in a separate test
def test_set(self):
p = sim.Population(4, IF_cond_exp, {'tau_m': 14.0, 'v_reset': -50., 'tau_syn_E': 1.0})
rng = MockRNG(start=12.31, delta=0.01, parallel_safe=True)
p.set(tau_m=random.RandomDistribution('uniform', (0.5, 1.5), rng=rng), v_reset=-60)
tau_m, v_reset, tau_syn_E = p.get(('tau_m', 'v_reset', 'tau_syn_E'), gather=True)
assert_array_equal(tau_m, numpy.array([12.31, 12.32, 12.33, 12.34]))
assert_array_equal(v_reset, -60.0**numpy.ones((4,)))
assert_array_equal(tau_syn_E, 1.0 * numpy.ones((4,)))
def testRSetNumpy(self):
"""Population.rset(): with numpy rng."""
rd1 = random.RandomDistribution(rng=random.NumpyRNG(seed=98765),
distribution='uniform',
parameters=[0.9,1.1])
rd2 = random.RandomDistribution(rng=random.NumpyRNG(seed=98765),
distribution='uniform',
parameters=[0.9,1.1])
self.popul1.rset('cm',rd1)
output_values = numpy.zeros((3,3),numpy.float)
for i in 0,1,2:
for j in 0,1,2:
output_values[i,j] = 1e9*simulator.net.object(self.popul1.getObjectID(self.popul1[i,j])).Cm
input_values = rd2.next(9)
output_values = output_values.reshape((9,))
for i in range(9):
self.assertAlmostEqual(input_values[i],output_values[i],places=5)
