def test_direct_mode_simple(self):
"""
"""
model = Model('Runtime Test', seed=123, backend='numpy')
model.make_node('in', output=np.sin)
model.probe('in')
res = model.run(0.01)
data = res['in']
print data.dtype
print data
assert np.allclose(data.flatten(), np.sin(np.arange(0, 0.0095, .001)))
def test_matrix_mul(self):
# Adjust these values to change the matrix dimensions
# Matrix A is D1xD2
# Matrix B is D2xD3
# result is D1xD3
D1 = 1
D2 = 2
D3 = 3
seed = 123
N = 50
model = Model('Matrix Multiplication', seed=seed, backend='numpy')
# values should stay within the range (-radius,radius)
radius = 1
# make 2 matrices to store the input
model.make_ensemble('A', LIF(N), D1*D2, radius=radius)
model.make_ensemble('B', LIF(N), D2*D3, radius=radius)
# connect inputs to them so we can set their value
model.make_node('input A', [0] * D1 * D2)
model.make_node('input B', [0] * D2 * D3)
model.connect('input A', 'A')
model.connect('input B', 'B')
# the C matrix holds the intermediate product calculations
# need to compute D1*D2*D3 products to multiply 2 matrices together
model.make_ensemble('C', LIF(4 * N), D1 * D2 * D3, # dimensions=2,
radius=1.5*radius)
# encoders=[[1,1], [1,-1], [-1,1], [-1,-1]])
# determine the transformation matrices to get the correct pairwise
# products computed. This looks a bit like black magic but if
# you manually try multiplying two matrices together, you can see
# the underlying pattern. Basically, we need to build up D1*D2*D3
# pairs of numbers in C to compute the product of. If i,j,k are the
# indexes into the D1*D2*D3 products, we want to compute the product
# of element (i,j) in A with the element (j,k) in B. The index in
# A of (i,j) is j+i*D2 and the index in B of (j,k) is k+j*D3.
# The index in C is j+k*D2+i*D2*D3, multiplied by 2 since there are
# two values per ensemble. We add 1 to the B index so it goes into
# the second value in the ensemble.
transformA = [[0] * (D1 * D2) for i in range(D1 * D2 * D3 * 2)]
transformB = [[0] * (D2 * D3) for i in range(D1 * D2 * D3 * 2)]
for i in range(D1):
for j in range(D2):
for k in range(D3):
ix = (j + k * D2 + i * D2 * D3) * 2
transformA[ix][j + i * D2] = 1
transformB[ix + 1][k + j * D3] = 1
model.connect('A', 'C', transform=transformA)
model.connect('B', 'C', transform=transformB)
# now compute the products and do the appropriate summing
model.make_ensemble('D', LIF(N), D1 * D3, radius=radius)
def product(x):
return x[0] * x[1]
# the mapping for this transformation is much easier, since we want to
# combine D2 pairs of elements (we sum D2 products together)
model.connect('C', 'D', index_post=[i / D2 for i in range(D1*D2*D3)],
func=product)
model.get('input A').origin['X'].decoded_output.set_value(
np.asarray([.5, -.5]).astype('float32'))
model.get('input B').origin['X'].decoded_output.set_value(
np.asarray([0, 1, -1, 0]).astype('float32'))
pprint(model.o)
Dprobe = model.probe('D')
model.run(1)
net_data = Dprobe.get_data()
print net_data.shape
plt.plot(net_data[:, 0])
plt.plot(net_data[:, 1])
if self.show:
plt.show()
nose.SkipTest('test correctness')
def test_basic_1(self, N=1000):
"""
Create a network with sin(t) being represented by
a population of spiking neurons. Assert that the
decoded value from the population is close to the
true value (which is input to the population).
Expected duration of test: about .7 seconds
"""
model = Model('Runtime Test', seed=123, backend='numpy')
model.make_node('in', output=np.sin)
model.make_ensemble('A', LIF(N), 1)
model.connect('in', 'A')
model.probe('A', sample_every=0.01, pstc=0.001) # 'A'
model.probe('A', sample_every=0.01, pstc=0.01) # 'A_1'
model.probe('A', sample_every=0.01, pstc=0.1) # 'A_2'
model.probe('in', sample_every=0.01, pstc=0.01)
pprint(model.o)
res = model.run(1.0)
target = np.sin(np.arange(0, 1000, 10) / 1000.)
target.shape = (100, 1)
for A, label in (('A', 'fast'), ('A_1', 'med'), ('A_2', 'slow')):
data = np.asarray(res[A]).flatten()
plt.plot(data, label=label)
in_data = np.asarray(res['in']).flatten()
plt.plot(in_data, label='in')
plt.legend(loc='upper left')
#print in_probe.get_data()
#print net.sim.sim_step
if self.show:
plt.show()
# target is off-by-one at the sampling frequency of dt=0.001
print rmse(target, res['in'])
assert rmse(target, res['in']) < .001
print rmse(target, res['A'])
assert rmse(target, res['A']) < .3
print rmse(target, res['A_1'])
assert rmse(target, res['A_1']) < .03
print rmse(target, res['A_2'])
assert rmse(target, res['A_2']) < 0.1
