def test_evaluateNxModel(self):
"""Check that NxModel can be evaluated like a Keras Model."""
batchSize = 10
batchInputShape = (batchSize, 7, 7, 1)
inputLayer = NxInputLayer(batch_input_shape=batchInputShape)
layer = NxConv2D(2, 3)(inputLayer.input)
model = NxModel(inputLayer.input, layer)
model.compile('sgd', 'mse')
model.evaluate(np.random.random_sample(model.input_shape),
np.random.random_sample(model.output_shape))
model.clearTemp()
def test_saveLoadNxModel(self):
"""Check that NxModel can be saved and loaded like a Keras Model."""
inputLayer = NxInputLayer(batch_input_shape=(1, 10, 10, 3))
layer = NxConv2D(2, 3)(inputLayer.input)
model1 = NxModel(inputLayer.input, layer)
model1.compile('sgd', 'mse')
model1.compileModel()
model1.clearTemp()
filename = os.path.abspath(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'../../..', 'temp', str(hash(model1))))
model1.save(filename)
model2 = loadNxModel(filename)
os.remove(filename)
x = np.random.random_sample(model1.input_shape)
y1 = model1.predict(x)
y2 = model2.predict(x)
self.assertTrue(np.array_equal(y1, y2))
num_input_neurons = 1024
num_output_neurons = 1
input_layer = NxInputLayer(num_input_neurons,
compartmentKwargs=compartment_kwargs,
inputMode=InputModes.AEDAT)
layer = NxDense(num_output_neurons,
compartmentKwargs=compartment_kwargs)(input_layer.input)
nxmodel = NxModel(input_layer.input, layer)
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)
num_neurons = num_classes
biases = np.zeros(num_neurons)
layer = NxDense(num_neurons,
weights=[weights, biases],
compartmentKwargs=compartment_kwargs,
connectionKwargs=conn_kwargs,
resetMode=reset_mode,
name=name)(layer)
# COMPILATION #
###############
# Compile complete model.
nxmodel = NxModel(input_layer.input, layer)
nxmodel.summary()
nxmodel.compile() # Keras compile function. Not yet invoking NxTF compiler.
# Apply pooling weights.
for name, weights in pool_weights.items():
nxmodel.get_layer(name).set_weights(weights)
# Use the composablility interface of NxSDK to wrap our NxTF model. Allows
# more efficient input injection, output readout, and resetting via snips.
nxmodel_composable = ComposableDNN(nxmodel,
num_steps_per_img,
enable_reset=reset_between_samples)
model = ComposableModel('gestures_cnn')
input_generator = SpikeInputGenerator(name='SpikeGen',
packetSize=256,
numSnipsPerChip=3,
queueSize=512)
def test_NxInputLayer(self):
"""
Test input layer in soft-reset mode.
"""
plot = False
verbose = False
resetMode = 'soft'
neuronSize = 2 if resetMode == 'soft' else 1
input_shape = (32, 32, 3)
inputSize = np.prod(input_shape)
inputLayer = NxInputLayer(input_shape,
probeSpikes=True,
vThMant=255,
resetMode=resetMode)
out = inputLayer.input
model = NxModel(out, out)
model.compile('adam', 'categorical_crossentropy', ['accuracy'])
model.summary()
layers = [inputLayer]
input_image = np.linspace(
0, 256, endpoint=False,
num=inputSize).reshape(input_shape).astype(int)
x_test = [input_image]
y_test = [0]
mapper = model.compileModel()
if verbose:
printLayerMappings(layers, mapper, synapses=True, inputAxons=True)
printLayers(layers)
layerProbes = []
numProbes = 32
for i, layer in enumerate(layers):
shape = layer.output_shape[1:]
# Define probes to read out currents.
vProbes = []
sProbes = []
uProbes = []
toProbe = numProbes if i == (len(layers) -
1) else numProbes * neuronSize
toProbe = min(toProbe,
int(np.asscalar(np.prod(shape))) * neuronSize)
for j in range(toProbe):
vProbes.append(layer[j].probe(ProbableStates.VOLTAGE))
sProbes.append(layer[j].probe(ProbableStates.ACTIVITY))
uProbes.append(layer[j].probe(ProbableStates.CURRENT))
layerProbes.append([uProbes, vProbes, sProbes])
# How many time steps to run each sample.
num_steps = 1000
# How many samples to test.
num_samples_to_test = 1
# Iterate over samples in testset.
for i, (input_image, target) in enumerate(zip(x_test, y_test)):
if i == num_samples_to_test:
break
if plot:
plt.hist(input_image.ravel())
plt.show()
# Set input bias currents.
for j, b in enumerate(np.ravel(input_image, 'F')):
inputLayer[j * neuronSize].biasMant = b
inputLayer[j * neuronSize].biasExp = 6
inputLayer[j * neuronSize].phase = 2
# Run model.
model.run(num_steps)
# Clean up.
data = [[extract(probe) for probe in lp] for lp in layerProbes]
spikesRates = []
for i, (layer, d) in enumerate(zip(layers, data)):
sData = d[2][:, (neuronSize - 1)::neuronSize]
spikecount = (sData // 127).sum(0)
spikesRates.append(spikecount / num_steps)
model.disconnect()
layer_activations = [x_test[0]]
if plot:
for activations, spikerate in zip(layer_activations, spikesRates):
plt.figure()
scale = np.max(activations)
spikesFlat = spikerate #spikerate.flatten()
plt.plot(
activations.flatten('F')[:len(spikesFlat)] / scale,
spikesFlat, '.')
plotLayerProbes(layers, data, neuronSize)
cor = np.corrcoef(np.ravel(spikesRates[-1]),
np.ravel(layer_activations[0],
'F')[:numProbes // 2])[0, 1]
self.assertGreater(cor, 0.99)
