def convert_dense(self, model, pre_layer, input_shape, index,
onnx_model_graph):
onnx_model_graph_node = onnx_model_graph.node
node_info = onnx_model_graph_node[index]
dense_num = self.get_dense_num(node_info, onnx_model_graph)
neuron_type = self.get_neuronType(index, onnx_model_graph_node)
with model:
x = nengo_dl.tensor_layer(pre_layer,
tf.layers.dense,
units=dense_num)
if neuron_type != "softmax":
if neuron_type == "lif":
x = nengo_dl.tensor_layer(
x, nengo.LIF(amplitude=self.amplitude))
elif neuron_type == "lifrate":
x = nengo_dl.tensor_layer(
x, nengo.LIFRate(amplitude=self.amplitude))
elif neuron_type == "adaptivelif":
x = nengo_dl.tensor_layer(
x, nengo.AdaptiveLIF(amplitude=self.amplitude))
elif neuron_type == "adaptivelifrate":
x = nengo_dl.tensor_layer(
x, nengo.AdaptiveLIFRate(amplitude=self.amplitude))
elif neuron_type == "izhikevich":
x = nengo_dl.tensor_layer(
x, nengo.Izhikevich(amplitude=self.amplitude))
elif neuron_type == "softlifrate":
x = nengo_dl.tensor_layer(
x,
nengo_dl.neurons.SoftLIFRate(amplitude=self.amplitude))
elif neuron_type == None: #default neuron_type = LIF
x = nengo_dl.tensor_layer(
x, nengo.LIF(amplitude=self.amplitude))
output_shape = [dense_num, 1]
return model, output_shape, x
def test_ratestospikes_state_overlap():
class CustomSpiking(RatesToSpikesNeuronType): # pylint: disable=abstract-method
state = {"adaptation": nengo.dists.Choice([0])}
with pytest.raises(ValidationError,
match="have an overlapping state variable"):
CustomSpiking(nengo.AdaptiveLIFRate())
def test_spiking_builders(SpikingType):
# use a base type with its own state(s), to make sure those states get built
neuron_type = SpikingType(
nengo.AdaptiveLIFRate(initial_state={"adaptation": np.ones(10) * 2}),
initial_state={"voltage": np.ones(10) *
3} if SpikingType is nengo.RegularSpiking else {},
)
with nengo.Network() as net:
neurons = nengo.Ensemble(10, 1, neuron_type=neuron_type).neurons
# check that the expected attributes are probeable
nengo.Probe(neurons, "output")
nengo.Probe(neurons, "rate_out")
nengo.Probe(neurons, "adaptation")
if SpikingType is nengo.RegularSpiking:
nengo.Probe(neurons, "voltage")
with nengo.Simulator(net) as sim:
ops = [op for op in sim.step_order if isinstance(op, SimNeurons)]
assert len(ops) == 2
assert ops[0].neurons is neurons.ensemble.neuron_type.base_type
assert ops[1].neurons is neurons.ensemble.neuron_type
adaptation = sim.model.sig[neurons]["adaptation"]
# All signals get put in `sets`
assert sum(adaptation is sig for sig in ops[0].sets) == 1
# check that initial state argument is applied correctly
assert np.allclose(sim.signals[sim.model.sig[neurons]["adaptation"]],
2)
if SpikingType is nengo.RegularSpiking:
assert np.allclose(sim.signals[sim.model.sig[neurons]["voltage"]],
3)
def test_alif(Simulator):
"""Test ALIF and ALIFRate by comparing them to each other"""
n = 100
max_rates = 50 * np.ones(n)
intercepts = np.linspace(-0.99, 0.99, n)
encoders = np.ones((n, 1))
nparams = dict(tau_n=1, inc_n=10e-3)
eparams = dict(n_neurons=n,
max_rates=max_rates,
intercepts=intercepts,
encoders=encoders)
model = nengo.Network()
with model:
u = nengo.Node(output=0.5)
a = nengo.Ensemble(neuron_type=nengo.AdaptiveLIFRate(**nparams),
dimensions=1,
**eparams)
b = nengo.Ensemble(neuron_type=nengo.AdaptiveLIF(**nparams),
dimensions=1,
**eparams)
nengo.Connection(u, a, synapse=0)
nengo.Connection(u, b, synapse=0)
ap = nengo.Probe(a, "spikes", synapse=0)
bp = nengo.Probe(b, "spikes", synapse=0)
dt = 1e-3
sim = Simulator(model, dt=dt)
sim.run(2.)
t = sim.trange()
a_rates = sim.data[ap] / dt
spikes = sim.data[bp]
b_rates = rates_kernel(t, spikes)
tmask = (t > 0.1) & (t < 1.7)
rel_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask])
with Plotter(Simulator) as plt:
ax = plt.subplot(311)
implot(plt, t, intercepts[::-1], a_rates.T, ax=ax)
ax.set_ylabel('input')
ax = plt.subplot(312)
implot(plt, t, intercepts[::-1], b_rates.T, ax=ax)
ax.set_ylabel('input')
ax = plt.subplot(313)
implot(plt, t, intercepts[::-1], (b_rates - a_rates)[tmask].T, ax=ax)
ax.set_xlabel('time [s]')
ax.set_ylabel('input')
plt.savefig('test_neurons.test_alif.pdf')
plt.close()
assert rel_rmse < 0.07
def convert_conv2d(self, model, pre_layer, input_shape, index,
onnx_model_graph):
onnx_model_graph_node = onnx_model_graph.node
node_info = onnx_model_graph_node[index]
neuron_type = self.get_neuronType(index, onnx_model_graph_node)
filters = self.get_filterNum(node_info, onnx_model_graph)
for index in range(len(node_info.attribute)):
if node_info.attribute[index].name == "kernel_shape":
kernel_size = node_info.attribute[index].ints[0]
elif node_info.attribute[index].name == "strides":
strides = node_info.attribute[index].ints[0]
elif node_info.attribute[index].name == "auto_pad":
padding = node_info.attribute[index].s.decode('ascii').lower()
if padding != "valid":
padding = "same"
if padding == "same":
output_shape = [input_shape[0], input_shape[1], filters]
else:
output_shape = [
int((input_shape[0] - kernel_size) / strides + 1),
int((input_shape[1] - kernel_size) / strides + 1), filters
]
with model:
x = nengo_dl.tensor_layer(pre_layer,
tf.layers.conv2d,
shape_in=(input_shape[0], input_shape[1],
input_shape[2]),
filters=filters,
kernel_size=kernel_size,
padding=padding)
if neuron_type == "lif":
x = nengo_dl.tensor_layer(x,
nengo.LIF(amplitude=self.amplitude))
elif neuron_type == "lifrate":
x = nengo_dl.tensor_layer(
x, nengo.LIFRate(amplitude=self.amplitude))
elif neuron_type == "adaptivelif":
x = nengo_dl.tensor_layer(
x, nengo.AdaptiveLIF(amplitude=self.amplitude))
elif neuron_type == "adaptivelifrate":
x = nengo_dl.tensor_layer(
x, nengo.AdaptiveLIFRate(amplitude=self.amplitude))
elif neuron_type == "izhikevich":
x = nengo_dl.tensor_layer(
x, nengo.Izhikevich(amplitude=self.amplitude))
elif neuron_type == "softlifrate":
x = nengo_dl.tensor_layer(
x, nengo_dl.neurons.SoftLIFRate(amplitude=self.amplitude))
elif neuron_type == None: #default neuron_type = LIF
x = nengo_dl.tensor_layer(x,
nengo.LIF(amplitude=self.amplitude))
return model, output_shape, x
def test_spiking_builders(SpikingType):
# use a base type with its own state(s), to make sure those states get built
neuron_type = SpikingType(nengo.AdaptiveLIFRate())
with nengo.Network() as net:
neurons = nengo.Ensemble(10, 1, neuron_type=neuron_type).neurons
with nengo.Simulator(net) as sim:
ops = [op for op in sim.model.operators if isinstance(op, SimNeurons)]
assert len(ops) == 1
adaptation = sim.model.sig[neurons]["adaptation"]
# All signals get put in `sets`
assert sum(adaptation is sig for sig in ops[0].sets) == 1
def test_alif_rate(Simulator):
n = 100
max_rates = 50 * np.ones(n)
# max_rates = 200 * np.ones(n)
intercepts = np.linspace(-0.99, 0.99, n)
encoders = np.ones((n, 1))
model = nengo.Network()
with model:
u = nengo.Node(output=0.5)
a = nengo.Ensemble(n,
1,
max_rates=max_rates,
intercepts=intercepts,
encoders=encoders,
neuron_type=nengo.AdaptiveLIFRate())
nengo.Connection(u, a, synapse=None)
ap = nengo.Probe(a, "spikes", synapse=None)
dt = 1e-3
sim = Simulator(model, dt=dt)
sim.run(2.)
t = sim.trange()
rates = sim.data[ap]
_, ref = tuning_curves(a, sim, eval_points=0.5)
with Plotter(Simulator) as plt:
ax = plt.subplot(211)
implot(plt, t, intercepts[::-1], rates.T / dt, ax=ax)
ax.set_xlabel('time [s]')
ax.set_ylabel('input')
ax = plt.subplot(212)
ax.plot(intercepts, ref[:, ::-1].T, 'k--')
ax.plot(intercepts, rates[[1, 500, 1000, -1], ::-1].T / dt)
ax.set_xlabel('input')
ax.set_xlabel('rate')
plt.savefig('test_neurons.test_alif_rate.pdf')
plt.close()
# check that initial tuning curve is the same as LIF rates
assert np.allclose(rates[1] / dt, ref, atol=0.1, rtol=1e-3)
# check that curves in firing region are monotonically decreasing
assert np.all(np.diff(rates[1:, intercepts < 0.4], axis=0) < 0)
def convert_dense(self, model, pre_layer, input_shape, index,
onnx_model_graph):
onnx_model_graph_node = onnx_model_graph.node
node_info = onnx_model_graph_node[index]
dense_num = self.get_dense_num(node_info, onnx_model_graph)
neuron_type = self.get_neuronType(
index,
onnx_model_graph_node) # node들 지나다니면서 - neuron이 op_type이 어떤건지 찾음
with model:
x = nengo_dl.Layer(
tf.keras.layers.Dense(units=dense_num))(pre_layer)
if neuron_type != "softmax":
if neuron_type == "lif":
x = nengo_dl.Layer(nengo.LIF(amplitude=self.amplitude))(x)
elif neuron_type == "lifrate":
x = nengo_dl.Layer(
nengo.LIFRate(amplitude=self.amplitude))(x)
elif neuron_type == "adaptivelif":
x = nengo_dl.Layer(
nengo.AdaptiveLIF(amplitude=self.amplitude))(x)
elif neuron_type == "adaptivelifrate":
x = nengo_dl.Layer(
nengo.AdaptiveLIFRate(amplitude=self.amplitude))(x)
elif neuron_type == "izhikevich":
x = nengo_dl.Layer(
nengo.Izhikevich(amplitude=self.amplitude))(x)
elif neuron_type == "softlifrate":
x = nengo_dl.Layer(
nengo_dl.neurons.SoftLIFRate(
amplitude=self.amplitude))(x)
elif neuron_type == None: # default neuron_type = LIF
x = nengo_dl.Layer(nengo.LIF(amplitude=self.amplitude))(x)
output_shape = [dense_num, 1]
print('convert Dense finish')
return model, output_shape, x # x를 return 하면서 모델을 계속 쌓아감
