def test_set_dir(self):
dir = 'unittest'
pre = utils.RES_DIR + '/'
utils.set_dir(dir)
post = utils._current_dir
self.assertTrue(os.path.exists(post))
self.assertEqual(post, utils._current_dir)
self.assertEqual(post[len(pre) - 1:], 'unittest/')
utils.set_dir('test2')
post = utils._current_dir
self.assertTrue(os.path.exists(post))
self.assertEqual(post, utils._current_dir)
self.assertEqual(post[len(pre) - 1:], 'test2/')
def run():
name = sys.argv[1]
# plt.rcParams['figure.facecolor'] = 'Indigo'
# c = circuit.CircuitFix([p for _ in range(9)], synapses=syns, gaps=gaps, labels=labels)
# c.plot()
t, i = datas.full4(dt=dt, nb_neuron_zero=5)
i[:, :, :] = i[:, :, [0, 1, 4, 5, 6, 7, 8, 2, 3]]
_, itest = datas.full4_test(dt=dt, nb_neuron_zero=5)
itest[:, :, :] = itest[:, :, [0, 1, 4, 5, 6, 7, 8, 2, 3]]
dir = utils.set_dir('Tapwith_' + name)
n_out = [4, 5]
train = sim.simul(pars=[p for _ in range(9)],
t=t,
i_injs=i,
synapses=syns,
gaps=gaps,
n_out=n_out,
suffix='train',
labels=labels)
test = sim.simul(pars=[p for _ in range(9)],
t=t,
i_injs=itest,
synapses=syns,
gaps=gaps,
n_out=n_out,
labels=labels,
suffix='test')
# n = nr.BioNeuronTf([rand() for _ in range(9)], dt=dt)
n = nr.Neurons([
nr.NeuronLSTM(dt=dt),
nr.NeuronLSTM(dt=dt),
nr.BioNeuronTf([p for _ in range(5)], dt=dt),
nr.NeuronLSTM(dt=dt),
nr.NeuronLSTM(dt=dt)
])
ctf = CircuitTf(n,
synapses=syns_opt[0],
gaps=gaps_opt[0],
labels=labels,
commands={4, 5},
sensors={0, 1, 7, 8})
ctf.plot(save=True)
exit()
# ctf = CircuitTf.create_random(neurons = n, n_neuron=9, dt=dt, syn_keys={k: v['E']>-60 for k,v in syns.items()}, gap_keys=gaps.keys(), labels=labels, commands={4, 5},
# sensors={0, 1, 7, 8}, n_rand=n_parallel)
copt = CircuitOpt(circuit=ctf)
copt.optimize(subdir=dir,
train=train,
test=test,
n_out=[4, 5],
l_rate=(0.1, 9, 0.95))
def test(nb_neuron, conns, conns_opt, dir, t, i_injs, n_out=[1]):
pars = [p for _ in range(nb_neuron)]
dir = utils.set_dir(dir)
print("Feed with current of shape : ", i_injs.shape)
# train = sim.simul(t, i_injs, pars, conns, n_out=n_out, show=False)
n = nr.BioNeuronTf(init_p=pars, dt=t[1]-t[0])
cr = CircuitTf(n, synapses=conns_opt)
cr.plot(save=True);exit()
c = CircuitOpt(cr)
c.optimize(dir, n_out=n_out, train=train)
def with_LSTM():
dir = utils.set_dir('withLSTM')
conns = {(0, 1): circuit.SYNAPSE}
conns_opt = {(0, 1): circuit.get_syn_rand(True)}
dt = 0.5
t, i = datas.give_train(dt=dt)
i_1 = np.zeros(i.shape)
i_injs = np.stack([i, i_1], axis=2)
train = sim.simul(t, i_injs, [p, p], conns, n_out=[0, 1], show=False)
neurons = nr.Neurons([nr.BioNeuronTf(PyBioNeuron.get_random(), fixed=[], dt=dt), nr.BioNeuronTf(p, fixed='all', dt=dt)])
c = CircuitTf(neurons=neurons, synapses=conns_opt)
co = CircuitOpt(circuit=c)
co.optimize(dir, train=train, n_out=[0, 1], l_rate=(0.01, 9, 0.95))
class TestNeuronLSTM(TestCase):
dir = utils.set_dir('unittest')
def test_build_graph(self):
l = NeuronLSTM()
i, r = l.build_graph(1)
self.assertEqual(len(i.shape), 2)
l.build_graph(4)
l.build_graph()
def test_init(self):
l = NeuronLSTM()
l.reset()
with self.assertRaises(ReferenceError):
l.hidden_init_state
l.init(1)
l.hidden_init_state
def test_calculate(self):
l = NeuronLSTM(4, 5, 6, 1)
x = l.calculate(np.array([2., 3., 4.]))
self.assertEqual(x.shape[0], 3)
self.assertEqual(x.shape[1], 2)
l = NeuronLSTM(4, 5, 6, 1)
x = l.calculate(np.array([[2., 3.], [2., 3.], [2., 3.]]))
self.assertEqual(x.shape[0], 3)
self.assertEqual(x.shape[1], 2)
self.assertEqual(x.shape[2], 2)
def test_load(self):
l = NeuronLSTM(4, 5, 6, 1)
l.reset()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
l.predump(sess)
with open(self.dir + 'yeee', 'wb') as f:
pickle.dump(l, f)
with open(self.dir + 'yeee', 'rb') as f:
l2 = pickle.load(f)
self.assertEqual(l.dt, l2.dt)
self.assertEqual(l._max_cur, l2._max_cur)
self.assertEqual(l._rest_v, l2._rest_v)
self.assertEqual(l._scale_v, l2._scale_v)
self.assertEqual(l._scale_ca, l2._scale_ca)
self.assertEqual(l._hidden_layer_nb, l2._hidden_layer_nb)
self.assertEqual(l._hidden_layer_size, l2._hidden_layer_size)
self.assertEqual(l._extra_ca, l2._extra_ca)
def show_res(dir, j=-1):
# with open('forward_input', 'rb') as f:
# cur = pickle.load(f)
# cur = cur[:, np.newaxis, :]
from odynn import optim
dir = utils.set_dir(dir)
train, __ = optim.get_data(dir)
cur = train[1]
dic = optim.get_vars(dir, j, loss=True)
best = np.nanargmin(dic['loss'])
print(best)
# dic = {k: np.stack([v[:,1] for _ in range(5)], axis=-1) for k,v in dic.items()}
[print(k, dic[k].shape) for k in dic.keys()]
# print(dic)
# dic = {v: np.array(val, dtype=np.float32) for v,val in dic.items()}
# ctf = cr.CircuitTf.create_random(n_neuron=39, syn_keys=syns_k, gap_keys=gaps_k,
# labels=labels, commands=commands, n_rand=5, fixed='all')
ctf = optim.get_model(dir)
# print(ctf._neurons.parameter_names)
# dic['tau'] = dic['tau'] * 100
# ctf._neurons.init_names()
ctf.init_params = dic
print(ctf.num)
states = ctf.calculate(np.stack([cur for _ in range(ctf.num)], axis=-1))
print(states.shape)
for i in range(ctf.num):
try:
i = best
ctf.plots_output_mult(train[0],
cur[:, 0, i],
states[..., i],
suffix='%s_epoch%s' % (i, j),
show=True,
save=True,
trace=False)
break
except Exception as e:
print(e)
exit(0)
def analyse(dir):
from odynn import optim
import pandas as pd
import seaborn as sns
import pylab as plt
dir = utils.set_dir(dir)
dic = optim.get_vars(dir, loss=True)
train, test = optim.get_data(dir)
df = pd.DataFrame.from_dict({'loss': dic['loss']}) # .head(4)
df = df.sort_values('loss').reset_index(drop=True)
# df = df.dropna()
sns.barplot(x=df.index, y='loss', data=df)
plt.show()
dic = optim.get_best_result(dir)
ctf = optim.get_model(dir)
ctf.plot(save=True)
ctf.init_params = dic
sim.simul(t=train[0], i_injs=train[1], circuit=ctf, show=True, save=True)
sim.simul(t=test[0], i_injs=test[1], circuit=ctf, show=True, save=True)
def table():
import re
neur = cfg_model.NEURON_MODEL
from odynn.models import celeg
dir = utils.set_dir('Integcomp_volt_mod3dt0.1-YES')
best = optim.get_best_result(dir)
for k, v in neur.default_params.items():
v = neur._constraints_dic.get(k, ['-inf', 'inf'])
u = ''
if 'tau' in k:
u = 'ms'
elif 'scale' in k or 'mdp' in k or 'E' in k:
u = 'mV'
elif 'g' in k:
u = 'mS/cm$^2$'
elif k == 'C_m':
u = '$\mu$F/cm$^2$'
else:
u = 'none'
tp = '%s &&& %s & %s&%s&%s&%s \\\\\n \\hline' % (k, v[0], v[1], u, cfg_model.NEURON_MODEL.default_params[k], best[k])
tp = re.sub('(.)__(.*) (&.*&.*&.*&.*&)', '\g<2>_\g<1> \g<3>', tp)
tp = tp.replace('inf', '$\\infty$')
tp = re.sub('scale_(.)', '$V_{scale}^\g<1>$', tp)
tp = re.sub('mdp_(.)', '$V_{mdp}^\g<1>$', tp)
tp = re.sub('tau_(.)', '$\\ tau^\g<1>$', tp)
tp = re.sub('E_(..?)', '$E_{\g<1>}$', tp)
tp = tp.replace('\\ tau', '\\tau')
tp = re.sub('g_([^ ]*) +', '$g_{\g<1>}$ ', tp)
tp = tp.replace('rho_ca', '$\\rho_{Ca}$')
tp = tp.replace('decay_ca', '$\\tau_{Ca}$')
tp = tp.replace('C_m', '$C_m$')
tp = tp.replace('alpha_h', '$\\alpha^h$')
tp = re.sub('(.*tau.*)&&&', '\g<1>&%s&%s&' % (celeg.MIN_TAU, celeg.MAX_TAU), tp)
tp = re.sub('(.*scale.*)&&&', '\g<1>&%s&%s&' % (celeg.MIN_SCALE, celeg.MAX_SCALE), tp)
print(tp)
exit(0)
class TestNeuronTf(TestCase):
dir = utils.set_dir('unittest')
def test_init(self):
hh = BioNeuronTf(init_p=[p for _ in range(10)])
self.assertEqual(len(hh._init_state), len(hh.default_init_state))
self.assertEqual(hh.num, 10)
self.assertEqual(hh._init_state.shape,
(len(hh.default_init_state), hh.num))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(list(hh.init_params.values())[0].shape, (10, ))
self.assertEqual(hh.init_params.keys(), p.keys())
self.assertEqual(hh.parameter_names, list(hh.default_params.keys()))
hh = BioNeuronTf(
init_p={var: [val for _ in range(10)]
for var, val in p.items()})
self.assertEqual(len(hh._init_state), len(hh.default_init_state))
self.assertEqual(hh.num, 10)
self.assertEqual(hh._init_state.shape,
(len(hh.default_init_state), hh.num))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(list(hh.init_params.values())[0].shape, (10, ))
self.assertEqual(hh.init_params.keys(), p.keys())
self.assertEqual(hh.parameter_names, list(hh.default_params.keys()))
hh = BioNeuronTf(init_p=[PyBioNeuron.get_random() for _ in range(13)])
self.assertEqual(len(hh._init_state), len(hh.default_init_state))
self.assertEqual(hh.num, 13)
self.assertEqual(hh._init_state.shape,
(len(hh.default_init_state), hh.num))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(list(hh.init_params.values())[0].shape, (13, ))
self.assertEqual(hh.init_params.keys(), p.keys())
self.assertEqual(hh.parameter_names, list(hh.default_params.keys()))
hh = BioNeuronTf(p)
self.assertEqual(hh.num, 1)
self.assertEqual(hh._init_state.shape, (len(hh.default_init_state), ))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(hh.init_params, p)
self.assertEqual(hh.parameter_names, list(hh.default_params.keys()))
hh = BioNeuronTf(n_rand=15)
self.assertEqual(len(hh._init_state), len(hh.default_init_state))
self.assertEqual(hh.num, 15)
self.assertEqual(hh._init_state.shape,
(len(hh.default_init_state), hh.num))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(list(hh.init_params.values())[0].shape, (15, ))
self.assertEqual(hh.parameter_names, list(hh.default_params.keys()))
def test_init_groups(self):
hh = BioNeuronTf(n_rand=15, groups=np.zeros(15, dtype=np.int32))
hh.reset()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
pars = sess.run(hh._param['C_m'])
for i in range(1, 15):
self.assertEqual(pars[i - 1], pars[i])
hh = BioNeuronTf(n_rand=6, groups=[1, 0, 0, 0, 2, 2])
hh = BioNeuronTf(n_rand=3, groups=[1, 0, 0, 0, 2, 2])
self.assertEqual(hh.parameter_names, list(hh.default_params.keys()))
hh.reset()
loss = tf.square(hh._param['C_m'] - [1., 20., 80., -10., -7., 90.])
train = tf.train.AdamOptimizer(0.1).minimize(loss)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
pars = sess.run(hh._param['C_m'])
self.assertEqual(pars[1], pars[2])
self.assertEqual(pars[1], pars[3])
self.assertEqual(pars[4], pars[5])
sess.run(train)
pars = sess.run(hh._param['C_m'])
self.assertEqual(pars[1], pars[2])
self.assertEqual(pars[1], pars[3])
self.assertEqual(pars[4], pars[5])
with self.assertRaises(ValueError):
hh = BioNeuronTf(n_rand=2, groups=[1, 0, 0, 0, 2, 2])
def test_pickle(self):
hh1 = BioNeuronTf(init_p=[p for _ in range(10)])
with open(self.dir + 'yeee', 'wb') as f:
pickle.dump(hh1, f)
with open(self.dir + 'yeee', 'rb') as f:
hh = pickle.load(f)
self.assertEqual(len(hh._init_state), len(hh.default_init_state))
self.assertEqual(hh.num, 10)
self.assertEqual(hh._init_state.shape,
(len(hh.default_init_state), hh.num))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(list(hh.init_params.values())[0].shape, (10, ))
self.assertEqual(hh.init_params.keys(), p.keys())
self.assertEqual(hh1.parameter_names, hh.parameter_names)
hh = BioNeuronTf(
init_p={var: [val for _ in range(10)]
for var, val in p.items()})
with open(self.dir + 'yeee', 'wb') as f:
pickle.dump(hh, f)
with open(self.dir + 'yeee', 'rb') as f:
hh = pickle.load(f)
self.assertEqual(len(hh._init_state), len(hh.default_init_state))
self.assertEqual(hh.num, 10)
self.assertEqual(hh._init_state.shape,
(len(hh.default_init_state), hh.num))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(list(hh.init_params.values())[0].shape, (10, ))
self.assertEqual(hh.init_params.keys(), p.keys())
hh = BioNeuronTf(init_p=[PyBioNeuron.get_random() for _ in range(13)])
with open(self.dir + 'yeee', 'wb') as f:
pickle.dump(hh, f)
with open(self.dir + 'yeee', 'rb') as f:
hh = pickle.load(f)
self.assertEqual(len(hh._init_state), len(hh.default_init_state))
self.assertEqual(hh.num, 13)
self.assertEqual(hh._init_state.shape,
(len(hh.default_init_state), hh.num))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(list(hh.init_params.values())[0].shape, (13, ))
self.assertEqual(hh.init_params.keys(), p.keys())
hh = BioNeuronTf(n_rand=15)
with open(self.dir + 'yeee', 'wb') as f:
pickle.dump(hh, f)
with open(self.dir + 'yeee', 'rb') as f:
hh = pickle.load(f)
self.assertEqual(len(hh._init_state), len(hh.default_init_state))
self.assertEqual(hh.num, 15)
self.assertEqual(hh._init_state.shape,
(len(hh.default_init_state), hh.num))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(list(hh.init_params.values())[0].shape, (15, ))
hh = BioNeuronTf(p)
with open(self.dir + 'yeee', 'wb') as f:
pickle.dump(hh, f)
with open(self.dir + 'yeee', 'rb') as f:
hh = pickle.load(f)
self.assertEqual(hh.num, 1)
self.assertEqual(hh._init_state.shape, (len(hh.default_init_state), ))
self.assertIsInstance(hh.init_params, dict)
self.assertEqual(hh.init_params, p)
def test_parallelize(self):
n = BioNeuronTf(init_p=p)
sh = list(n._init_state.shape)
n.parallelize(10)
sh.append(10)
shp = (10, )
self.assertEqual(n._init_state.shape, tuple(sh))
self.assertEqual(list(n.init_params.values())[0].shape, tuple(shp))
n = BioNeuronTf(init_p=[p for _ in range(8)])
sh = list(n._init_state.shape)
shp = list(list(n.init_params.values())[0].shape)
n.parallelize(11)
sh.append(11)
shp.append(11)
self.assertEqual(n._init_state.shape, tuple(sh))
self.assertEqual(list(n.init_params.values())[0].shape, tuple(shp))
def test_build_graph(self):
n = BioNeuronTf(init_p=p)
nn = BioNeuronTf(init_p=[p for _ in range(8)])
i, res = n.build_graph()
self.assertEqual(i.get_shape().as_list(), [None])
i, res = n.build_graph(3)
self.assertEqual(i.get_shape().as_list(), [None, None])
i, res = n.build_graph(batch=1)
self.assertEqual(i.get_shape().as_list(), [None, None])
i, res = nn.build_graph()
self.assertEqual(i.get_shape().as_list(), [None, 8])
i, res = nn.build_graph(1)
self.assertEqual(i.get_shape().as_list(), [None, None, 8])
i, res = nn.build_graph(batch=4)
self.assertEqual(i.get_shape().as_list(), [None, None, 8])
def test_calculate(self):
n = BioNeuronTf(init_p=p)
nn = BioNeuronTf(init_p=[p for _ in range(8)])
i = np.array([2., 3., 0.])
ii = np.array([[2., 2.], [3., 3.], [0., 0.]])
x = n.calculate(i)
self.assertEqual(n._init_state.shape[0], x.shape[1])
self.assertEqual(x.shape[0], len(i))
x = n.calculate(ii)
self.assertEqual(ii.shape[1], x.shape[2])
self.assertEqual(x.shape[0], ii.shape[0]) # same time
self.assertEqual(x.shape[1], n._init_state.shape[0])
self.assertEqual(x.shape[2], ii.shape[1]) # same nb of batch
x = nn.calculate(i) #several neurons, one batch
self.assertEqual(x.shape[-1], nn.num)
self.assertEqual(x.shape[0], len(i))
self.assertEqual(x.shape[1], nn._init_state.shape[0])
xx2 = nn.calculate(ii) #several neurons, several batches
xx = nn.calculate(
np.stack([ii for _ in range(8)],
axis=ii.ndim)) # several neurons, several batches
self.assertEqual(xx.shape[-1], nn.num)
self.assertEqual(xx.shape[0], ii.shape[0]) # same time
self.assertEqual(xx.shape[1], nn._init_state.shape[0])
self.assertEqual(xx.shape[2], ii.shape[1]) # same nb of batch
self.assertEqual(xx.all(), xx2.all())
for i, m in enumerate(cfg_model.models):
if cfg_model.NEURON_MODEL == m:
suffix = cfg_model.models_name[i] + suffix
break
if fake:
suffix = suffix + 'fake'
else:
suffix = suffix + 'real'
if eq_cost:
suffix = suffix + 'eqcost'
else:
suffix = suffix + 'difcost'
suffix = suffix + str(dt)
name = 'Forward_{}'.format(suffix)
dir = utils.set_dir(name)
with open(dir + 'settings_fw', 'w') as f:
f.write('eq_cost : %s' % eq_cost + '\n' + 'fake : %s' % fake + '\n' +
'model %s' % cfg_model.NEURON_MODEL)
with open('forward_target', 'rb') as f:
res = pickle.load(f)
print(cur.shape)
print(res.shape)
if fake:
for i in range(4, len(labels)):
res[:, i + 1] = np.roll(res[:, i], int(64 / dt), axis=0)
# for i in range(rev_labels['DD1'], rev_labels['VB11']+1):
from unittest import TestCase
from odynn import utils, datas
from odynn.neuron import NeuronLSTM, BioNeuronTf, PyBioNeuron
from odynn.noptim import NeuronOpt
from odynn.nsimul import simul
from odynn import optim
import tensorflow as tf
import numpy as np
dir = utils.set_dir('unittest')
dt = 0.5
t, i = datas.give_train(dt=dt, max_t=5.)
default = PyBioNeuron.default_params
pars = PyBioNeuron.get_random()
train = simul(p=default, dt=dt, i_inj=i, show=False, suffix='train')
plot = False
nr = BioNeuronTf(init_p=pars, dt=dt)
class TestNeuronOpt(TestCase):
def test_init(self):
with self.assertRaises(TypeError):
no = NeuronOpt(5)
def test_loss(self):
co = NeuronOpt(nr)
res = tf.zeros((len(t), len(PyBioNeuron.default_init_state), 3))
ys_ = [
tf.placeholder(shape=(len(t), 3), dtype=tf.float32, name="test")
] + [
tf.placeholder(shape=(len(t), 3), dtype=tf.float32, name="test")
import numpy as np from odynn import utils, nsimul, neuron, noptim #This file defines the model we will use from odynn.models import cfg_model dt = 1. folder = 'Example' # Function to call to set the target directories for plots and saved files dir = utils.set_dir(folder) #Definition of time and 2 input currents t = np.arange(0., 1200., dt) i_inj1 = 10. * ((t > 200) & (t < 600)) + 20. * ((t > 800) & (t < 1000)) i_inj2 = 5. * ((t > 200) & (t < 300)) + 30. * ((t > 500) & (t < 1000)) i_injs = np.stack([i_inj1, i_inj2], axis=-1) #10 random initial parameters params = [cfg_model.NEURON_MODEL.get_random() for _ in range(10)] neuron = neuron.BioNeuronTf(params, dt=dt) #This function will take the default parameters of the used model if none is given train = nsimul.simul(t=t, i_inj=i_injs, show=True) #Optimization optimizer = noptim.NeuronOpt(neuron) optimizer.optimize(dir=dir, train=train)
def leak_box(df):
utils.box(df, ['b', 'g', 'Gold'], ['C_m', 'g_L', 'E_L'])
plt.title('Membrane')
utils.save_show(True, True, 'box1', dpi=300)
if __name__ == '__main__':
from odynn.nsimul import simul
import scipy as sp
t = sp.arange(0., 1200., 0.1)
i = 20. * ((t>400) & (t<800))
simul(t=t, i_inj=i, show=True);exit()
dir = utils.set_dir('Tapwith_dt0.5')
dic = optim.get_vars(dir, loss=False)
# df = pd.DataFrame.from_dict(dic)
# df = df.dropna()
# dfdisp = (df - df.mean()) / df.std()
# plt.plot(dfdisp.transpose())
# utils.save_show(True, True, 'dispreal', dpi=300)
dd = optim.get_vars_all(dir, losses=True)
optim.plot_loss_rate(dd['loss'], dd['rates'], dd['loss_test'], 50, show=True)
from odynn import datas
dic = optim.get_vars(dir, loss=True)
train, test = optim.get_data(dir)
print(dic['loss'])
import odynn.csimul as csim
import odynn.neuron as nr
import tensorflow as tf
n_neuron = 2
conns = {
(0, 1): odynn.circuit.SYNAPSE_inhib,
(1, 0): odynn.circuit.SYNAPSE_inhib
}
conns_opt = {
(0, 1): odynn.circuit.get_syn_rand(False),
(1, 0): odynn.circuit.get_syn_rand(False)
}
conns_opt_parallel = [conns_opt for _ in range(10)]
dir = 'unittest/'
dir = utils.set_dir(dir)
dt = 0.5
t, i = odynn.datas.give_train(dt=dt, max_t=5.)
length = int(5. / 0.5)
i_1 = np.zeros(i.shape)
i_injs = np.stack([i, i_1], axis=2)
i_injs3 = np.stack([i, i_1, i_1], axis=2)
p = nr.PyBioNeuron.get_random()
pars = [p for _ in range(n_neuron)]
plot = False
evol_var = False
class TestCircuitOpt(TestCase):
