def create_snn_model():
"""
Create a Spiking Model of the MNIST dnn
:return: Spiking Model
"""
vth_mant = 2**9
bias_exp = 6
weight_exponent = 0
synapse_encoding = 'sparse'
inputLayer = NxInputLayer(input_shape, vThMant=vth_mant, biasExp=bias_exp)
layer = NxConv2D(filters=16,
kernel_size=(5, 5),
strides=(2, 2),
input_shape=input_shape,
vThMant=vth_mant,
weightExponent=weight_exponent,
synapseEncoding=synapse_encoding)(inputLayer.input)
layer = NxConv2D(filters=32,
kernel_size=(3, 3),
vThMant=vth_mant,
weightExponent=weight_exponent,
synapseEncoding=synapse_encoding)(layer)
layer = NxConv2D(filters=64,
kernel_size=(3, 3),
strides=(2, 2),
vThMant=vth_mant,
weightExponent=weight_exponent,
synapseEncoding=synapse_encoding)(layer)
layer = NxConv2D(filters=10,
kernel_size=(4, 4),
activation='softmax',
vThMant=vth_mant,
weightExponent=weight_exponent,
synapseEncoding=synapse_encoding)(layer)
spiking_model = NxModel(inputLayer.input, layer, numCandidatesToCompute=1)
spiking_model.summary()
return spiking_model
'refractoryDelay': 0,
}
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)
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)
def test_random_cor(self):
"""
Tests the soft reset mode by comparing activations from an ANN
to spike-rate from the converted SNN. The input and weights
are randomly initialized.
"""
seed = 123
np.random.seed(seed)
plot = False
verbose = False
visualizePartitions = False
logger = None
resetMode = 'soft'
neuronSize = 2 if resetMode == 'soft' else 1
inputShape = (4, 4, 1)
inputScale = 255
inputImage = np.random.randint(int(inputScale * 0.25), int(inputScale),
inputShape)
maxNumSpikes = 100
numSteps = int(np.max(inputImage / 255) * maxNumSpikes)
inputLayer = NxInputLayer(batch_input_shape=(1, ) + inputShape,
vThMant=255,
visualizePartitions=visualizePartitions,
resetMode=resetMode,
probeSpikes=True)
out = inputLayer.input
layers = [inputLayer]
# Conv2D
kernelShape = (3, 3, 1)
kernelScale = 4
# No need to divide by thrGain because spike input receives equal gain.
vThMant = 2**9 - 1
kernel_init = partial(kernel_initializer, kernelScale=kernelScale)
numLayers = 1
for i in range(numLayers):
layer = NxConv2D(filters=kernelShape[-1],
kernel_size=kernelShape[:-1],
vThMant=vThMant,
kernel_initializer=kernel_init,
bias_initializer='ones',
validatePartitions=False,
probeSpikes=True,
activation='relu',
resetMode=resetMode)
layers.append(layer)
out = layer(out)
model = NxModel(inputLayer.input, out, logger=logger)
for layer in layers[1:]:
weights, biases = layer.get_weights()
weights, biases = to_integer(weights, biases, 8,
np.max(weights) // 2)
layer.set_weights([weights, biases])
mapper = model.compileModel()
if verbose:
printLayerMappings(layers, mapper, synapses=True, inputAxons=True)
printLayers(layers)
print(model.summary())
layerProbes = []
for layer in layers:
shape = layer.output_shape[1:]
# Define probes to read out currents.
vProbes = []
sProbes = []
uProbes = []
for i in range(int(np.asscalar(np.prod(shape))) * neuronSize):
vProbes.append(layer[i].probe(ProbableStates.VOLTAGE))
sProbes.append(layer[i].probe(ProbableStates.ACTIVITY))
uProbes.append(layer[i].probe(ProbableStates.CURRENT))
layerProbes.append([uProbes, vProbes, sProbes])
# Set bias currents
for i, b in enumerate(np.ravel(inputImage, 'F')):
inputLayer[i * neuronSize].biasMant = b
inputLayer[i * neuronSize].phase = 2
if verbose:
for layer in layers:
print(getCompartmentStates(layer, neuronSize))
model.run(numSteps)
if verbose:
for layer in layers:
print(getCompartmentStates(layer, neuronSize))
model.disconnect()
data = [[extract(probe) for probe in lp] for lp in layerProbes]
if plot:
plotLayerProbes(layers, data, neuronSize)
spikesRates = []
for i, (layer, d) in enumerate(zip(layers, data)):
sData = d[2][:, (neuronSize - 1)::neuronSize]
shape = layer.output_shape[1:]
spikecount = _data_to_img(sData // 127, shape)
spikesRates.append(spikecount / numSteps)
batchInputImage = np.expand_dims(inputImage, 0)
activations = model.predict(batchInputImage)[0]
if plot:
plt.figure()
plt.plot(inputImage.flatten(), spikesRates[0].flatten(), '.')
plt.show()
plt.figure()
plt.plot(activations.flatten(), spikesRates[-1].flatten(), '.')
plt.show()
plt.figure()
plt.imshow(normalize_image_dims(activations))
plt.show()
plt.figure()
plt.imshow(normalize_image_dims(spikesRates[-1]))
plt.show()
cor = np.corrcoef(np.ravel(spikesRates[-1]), np.ravel(activations))[0,
1]
self.assertGreater(cor, 0.99)
if verbose:
print(cor)
