nxmodel.summary()
nxmodel.compile()
num_steps_per_img = num_input_neurons + 1
nxmodel_composable = ComposableDNN(nxmodel, num_steps_per_img)
input_generator = SpikeInputGenerator(name='SpikeGen',
packetSize=256,
queueSize=64,
numSnipsPerChip=1)
input_generator.connect(nxmodel_composable)
input_generator.processes.inputEncoder.executeAfter(
nxmodel_composable.processes.reset)
model = ComposableModel('debug')
model.add(nxmodel_composable)
model.add(input_generator)
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):
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)
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])
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)
def testComposableDNNWithInScopeVersion(self):
"""Tests the DNN Composable with the in-scope version"""
with Model("dnn_pipeline") as model:
dnn = self.setUpDNN()
model.compile()
def testComposableDNN(self):
"""Test composable dnn and run the pipeline"""
composableDNNModel = self.setUpDNN()
model = Model("dnn_pipeline")
model.add(composableDNNModel)
model.compile()