def simulate(self, **kwargs):
data = kwargs[str('x_b_l')]
if self.data_format == 'channels_last' and data.ndim == 4:
data = np.moveaxis(data, 3, 1)
x_flat = np.ravel(data)
if self._poisson_input:
self.layers[0].set(rate=list(x_flat / self.rescale_fac * 1000))
elif self._dataset_format == 'aedat':
raise NotImplementedError
else:
spike_times = \
[np.linspace(0, self._duration, self._duration * amplitude)
for amplitude in x_flat]
self.layers[0].set(spike_times=spike_times)
if is_module_installed('pynn_object_serialisation'):
from pynn_object_serialisation.functions import intercept_simulator
current_time = time.strftime("_%H%M%S_%d%m%Y")
intercept_simulator(self.sim, "snn_toolbox_pynn_" + current_time)
self.sim.run(self._duration - self._dt,
callbacks=[MyProgressBar(self._dt, self._duration)])
print("\nCollecting results...")
output_b_l_t = self.get_recorded_vars(self.layers)
return output_b_l_t
def get_custom_layers_dict(filepath=None):
"""
Import all implemented custom layers so they can be used when loading a
Keras model.
Parameters
----------
filepath : Optional[str]
Path to json file containing additional custom objects.
"""
from snntoolbox.utils.utils import is_module_installed
custom_layers = {}
if is_module_installed('keras_rewiring'):
from keras_rewiring import Sparse, SparseConv2D, SparseDepthwiseConv2D
from keras_rewiring.optimizers import NoisySGD
custom_layers.update({
'Sparse': Sparse,
'SparseConv2D': SparseConv2D,
'SparseDepthwiseConv2D': SparseDepthwiseConv2D,
'NoisySGD': NoisySGD
})
if filepath is not None and filepath != '':
import json
with open(filepath) as f:
kwargs = json.load(f)
custom_layers.update(kwargs)
return custom_layers
def _model_3(_dataset):
if not is_module_installed('keras_rewiring'):
return
from keras_rewiring import Sparse, SparseConv2D, SparseDepthwiseConv2D
x_train, y_train, x_test, y_test = _dataset
axis = 1 if keras.backend.image_data_format() == 'channels_first' else -1
input_shape = x_train.shape[1:]
input_layer = Input(input_shape)
layer = SparseConv2D(filters=16, kernel_size=(5, 5),
strides=(2, 2))(input_layer)
layer = BatchNormalization(axis=axis)(layer)
layer = Activation('relu')(layer)
layer = AveragePooling2D()(layer)
branch1 = SparseConv2D(filters=32,
kernel_size=(3, 3),
padding='same',
activation='relu')(layer)
branch2 = SparseDepthwiseConv2D(kernel_size=(1, 1),
activation='relu')(layer)
layer = Concatenate(axis=axis)([branch1, branch2])
layer = SparseConv2D(filters=10, kernel_size=(3, 3),
activation='relu')(layer)
layer = Flatten()(layer)
layer = Dropout(1e-5)(layer)
layer = Sparse(units=10, activation='softmax')(layer)
model = Model(input_layer, layer)
model.compile('adam', 'categorical_crossentropy', ['accuracy'])
# Train model with backprop.
history = model.fit(x_train,
y_train,
batch_size=64,
epochs=1,
verbose=2,
validation_data=(x_test, y_test))
assert history.history['val_accuracy'][-1] > 0.96
return model
def _installed_input_libs(_config):
input_libs = _config.get('restrictions', 'model_libs')
return [lib for lib in input_libs if is_module_installed(lib)]
def _model_4(_dataset):
if not is_module_installed('torch'):
return
import torch
import torch.nn as nn
from tests.parsing.models import pytorch
x_train, y_train, x_test, y_test = _dataset
# Pytorch doesn't support one-hot labels.
y_train = np.argmax(y_train, 1)
y_test = np.argmax(y_test, 1)
class PytorchDataset(torch.utils.data.Dataset):
def __init__(self, data, target, transform=None):
self.data = torch.from_numpy(data).float()
self.target = torch.from_numpy(target).long()
self.transform = transform
def __getitem__(self, index):
x = self.data[index]
if self.transform:
x = self.transform(x)
return x, self.target[index]
def __len__(self):
return len(self.data)
trainset = torch.utils.data.DataLoader(PytorchDataset(x_train, y_train),
batch_size=64)
testset = torch.utils.data.DataLoader(PytorchDataset(x_test, y_test),
batch_size=64)
model = pytorch.Model()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())
acc = 0
for epoch in range(3):
for i, (xx, y) in enumerate(trainset):
optimizer.zero_grad()
outputs = model(xx)
loss = criterion(outputs, y)
loss.backward()
optimizer.step()
total = 0
correct = 0
with torch.no_grad():
for xx, y in testset:
outputs = model(xx)
_, predicted = torch.max(outputs.data, 1)
total += y.size(0)
correct += (predicted == y).sum().item()
acc = correct / total
print("Test accuracy: {:.2%}".format(acc))
# assert acc > 0.96, "Test accuracy after training not high enough."
return model
correct = 0
with torch.no_grad():
for xx, y in testset:
outputs = model(xx)
_, predicted = torch.max(outputs.data, 1)
total += y.size(0)
correct += (predicted == y).sum().item()
acc = correct / total
print("Test accuracy: {:.2%}".format(acc))
# assert acc > 0.96, "Test accuracy after training not high enough."
return model
spinnaker_conditions = (is_module_installed('keras_rewiring')
and is_module_installed('pynn_object_serialisation')
and (is_module_installed('pyNN.spiNNaker')
or is_module_installed('spynnaker8')))
spinnaker_skip_if_dependency_missing = pytest.mark.skipif(
not spinnaker_conditions, reason="Spinnaker dependency missing.")
nest_conditions = (is_module_installed('pyNN') and is_module_installed('nest'))
nest_skip_if_dependency_missing = pytest.mark.skipif(
not nest_conditions, reason="Nest dependency missing.")
brian2_conditions = (is_module_installed('brian2'))
brian2_skip_if_dependency_missing = pytest.mark.skipif(
not brian2_conditions, reason="Brian2 dependency missing.")
pytorch_conditions = (is_module_installed('torch')
activation='softmax')(layer)
model = Model(input_layer, layer)
model.compile('adam', 'categorical_crossentropy', ['accuracy'])
# Train model with backprop.
history = model.fit(x_train, y_train, batch_size=64, epochs=1, verbose=2,
validation_data=(x_test, y_test))
assert history.history['val_accuracy'][-1] > 0.96
return model
spinnaker_conditions = (is_module_installed('keras_rewiring') and
is_module_installed('pynn_object_serialisation') and
(is_module_installed('pyNN.spiNNaker') or
is_module_installed('spynnaker8')))
spinnaker_skip_if_dependency_missing = pytest.mark.skipif(
not spinnaker_conditions, reason="Spinnaker dependency missing.")
nest_conditions = (is_module_installed('pyNN') and
is_module_installed('nest'))
nest_skip_if_dependency_missing = pytest.mark.skipif(
not nest_conditions, reason="Nest dependency missing.")
brian2_conditions = (is_module_installed('brian2'))
brian2_skip_if_dependency_missing = pytest.mark.skipif(
not brian2_conditions, reason="Brian2 dependency missing.")
