def test_input_encoder(self):
"""Test running a compilation pipeline with input encoder and mocked port"""
# Create an input encoder
shape = (32, 32, 1, 1)
ie = InputGenerator(shape)
a = np.arange(0, 1024*5, 5)
a = a.reshape(*shape)
# Create an instance of board
board = N2Board(1, 1, [4], [[5]*4])
# Create a mock port and connect input encoder to this port
mockPort = StateInputPort(name="input")
cxIds = np.arange(shape[0]*shape[1])
chip_core_ids = np.array([[0, 19]]*shape[0]*shape[1])
mockAddresses = np.hstack((chip_core_ids, cxIds.reshape((shape[0]*shape[1],1))))
mockPort.resourceMap = ResourceMapFactory.createExplicit(ResourceMapType.COMPARTMENT, mockAddresses)
# Connect the ports
ie.ports.output.connect(mockPort)
# Create a model and add input encoder as composable
m = Model(name="video_encoder")
m.add(ie)
m.compile(board=board)
m.start(board=m.board, partition=os.environ.get("PARTITION"))
# Encode the data
ie.encode(a)
m.run(1)
m.disconnect()
self.assertEqual(True, True)
def test_spike_input_gen(self):
"""
Create a mock output port and inject spikes into random axons.
"""
# Create an input encoder
ie = SpikeInputGenerator(name="SpikeGen")
# Create an instance of board
board = N2Board(1, 1, [4], [[5] * 4])
# Create a mock port and connect input encoder to this port
mockPort = StateInputPort(name="input")
axonIds = np.arange(100)
chip_core_ids = np.array([[0, 19]] * 100)
mockAddresses = np.hstack((chip_core_ids, axonIds.reshape((100, 1))))
mockPort.resourceMap = ResourceMapFactory.createExplicit(
ResourceMapType.INPUT_AXON, mockAddresses)
# Connect the ports
ie.ports.output.connect(mockPort)
# Create a model and add input encoder as composable
m = Model(name="spike_encoder")
m.add(ie)
m.compile(board=board)
m.start(board=m.board, partition=os.environ.get("PARTITION"))
# Encode the data
input_list = []
for i in range(20):
input_list.append((random.randint(1, 20), random.randint(0, 100)))
ie.encode(input_list)
m.run(20)
m.disconnect()
self.assertEqual(True, True)
model.compile()
p = ProbableStates.ACTIVITY
probes_spikes_input = [neuron.probe(p) for neuron in nxmodel.layers[0]]
p = ProbableStates.VOLTAGE
probes_voltage_input = [neuron.probe(p) for neuron in nxmodel.layers[0]]
probes_voltage_output = [neuron.probe(p) for neuron in nxmodel.layers[-1]]
model.start(nxmodel.board)
inputs = []
for n in range(num_input_neurons):
inputs.append((n, n + 1))
input_generator.encode(inputs)
model.run(num_steps_per_img)
model.finishRun()
spikes_input = np.stack(
[p.data[-num_steps_per_img:] for p in probes_spikes_input], 1)
voltage_input = np.stack(
[p.data[-num_steps_per_img:] for p in probes_voltage_input], 1)
for p in probes_voltage_input:
p.plot()
plt.show()
probes_voltage_output[0].plot()
plt.show()
model.disconnect()
t = dataset[i].t + i * num_steps_per_img + 1
p = dataset[i].p
# Encode pixel-address, timestamp, and polarity as single number.
addr = p * input_shape[0] * input_shape[1] + y * input_shape[0] + x
# Apply encoding expected by SpikeInputGenerator.
inp_encoded = input_generator.prepare_encoding(np.column_stack([addr, t]))
# Group the encoded spikes of each sample by chip and embedded processor.
for chip_id, inputs_per_chip in inp_encoded.items():
inputs_encoded.setdefault(chip_id, OrderedDict())
for cpu_id, inputs_per_cpu in inputs_per_chip.items():
inputs_encoded[chip_id].setdefault(cpu_id, [])
inputs_encoded[chip_id][cpu_id].extend(inputs_per_cpu)
# Start run.
model.start(nxmodel.board)
model.run(num_steps_per_img * num_to_test, aSync=True)
# Inject input.
print("Sending encoded input spikes.")
input_generator.send_inputs(inputs_encoded)
# Read output.
outputs = nxmodel_composable.readout_channel.read(num_to_test)
accuracy = np.mean(np.equal(outputs, dataset.labels[:len(outputs)]))
print("Accuracy after {} samples: {:.2%}.".format(num_to_test, accuracy))
model.finishRun()
model.disconnect()
# Show performance results.
if probe_performance:
def test_spike_input_gen(self):
"""
Create a mock output port and inject spikes into random axons.
"""
# Create an input encoder
ie = SpikeInputGenerator(name="SpikeGen")
# Create an instance of board
board = N2Board(1, 1, [4], [[5] * 4])
n2Core = board.n2Chips[0].n2Cores[0]
n2Core.cxProfileCfg[0].configure(decayV=int(2**12 - 1),
decayU=int(2**12 - 1))
n2Core.cxMetaState[0].configure(phase0=2)
n2Core.vthProfileCfg[0].staticCfg.configure(vth=1024)
n2Core.numUpdates.configure(numUpdates=1)
n2Core.cxCfg[0].configure(bias=0, biasExp=0, vthProfile=0, cxProfile=0)
n2Core.synapseMap[0].synapsePtr = 0
n2Core.synapseMap[0].synapseLen = 1
n2Core.synapseMap[0].discreteMapEntry.configure()
n2Core.synapses[0].CIdx = 0
n2Core.synapses[0].Wgt = 255
n2Core.synapses[0].synFmtId = 1
n2Core.synapseFmt[1].wgtBits = 7
n2Core.synapseFmt[1].numSynapses = 63
n2Core.synapseFmt[1].idxBits = 1
n2Core.synapseFmt[1].compression = 3
n2Core.synapseFmt[1].fanoutType = 1
mon = board.monitor
vProbes = mon.probe(n2Core.cxState, [0], 'v')[0]
# Create a mock port and connect input encoder to this port
mockPort = StateInputPort(name="input")
num_axons = 100
dst_core_id = 4
chip_id = 0
axonIds = np.arange(num_axons)
chip_core_ids = np.array([[chip_id, dst_core_id]] * num_axons)
mockAddresses = np.hstack((chip_core_ids, np.expand_dims(axonIds, 1)))
mockPort.resourceMap = ResourceMapFactory.createExplicit(
ResourceMapType.INPUT_AXON, mockAddresses)
# Connect the ports
ie.ports.output.connect(mockPort)
# Create a model and add input encoder as composable
m = Model(name="spike_encoder")
m.add(ie)
m.compile(board=board)
m.start(board=m.board, partition=os.environ.get("PARTITION"))
# Encode the data
input_list = []
num_timesteps = 200
# for i in range(num_timesteps):
# input_list.append((random.randint(0, num_axons - 1),
# random.randint(1, num_timesteps)))
input_list = [(0, t) for t in range(1, num_timesteps)]
ie.encode(input_list)
m.run(num_timesteps)
vProbes.plot()
import matplotlib.pyplot as plt
plt.show()
m.disconnect()
self.assertEqual(True, True)