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 """ net = Network('Runtime Test', dt=0.001, seed=123, Simulator=self.Simulator) print 'make_input' net.make_input('in', value=np.sin) print 'make A' net.make('A', N, 1) print 'connecting in -> A' net.connect('in', 'A') A_fast_probe = net.make_probe('A', dt_sample=0.01, pstc=0.001) A_med_probe = net.make_probe('A', dt_sample=0.01, pstc=0.01) A_slow_probe = net.make_probe('A', dt_sample=0.01, pstc=0.1) in_probe = net.make_probe('in', dt_sample=0.01, pstc=0.0) net.run(1.0) target = np.sin(np.arange(0, 1000, 10) / 1000.) target.shape = (100, 1) for speed in 'fast', 'med', 'slow': probe = locals()['A_%s_probe' % speed] data = np.asarray(probe.get_data()).flatten() plt.plot(data, label=speed) in_data = np.asarray(in_probe.get_data()).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, in_probe.get_data()) assert rmse(target, in_probe.get_data()) < .001 print rmse(target, A_fast_probe.get_data()) assert rmse(target, A_fast_probe.get_data()) < .1, ( rmse(target, A_fast_probe.get_data())) print rmse(target, A_med_probe.get_data()) assert rmse(target, A_med_probe.get_data()) < .01 print rmse(target, A_slow_probe.get_data()) assert rmse(target, A_slow_probe.get_data()) < 0.1
def test_direct_mode_simple(self): """ """ net = Network('Runtime Test', dt=0.001, seed=123, Simulator=self.Simulator) net.make_input('in', value=np.sin) p = net.make_probe('in', dt_sample=0.001, pstc=0.0) rawp = net._raw_probe(net.inputs['in'], dt_sample=.001) st_probe = net._raw_probe(net.simtime, dt_sample=.001) net.run(0.01) data = p.get_data() raw_data = rawp.get_data() st_data = st_probe.get_data() print data.dtype print st_data print raw_data assert np.allclose(st_data.ravel(), np.arange(0.001, 0.0105, .001)) assert np.allclose(raw_data.ravel(), np.sin(np.arange(0, 0.0095, .001))) # -- the make_probe call induces a one-step delay # on readout even when the pstc is really small. assert np.allclose(data.ravel()[1:], np.sin(np.arange(0, 0.0085, .001)))
def test_prod(self): def product(x): return x[0]*x[1] #from nengo_theano import Network N = 250 seed = 123 net=Network('Matrix Multiplication', seed=seed) #Simulator=self.Simulator) net.make_input('sin', value=np.sin) net.make_input('neg', value=[-.5]) net.make_array('p', 2 * N, 1, dimensions=2, radius=1.5) net.make_array('D', N, 1, dimensions=1) net.connect('sin', 'p', transform=[[1], [0]]) net.connect('neg', 'p', transform=[[0], [1]]) net.connect('p', 'D', func=product, pstc=0.01) p_raw = net._probe_decoded_signals( [net.ensembles['p'].origin['product'].sigs[0]], dt_sample=.01, pstc=.01) probe_p = net.make_probe('p', dt_sample=.01, pstc=.01) probe_d = net.make_probe('D', dt_sample=.01, pstc=.01) net.run(6) data_p = probe_p.get_data() data_d = probe_d.get_data() data_r = p_raw.get_data() plt.subplot(211); plt.plot(data_p) plt.plot(np.sin(np.arange(0, 6, .01))) plt.subplot(212); plt.plot(data_d) plt.plot(data_r) plt.plot(-.5 * np.sin(np.arange(0, 6, .01))) if self.show: plt.show() assert np.allclose(data_p[:, 0], np.sin(np.arange(0, 6, .01)), atol=.1, rtol=.01) assert np.allclose(data_p[20:, 1], -0.5, atol=.1, rtol=.01) def match(a, b): assert np.allclose(a, b, .1, .1) match(data_d[:, 0], -0.5 * np.sin(np.arange(0, 6, .01))) match(data_r[:, 0], -0.5 * np.sin(np.arange(0, 6, .01)))
def test_vector_input_constant(self): # Adjust these values to change the matrix dimensions # Matrix A is D1xD2 # Matrix B is D2xD3 # result is D1xD3 D1 = 1 D2 = 2 seed = 123 N = 50 net=Network('Matrix Multiplication', seed=seed, Simulator=self.Simulator) # make 2 matrices to store the input print "make_array: input matrices A and B" net.make_array('A', neurons=N, array_size=D1*D2, neuron_type='lif') # connect inputs to them so we can set their value net.make_input('input A', value=[.5, -.5]) net.connect('input A', 'A') inprobe = net.make_probe('input A', dt_sample=0.01, pstc=0.1) sprobe = net._probe_signals( net.ensembles['A'].input_signals, dt_sample=0.01, pstc=0.01) Aprobe = net.make_probe('A', dt_sample=0.01, pstc=0.1) net.run(1) in_data = inprobe.get_data() s_data = sprobe.get_data() A_data = Aprobe.get_data() plt.subplot(311); plt.plot(in_data) plt.subplot(312); plt.plot(s_data) plt.subplot(313); plt.plot(A_data) if self.show: plt.show() assert np.allclose(in_data[-10:], [.5, -.5], atol=.01, rtol=.01) assert np.allclose(s_data[-10:], [.5, -.5], atol=.01, rtol=.01) assert np.allclose(A_data[-10:], [.5, -.5], atol=.01, rtol=.01)
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 = 2 seed = 123 N = 200 Amat = np.asarray([[.5, -.5]]) Bmat = np.asarray([[0, -1.,], [.7, 0]]) net=Network('Matrix Multiplication', seed=seed, Simulator=self.Simulator) # values should stay within the range (-radius,radius) radius = 1 # make 2 matrices to store the input print "make_array: input matrices A and B" net.make_array('A', neurons=N, array_size=D1 * D2, radius=radius, neuron_type='lif') net.make_array('B', neurons=N, array_size=D2 * D3, radius=radius, neuron_type='lif') # connect inputs to them so we can set their value inputA = net.make_input('input A', value=Amat.ravel()) inputB = net.make_input('input B', value=Bmat.ravel()) print "connect: input matrices A and B" net.connect('input A', 'A') net.connect('input B', 'B') # the C matrix holds the intermediate product calculations # need to compute D1*D2*D3 products to multiply 2 matrices together print "make_array: intermediate C" net.make_array('C', 4 * N, D1 * D2 * D3, dimensions=2, radius=1.5 * radius, encoders=[[1, 1], [1, -1], [-1, 1], [-1, -1]], neuron_type='lif') # 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): tmp = (j + k * D2 + i * D2 * D3) transformA[tmp * 2][j + i * D2] = 1 transformB[tmp * 2 + 1][k + j * D3] = 1 print "connect A->C" net.connect('A', 'C', transform=transformA) print "connect B->C" net.connect('B', 'C', transform=transformB) # now compute the products and do the appropriate summing print "make_array: output D" net.make_array('D', N , D1 * D3, radius=radius, neuron_type='lif') 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) net.connect('C', 'D', index_post=[i / D2 for i in range(D1 * D2 * D3)], func=product) Aprobe = net.make_probe('A', dt_sample=0.01, pstc=0.01) Bprobe = net.make_probe('B', dt_sample=0.01, pstc=0.01) Cprobe = net.make_probe('C', dt_sample=0.01, pstc=0.01) Dprobe = net.make_probe('D', dt_sample=0.01, pstc=0.01) prod_probe = net._probe_decoded_signals( net.ensembles['C'].origin['product'].sigs, dt_sample=0.01, pstc=.01) net.run(1) Dmat = np.dot(Amat, Bmat) data = Dprobe.get_data() for i in range(D1): for k in range(D3): plt.subplot(D1, D3, i * D3 + k + 1) plt.title('D[%i, %i]' % (i, k)) plt.plot(data[:, i * D3 + k]) plt.axhline(Dmat[i, k]) plt.ylim(-radius, radius) if self.show: plt.show() assert np.allclose(Aprobe.get_data()[50:, 0], 0.5, atol=.1, rtol=.01) assert np.allclose(Aprobe.get_data()[50:, 1], -0.5, atol=.1, rtol=.01) assert np.allclose(Bprobe.get_data()[50:, 0], 0, atol=.1, rtol=.01) assert np.allclose(Bprobe.get_data()[50:, 1], -1, atol=.1, rtol=.01) assert np.allclose(Bprobe.get_data()[50:, 2], .7, atol=.1, rtol=.01) assert np.allclose(Bprobe.get_data()[50:, 3], 0, atol=.1, rtol=.01) for i in range(D1): for k in range(D3): assert np.allclose( data[-10:, i * D3 + k], Dmat[i, k], atol=0.1, rtol=0.1), ( data[-10:, i * D3 + k], Dmat[i, k])
def test_multidim_probe(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 = 200 Amat = np.asarray([[.4, .8]]) Bmat = np.asarray([[-1.0, -0.6, -.15], [0.25, .5, .7]]) net=Network('V', seed=seed, Simulator=self.Simulator) # values should stay within the range (-radius,radius) radius = 2.0 # make 2 matrices to store the input print "make_array: input matrices A and B" net.make_array('A', neurons=N, array_size=D1 * D2, radius=radius, neuron_type='lif') net.make_array('B', neurons=N, array_size=D2 * D3, radius=radius, neuron_type='lif') # connect inputs to them so we can set their value inputA = net.make_input('input A', value=Amat.flatten()) inputB = net.make_input('input B', value=Bmat.flatten()) print "connect: input matrices A and B" net.connect('input A', 'A') net.connect('input B', 'B') # the C matrix holds the intermediate product calculations # need to compute D1*D2*D3 products to multiply 2 matrices together print "make_array: intermediate C" net.make_array('C', 4 * N, D1 * D2 * D3, dimensions=2, radius=1.5 * radius, encoders=[[1, 1], [1, -1], [-1, 1], [-1, -1]], neuron_type='lif') 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 k in range(D3): for j in range(D2): tmp = (j + k * D2 + i * D2 * D3) transformA[tmp * 2][j + i * D2] = 1 transformB[tmp * 2 + 1][k + j * D3] = 1 print transformA #print transformB print "connect A->C" net.connect('A', 'C', transform=transformA) #print "connect B->C" net.connect('B', 'C', transform=transformB) Cprobe = net.make_probe('C', dt_sample=0.01, pstc=0.01) net.run(1) print Cprobe.get_data().shape print Amat print Bmat #assert Cprobe.get_data().shape == (100, D1 * D2 * D3, 2) data = Cprobe.get_data() for i in range(D1): for k in range(D3): for j in range(D2): tmp = (j + k * D2 + i * D2 * D3) plt.subplot(D1 * D2 * D3, 2, 1 + 2 * tmp); plt.title('A[%i, %i]' % (i, j)) plt.axhline(Amat[i, j]) plt.ylim(-radius, radius) plt.plot(data[:, 2 * tmp]) plt.subplot(D1 * D2 * D3, 2, 2 + 2 * tmp); plt.title('B[%i, %i]' % (j, k)) plt.axhline(Bmat[j, k]) plt.ylim(-radius, radius) plt.plot(data[:, 2 * tmp + 1]) if self.show: plt.show() for i in range(D1): for k in range(D3): for j in range(D2): tmp = (j + k * D2 + i * D2 * D3) assert np.allclose( data[-10:, 2 * tmp], Amat[i, j], atol=0.1, rtol=0.1), ( data[-10:, 2 * tmp], Amat[i, j]) assert np.allclose( data[-10:, 1 + 2 * tmp], Bmat[j, k], atol=0.1, rtol=0.1)