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')
