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 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_izhikevich(Simulator, plt, seed, rng): """Smoke test for using Izhikevich neurons. Tests that the 6 parameter sets listed in the original paper can be simulated in Nengo (but doesn't test any properties of them). """ with nengo.Network() as m: u = nengo.Node(output=WhiteSignal(0.6, high=10), size_out=1) # Seed the ensembles (not network) so we get the same sort of neurons ens_args = {'n_neurons': 4, 'dimensions': 1, 'seed': seed} rs = nengo.Ensemble(neuron_type=nengo.Izhikevich(), **ens_args) ib = nengo.Ensemble(neuron_type=nengo.Izhikevich(reset_voltage=-55, reset_recovery=4), **ens_args) ch = nengo.Ensemble(neuron_type=nengo.Izhikevich(reset_voltage=-50, reset_recovery=2), **ens_args) fs = nengo.Ensemble(neuron_type=nengo.Izhikevich(tau_recovery=0.1), **ens_args) lts = nengo.Ensemble(neuron_type=nengo.Izhikevich(coupling=0.25), **ens_args) rz = nengo.Ensemble(neuron_type=nengo.Izhikevich(tau_recovery=0.1, coupling=0.26), **ens_args) ensembles = (rs, ib, ch, fs, lts, rz) out = {} spikes = {} for ens in ensembles: nengo.Connection(u, ens) out[ens] = nengo.Probe(ens, synapse=0.05) spikes[ens] = nengo.Probe(ens.neurons) up = nengo.Probe(u) with Simulator(m, seed=seed + 1) as sim: sim.run(0.6) t = sim.trange() def plot(ens, title, ix): ax = plt.subplot(len(ensembles), 1, ix) plt.title(title) plt.plot(t, sim.data[out[ens]], c='k', lw=1.5) plt.plot(t, sim.data[up], c='k', ls=':') ax = ax.twinx() ax.set_yticks(()) rasterplot(t, sim.data[spikes[ens]], ax=ax) plt.figure(figsize=(10, 12)) plot(rs, "Regular spiking", 1) plot(ib, "Intrinsically bursting", 2) plot(ch, "Chattering", 3) plot(fs, "Fast spiking", 4) plot(lts, "Low-threshold spiking", 5) plot(rz, "Resonator", 6)
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 하면서 모델을 계속 쌓아감
with model: stim = nengo.Node(0) a = nengo.Ensemble(n_neurons=50, dimensions=1, neuron_type=nengo.LIF(tau_rc=0.02, tau_ref=0.002)) b = nengo.Ensemble(n_neurons=50, dimensions=1, neuron_type=nengo.LIFRate(tau_rc=0.02, tau_ref=0.002)) #c = nengo.Ensemble(n_neurons=50, dimensions=1, # neuron_type=nengo.Sigmoid(tau_ref=0.002)) d = nengo.Ensemble(n_neurons=50, dimensions=1, neuron_type=nengo.RectifiedLinear()) e = nengo.Ensemble(n_neurons=50, dimensions=1, neuron_type=nengo.Izhikevich(tau_recovery=0.02, coupling=0.2, reset_voltage=-65, reset_recovery=8)) nengo.Connection(stim, a) nengo.Connection(stim, b) #nengo.Connection(stim, c) nengo.Connection(stim, d) nengo.Connection(stim, e)
from nengo.processes import WhiteSignal import matplotlib.pyplot as plt from nengo.utils.matplotlib import rasterplot import json json_data = open("option.json").read() data = json.loads(json_data) print(data) model = nengo.Network() with model: stim = nengo.Node(WhiteSignal(60, high=5), size_out=1) cortex = nengo.Ensemble(n_neurons=int(data["n_neurons"]["cortex"]), dimensions=1, neuron_type=nengo.Izhikevich()) striatum = nengo.Ensemble(n_neurons=int(data["n_neurons"]["striatum"]), dimensions=1, neuron_type=nengo.Izhikevich()) GPe = nengo.Ensemble(n_neurons=int(data["n_neurons"]["GPe"]), dimensions=1, neuron_type=nengo.Izhikevich()) GPi = nengo.Ensemble(n_neurons=int(data["n_neurons"]["GPi"]), dimensions=1, neuron_type=nengo.Izhikevich()) STN = nengo.Ensemble(n_neurons=int(data["n_neurons"]["STN"]), dimensions=1, neuron_type=nengo.Izhikevich()) SNr = nengo.Ensemble(n_neurons=int(data["n_neurons"]["SNr"]), dimensions=1, neuron_type=nengo.Izhikevich())
import matplotlib.pyplot as plt import nengo from nengo.utils.neurons import rates_isi from nengo.utils.ensemble import tuning_curves dur = 0.1 # duration of stimulus dt = 0.0001 # use finer resolution cz of high bursting with nengo.Network() as model: # parameters tuned for EBN/IBN neuron = nengo.Izhikevich(reset_voltage=-70, reset_recovery=2, tau_recovery=0.005) ens = nengo.Ensemble(n_neurons=1, dimensions=1, encoders=[[1]], intercepts=[-0.9], max_rates=[150], neuron_type=neuron) # ens = nengo.Ensemble(n_neurons=1, dimensions=1, encoders=[[1]], # intercepts=[-0.9]) node = nengo.Node(output=lambda t: 1 if t < dur else -1) nengo.Connection(node, ens) sp = nengo.Probe(ens.neurons, attr='spikes') cp = nengo.Probe(ens, attr='input') s = nengo.Simulator(model, dt=dt) s.run(0.1) plt.figure() plt.subplot(221) plt.plot(s.trange(), s.data[sp]) plt.subplot(222) plt.plot(s.trange(), rates_isi(s.trange(), s.data[sp]))
print(f"{datetime.now()-start}") def mkdir(dir_in_quest): if not os.path.isdir(dir_in_quest): os.makedirs(dir_in_quest) from shutil import copy def aggregator(): output_dir = "sim1/" lg = [x/100.0 for x in range(20,-2,-2)] le = [x/100.0 for x in range(20,-2,-2)] for i in lg: for j in le: source_dir_string = str(int(i*100)).zfill(2) + str(int(j*100)).zfill(2) for k in ["a","b","c","d","e"]: source_file = f"{source_dir_string}/{source_dir_string}{k}.png" copy(source_file, output_dir) if __name__ == "__main__" # intrinsically_bursting n_ib = nengo.Izhikevich(reset_voltage=-55, reset_recovery=4) # chattering n_ch = nengo.Izhikevich(reset_voltage=-50, reset_recovery=2) # fast_spiking n_fs = nengo.Izhikevich(tau_recovery=0.1) # low_threshold_spiking n_lts = nengo.Izhikevich(coupling=0.25) # resonator n_rz = nengo.Izhikevich(tau_recovery=0.1, coupling=0.26)
def model_init(self): model = nengo.Network(label='Neuron Scheduler') with model: # running_processes = waiting_processes print(self.running_process_size()) num_cores_node = nengo.Node(self.num_cores) running_size = nengo.Node(output=self.running_process_size() ) # output=running_process_size()) running_procs_size_en = nengo.Ensemble(self.calc_n_neurons, 1, radius=self.num_cores) num_cores_en = nengo.Ensemble(1024, 1, radius=self.num_cores) nengo.Connection(num_cores_node, num_cores_en) avail_procs = nengo.Ensemble(self.calc_n_neurons, 1, radius=self.num_cores) nengo.Connection(num_cores_en, avail_procs) # nengo.Connection(running_procs_size_en, avail_procs.neurons, transform=[[-1]]*calc_n_neurons) nengo.Connection(running_procs_size_en, avail_procs, transform=-1) def can_add_thd_logic(x): x = np.round(x) return x ## New Process Addition waiting_proc_q_top_size = nengo.Node(1) waiting_proc_size = nengo.Ensemble(self.calc_n_neurons, 1, radius=self.num_cores) def waiting_q_input_logic(x): if x <= 0: return self.num_cores * 2 else: return x # nengo.Connection(waiting_proc_q_top_size,waiting_proc_size,function=waiting_q_input_logic) can_add_next_proc = nengo.Ensemble(self.calc_n_neurons, 1) next_proc_size_check = nengo.Ensemble( self.calc_n_neurons, 1, radius=self.num_cores, neuron_type=nengo.neurons.SpikingRectifiedLinear()) next_proc_size_check.intercepts = Choice([-.1]) nengo.Connection(avail_procs, next_proc_size_check) nengo.Connection(waiting_proc_size, next_proc_size_check, transform=-1) def can_add_next_proc_logic(x): if x > 0: return 1 else: return 0 nengo.Connection(next_proc_size_check, can_add_next_proc, function=can_add_thd_logic) ### Add New ## Queue Repr: qsim_waiting = nengo.Node(self.queue_nodes.output_message, size_out=3) qsim_add_spike = nengo.Node(self.queue_nodes.input_message, size_in=1, size_out=1) v = nengo.Ensemble(32, 3, radius=128) nengo.Connection(qsim_waiting, v) nengo.Connection(qsim_waiting[0], waiting_proc_size, function=waiting_q_input_logic) # nengo.Connection(qsim_waiting[1] , running_procs_size_en) add_new_proc_system = nengo.Ensemble( self.calc_n_neurons, 1, radius=2, neuron_type=nengo.Izhikevich(reset_recovery=0)) nengo.Connection(can_add_next_proc, add_new_proc_system, function=np.ceil) nengo.Connection(running_size, running_procs_size_en) ## Filter for spikes: nengo.Connection(add_new_proc_system, qsim_add_spike) # deepcode ignore MultiplyList: Pointing to the list is okay here since neurons are read-only nengo.Connection(qsim_add_spike, add_new_proc_system.neurons, transform=[[-1]] * self.calc_n_neurons) ## RR Clock clock_input = nengo.Node(size_out=1) check_proc_ens = nengo.Ensemble(self.calc_n_neurons, dimensions=2) rr_clock = nengo.Network() with rr_clock: def node_tick_clock(t): t = np.round(t) % 10 return t def neuron_timer_check(x): nv = x[0] if x[0] > 10: nv = 0 else: nv = x[0] return nv stim = nengo.Node(1) inhibition = nengo.Node(0) interupt_proc = nengo.Ensemble(n_neurons=1024, dimensions=1) c = nengo.Ensemble(n_neurons=1024, dimensions=1) nengo.Connection(stim, interupt_proc) nengo.Connection(c, interupt_proc.neurons, transform=[[-2.5]] * 1024) nengo.Connection(inhibition, c) clock = nengo.Node(node_tick_clock) time_slice = nengo.Node(10) cl_enc = nengo.Ensemble(1024, dimensions=1, radius=25) ts_enc = nengo.Ensemble(1024, dimensions=1, radius=25) nengo.Connection(time_slice, ts_enc, function=lambda x: x % self.time_slice_ticks) nengo.Connection(clock, cl_enc) time_check = nengo.Ensemble(1024, dimensions=1, radius=20) # summation = nengo.networks. tau = 0.1 nengo.Connection(cl_enc, time_check, synapse=tau, function=neuron_timer_check) nengo.Connection(time_check, c) qsim_running_interrupt = nengo.Node(size_in=1, size_out=0) nengo.Connection(interupt_proc, qsim_running_interrupt) self.model = model self.sim = nengo.Simulator(model)
# To use it, use a `nengo.Izhikevich` instance # as the `neuron_type` of an ensemble. # In[ ]: import numpy as np import matplotlib.pyplot as plt import nengo from nengo.utils.matplotlib import rasterplot # In[ ]: with nengo.Network(seed=0) as model: u = nengo.Node(lambda t: np.sin(2 * np.pi * t)) ens = nengo.Ensemble(10, dimensions=1, neuron_type=nengo.Izhikevich()) nengo.Connection(u, ens) # In addition to the usual decoded output and neural activity # that can always be probed, # you can probe the voltage and recovery terms # of the Izhikevich model. # In[ ]: with model: out_p = nengo.Probe(ens, synapse=0.03) spikes_p = nengo.Probe(ens.neurons) voltage_p = nengo.Probe(ens.neurons, 'voltage') recovery_p = nengo.Probe(ens.neurons, 'recovery')