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 하면서 모델을 계속 쌓아감