def pif_reset():
defaultclock.reinit()
sim = Network()
I = 0.2*nA
R = 1*Mohm
lifeq = """
dV/dt = I*R/ms : volt
Vth : volt
"""
thstep = 15*mV
nrn = NeuronGroup(1, lifeq, threshold="V>=Vth", reset="V=0*mV")
nrn.V = 0*mV
nrn.Vth = thstep
sim.add(nrn)
#connection = Connection(inputgrp, nrn, state="V", weight=0.5*mV)
#sim.add(inputgrp, connection)
vmon = StateMonitor(nrn, "V", record=True)
thmon = StateMonitor(nrn, "Vth", record=True)
spikemon = SpikeMonitor(nrn, record=True)
sim.add(vmon, thmon, spikemon)
sim.run(duration)
return vmon, thmon, spikemon
def ousim(mu_amp, mu_offs, sigma_amp, sigma_offs, freq, V_th):
# mu_amp, mu_offs, sigma_amp, sigma_offs, freq, V_th = config
if sigma_amp > sigma_offs:
sigma_amp = sigma_offs
# print("Setting up OU LIF simulation...")
ounet = Network()
clock.reinit_default_clock()
eqs =Equations('dV/dt = mu-(V+V0)/tau + sigma*I/sqrt(dt) : volt')
eqs+=Equations('dI/dt = -I/dt + xi/sqrt(dt) : 1')
eqs+=Equations('mu = mu_amp*sin(t*freq*2*pi) + mu_offs : volt/second')
eqs+=Equations('sigma = sigma_amp*sin(t*freq*2*pi) + sigma_offs :'
' volt/sqrt(second)')
eqs.prepare()
ounrn = NeuronGroup(1, eqs, threshold=V_th, refractory=t_refr,
reset=V_reset)
ounet.add(ounrn)
ounrn.V = V0
V_mon = StateMonitor(ounrn, 'V', record=True)
st_mon = SpikeMonitor(ounrn)
ounet.add(V_mon, st_mon)
ounet.run(duration)
V_mon.insert_spikes(st_mon, value=V_th*2)
times = V_mon.times
membrane = V_mon[0]
return times, st_mon.spiketimes[0], membrane
def run(self, **param_values):
delays = param_values.pop('delays', zeros(self.neurons))
# print self.refractory,self.max_refractory
if self.max_refractory is not None:
refractory = param_values.pop('refractory', zeros(self.neurons))
else:
refractory = self.refractory*ones(self.neurons)
tau_metric = param_values.pop('tau_metric', zeros(self.neurons))
self.update_neurongroup(**param_values)
# repeat spike delays and refractory to take slices into account
delays = kron(delays, ones(self.slices))
refractory = kron(refractory, ones(self.slices))
tau_metric = kron(tau_metric, ones(self.slices))
# TODO: add here parameters to criterion_params if a criterion must use some parameters
criterion_params = dict(delays=delays)
if self.criterion.__class__.__name__ == 'Brette':
criterion_params['tau_metric'] = tau_metric
self.update_neurongroup(**param_values)
self.initialize_criterion(**criterion_params)
if self.use_gpu:
# Reinitializes the simulation object
self.mf.reinit_vars(self.criterion_object,
self.inputs_inline, self.inputs_offset,
self.spikes_inline, self.spikes_offset,
self.traces_inline, self.traces_offset,
delays, refractory
)
# LAUNCHES the simulation on the GPU
self.mf.launch(self.sliced_duration, self.stepsize)
# Synchronize the GPU values with a call to gpuarray.get()
self.criterion_object.update_gpu_values()
else:
# set the refractory period
if self.max_refractory is not None:
self.group.refractory = refractory
# Launch the simulation on the CPU
self.group.clock.reinit()
net = Network(self.group, self.criterion_object)
if self.statemonitor_var is not None:
self.statemonitors = []
for state in self.statemonitor_var:
monitor = StateMonitor(self.group, state, record=True)
self.statemonitors.append(monitor)
net.add(monitor)
net.run(self.sliced_duration)
sliced_values = self.criterion_object.get_values()
combined_values = self.combine_sliced_values(sliced_values)
values = self.criterion_object.normalize(combined_values)
return values
def setup_sims(neuron_params, input_params, duration):
fin = input_params.get("fin")
fout = input_params.get("fout")
weight = input_params.get("weight")
num_inp = input_params.get("num_inp")
sync_configs = input_params.get("sync")
if fin is None:
fin = sl.tools.calibrate_frequencies(neuron_params,
N_in=num_inp, w_in=weight,
f_out=fout,
synchrony_conf=sync_configs)
brian.clear(True)
gc.collect()
brian.defaultclock.reinit()
neurons = NeuronGroup(N=len(sync_configs), **neuron_params)
simulation = Network(neurons)
input_groups = []
for idx, (inrate, (sync, jitter)) in enumerate(zip(fin, sync_configs)):
inp_grp = sl.tools.fast_synchronous_input_gen(num_inp,
inrate*Hz,
sync, jitter,
duration)
simulation.add(inp_grp)
inp_conn = Connection(inp_grp, neurons[idx], state='V', weight=weight)
input_groups.append(inp_grp)
simulation.add(inp_conn)
tracemon = StateMonitor(neurons, 'V', record=True)
spikemon = SpikeMonitor(neurons)
inputmons = [SpikeMonitor(igrp) for igrp in input_groups]
simulation.add(tracemon, spikemon, inputmons)
monitors = {"inputs": inputmons, "outputs": spikemon, "traces": tracemon}
return simulation, monitors
def lifsim(mu_amp, mu_offs, simga_amp, sigma_offs, freq, V_th):
lifnet = Network()
clock.reinit_default_clock()
eqs = Equations('dV/dt = (-V+V0)/tau : volt')
eqs.prepare()
lifnrn = NeuronGroup(1, eqs, threshold=V_th, refractory=t_refr,
reset=V_reset)
lifnet.add(lifnrn)
pulse_times = (np.arange(1, duration*freq, 1)+0.25)/freq
pulse_spikes = []
Npoiss = 5000
Npulse = 5000
wpoiss = (mu_offs-mu_amp)/(Npoiss*freq)
wpulse = mu_amp/(Npulse*freq)
sigma = 1/(freq*5)
if (wpulse != 0):
for pt in pulse_times:
pp = PulsePacket(t=pt*second, n=Npulse, sigma=sigma)
pulse_spikes.extend(pp.spiketimes)
pulse_input = SpikeGeneratorGroup(Npulse, pulse_spikes)
pulse_conn = Connection(pulse_input, lifnrn, 'V', weight=wpulse)
lifnet.add(pulse_input, pulse_conn)
if (wpoiss != 0):
poiss_input = PoissonGroup(Npoiss, freq)
poiss_conn = Connection(poiss_input, lifnrn, 'V', weight=wpoiss)
lifnet.add(poiss_input, poiss_conn)
V_mon = StateMonitor(lifnrn, 'V', record=True)
st_mon = SpikeMonitor(lifnrn)
lifnet.add(V_mon, st_mon)
lifnet.run(duration)
V_mon.insert_spikes(st_mon, value=V_th*2)
times = V_mon.times
membrane = V_mon[0]
return times, st_mon.spiketimes[0], membrane
def runsim(Nin, weight, fout, sync):
sim = Network()
clear(True)
gc.collect()
defaultclock.reinit()
duration = 5*second
lifeq = "dV/dt = -V/(10*ms) : volt"
nrndef = {"model": lifeq, "threshold": "V>=15*mV", "reset": "V=0*mV",
"refractory": 2*ms}
fin = load_or_calibrate(nrndef, Nin, weight, sync, fout,
Vth=15*mV, tau=10*ms)
# print("Calibrated frequencies:")
# print(", ".join(str(f) for f in fin))
inputgroups = []
connections = []
neurons = []
Nneurons = len(fin)
neurons = NeuronGroup(Nneurons, **nrndef)
for idx in range(Nneurons):
fin_i = fin[idx]
sync_i, sigma_i = sync[idx]
inputgrp = sl.tools.fast_synchronous_input_gen(Nin, fin_i,
sync_i, sigma_i,
duration)
defaultclock.reinit()
conn = Connection(inputgrp, neurons[idx], state="V", weight=weight)
inputgroups.append(inputgrp)
connections.append(conn)
voltagemon = StateMonitor(neurons, "V", record=True)
spikemon = SpikeMonitor(neurons, record=True)
sim.add(neurons, voltagemon, spikemon)
sim.add(*inputgroups)
sim.add(*connections)
print("Running {} {} {}".format(Nin, weight, fout))
sim.run(duration, report="stdout")
mnpss = []
allnpss = []
for idx in range(Nneurons):
vmon = voltagemon[idx]
smon = spikemon[idx]
# print("Desired firing rate: {}".format(fout))
# print("Actual firing rate: {}".format(len(smon)/duration))
if len(smon) > 0:
npss = sl.tools.npss(vmon, smon, 0*mV, 15*mV, 10*ms, 2*ms)
else:
npss = 0
mnpss.append(np.mean(npss))
allnpss.append(npss)
nrndeftuple = tuple(nrndef.items())
key = (nrndeftuple, Nin, weight, tuple(sync), fout, 15*mV, 10*ms)
save_data(key, allnpss)
imshape = (len(sigma), len(Sin))
imextent = (0, 1, 0, 4.0)
mnpss = np.reshape(mnpss, imshape, order="F")
plt.figure()
plt.imshow(mnpss, aspect="auto", origin="lower", extent=imextent,
interpolation="none", vmin=0, vmax=1)
cbar = plt.colorbar()
cbar.set_label("$\overline{M}$")
plt.xlabel("$S_{in}$")
plt.ylabel("$\sigma_{in}$ (ms)")
filename = "npss_{}_{}_{}".format(Nin, weight, fout).replace(".", "")
plt.savefig(filename+".pdf")
plt.savefig(filename+".png")
print("{} saved".format(filename))
voltages = voltagemon.values
spiketrains = spikemon.spiketimes.values()
pickle.dump({"voltages": voltages, "spiketrains": spiketrains},
open(filename+".pkl", 'w'))
return voltagemon, spikemon
def runsim(fin):
clear(True)
gc.collect()
defaultclock.reinit()
weight = 0.16*mV
sim = Network()
duration = 2.0*second
Vth = 15*mV
Vreset = 13.65*mV
trefr = 2*ms
lifeq = """
dV/dt = -V/(10*ms) : volt
Vth : volt
"""
nrndef = {"model": lifeq, "threshold": "V>=Vth", "reset": "V=Vreset",
"refractory": 0.1*ms}
inputgroups = []
connections = []
neurons = []
Nneurons = len(fin)
neurons = NeuronGroup(Nneurons, **nrndef)
neurons.V = 0*mV
neurons.Vth = 15*mV
for idx in range(Nneurons):
fin_i = fin[idx]*Hz
inputgrp = PoissonGroup(50, fin_i)
conn = Connection(inputgrp, neurons[idx], state="V", weight=weight)
inputgroups.append(inputgrp)
connections.append(conn)
voltagemon = StateMonitor(neurons, "V", record=True)
spikemon = SpikeMonitor(neurons, record=True)
sim.add(neurons, voltagemon, spikemon)
sim.add(*inputgroups)
sim.add(*connections)
@network_operation
def refractory_threshold(clock):
for idx in range(Nneurons):
if (len(spikemon.spiketimes[idx])
and clock.t < spikemon.spiketimes[idx][-1]*second+trefr):
neurons.Vth[idx] = 100*mV
else:
neurons.Vth[idx] = Vth
sim.add(refractory_threshold)
print("Running simulation of {} neurons for {} s".format(Nneurons, duration))
sim.run(duration, report="stdout")
mnpss = []
allnpss = []
outisi = []
for idx in range(Nneurons):
vmon = voltagemon[idx]
smon = spikemon[idx]
if not len(smon):
continue
outisi.append(duration*1000/len(smon))
if len(smon) > 0:
npss = sl.tools.npss(vmon, smon, 0*mV, 15*mV, 10*ms, 2*ms)
else:
npss = 0
mnpss.append(np.mean(npss))
allnpss.append(npss)
return outisi, mnpss
import numpy as np import sys sim = Network() duration = 200*ms dt = 0.1*ms tau = 10*ms Vth = 15*mV Vreset = 0*mV Vreset = 13.65*mV lifeq = "dV/dt = -V/tau : volt" lifnrn = NeuronGroup(1, lifeq, threshold="V>=Vth", reset=Vreset) lifnrn.V = Vreset sim.add(lifnrn) Nin = 200 fin = 80*Hz Sin = 0.6 sigma = 0.0*ms weight = 0.1*mV inputs = sl.tools.fast_synchronous_input_gen(Nin, fin, Sin, sigma, duration) connection = Connection(inputs, lifnrn, "V", weight=weight) sim.add(inputs, connection) vmon = StateMonitor(lifnrn, "V", record=True) spikemon = SpikeMonitor(lifnrn) sim.add(vmon, spikemon) sim.run(duration)
def runsim(neuron_model,
# sim params
dt, simtime, prerun, monitors, recvars,
# stimulation params
fstim, r0_bg, r0_stim, stim_starts, stim_stops, stim_odors, stim_amps, stim_start_var,
# network params
beeid, N_glu, N_KC, ORNperGlu, PNperKC, PN_I0, LN_I0,
# network weights
wi, wORNLN, wORNPN, wPNKC,
# default params
V0min, inh_struct=None, Winh=None, timestep=500, report=None):
np.random.seed() #needed for numpy/brian when runing parallel sims
define_default_clock(dt=dt)
inh_on_off = 0 if (wi == 0) or (wi is None) or (wORNLN is None) else 1
######################### NEURONGROUPS #########################
NG = dict()
# ORN Input
# For each glumerolus, random temporal response jitter can be added.
# The jitter is added to the response onset. Maximum jitter is given by stim_start_var.
# stim_start_jittered is a vector containing the jittered stim start tims
# orn_activation returns a booolean vector of stim presence given time t
# Total ORN rate: Baseline componenent equal for all units,
# and individual activationa.
jitter = np.random.uniform(0,stim_start_var,N_glu)
stim_tun = lambda odorN: fstim(N_glu=N_glu, odorN=odorN) * r0_stim
orn_activation = lambda t: np.sum([
a*stim_tun(odorN=o)*np.logical_and(np.greater(t,prerun+stim_start+jitter), np.less(t,prerun+stim_stop))
for stim_start,stim_stop,o,a in zip(stim_starts, stim_stops, stim_odors, stim_amps)], 0)
orn_rates = lambda t: np.repeat(r0_bg + orn_activation(t),repeats = ORNperGlu)
NG['ORN'] = PoissonGroup(ORNperGlu*N_glu, rates=orn_rates)
NG['PN'] = NeuronGroup(N_glu, **neuron_model)
NG['LN'] = NeuronGroup(N_glu*inh_on_off, **neuron_model)
if 'KC' in monitors: NG['KC'] = NeuronGroup(N_KC, **neuron_model)
######################### CONNECTIONS #########################
c = dict()
c['ORNPN'] = Connection(NG['ORN'],NG['PN'],'ge')
for i in np.arange(N_glu): c['ORNPN'].connect_full(NG['ORN'].subgroup(ORNperGlu),NG['PN'][i],weight=wORNPN)
if inh_on_off:
print('-- inhibiting --',wi)
c['ORNLN'] = Connection(NG['ORN'],NG['LN'],'ge')
c['LNPN'] = Connection(NG['LN'],NG['PN'],'gi',weight=(wi*35)/N_glu)
for i in np.arange(N_glu):
c['ORNLN'].connect_full(NG['ORN'][ i*ORNperGlu : (i+1)*ORNperGlu ],
NG['LN'][i],
weight = wORNLN)
if inh_struct: c['LNPN'].connect(NG['LN'],NG['PN'],Winh)
if 'KC' in monitors:
c['KC'] = Connection(NG['PN'],NG['KC'],'ge')
c['KC'].connect_random(NG['PN'],NG['KC'],p=PNperKC/float(N_glu),weight=wPNKC,seed=beeid)
######################### INITIAL VALUES #########################
VT = neuron_model['threshold']
NG['PN'].vm = np.random.uniform(V0min,VT,size=len(NG['PN']))
if inh_on_off:
NG['LN'].vm= np.random.uniform(V0min,VT,size=len(NG['LN']))
if 'KC' in monitors:
NG['KC'].vm= np.random.uniform(V0min,VT,size=len(NG['KC']))
net = Network(NG.values(), c.values())
#### Compensation currents ###
NG['PN'].I0 = PN_I0
NG['LN'].I0 = LN_I0
##########################################################################
######################### PRE-RUN #########################
net.run(prerun)
######################### MONITORS #########################
spmons = [SpikeMonitor(NG[mon], record=True) for mon in monitors]
net.add(spmons)
if len(recvars) > 0:
mons = [MultiStateMonitor(NG[mon], vars=recvars, record=True, timestep=timestep) for mon in monitors]
net.add(mons)
else:
mons = None
######################### RUN #########################
net = run(simtime, report=report)
out_spikes = dict( (monitors[i],np.array(sm.spikes)) for i,sm in enumerate(spmons) )
if mons is not None:
out_mons = dict( (mon,dict((var,statemon.values) for var,statemon in m.iteritems())) for mon,m in zip(monitors,mons))
else:
out_mons = None
#subtract the prerun from spike times, if there are any
for spikes in out_spikes.itervalues():
if len(spikes) != 0:
spikes[:,1] -= prerun
return out_spikes, out_mons
class VirtualSubject:
def __init__(self, subj_id, wta_params=default_params(), pyr_params=pyr_params(), inh_params=inh_params(),
sim_params=simulation_params(), network_class=WTANetworkGroup):
self.subj_id = subj_id
self.wta_params = wta_params
self.pyr_params = pyr_params
self.inh_params = inh_params
self.sim_params = sim_params
self.simulation_clock = Clock(dt=self.sim_params.dt)
self.input_update_clock = Clock(dt=1 / (self.wta_params.refresh_rate / Hz) * second)
self.background_input = PoissonGroup(self.wta_params.background_input_size,
rates=self.wta_params.background_freq, clock=self.simulation_clock)
self.task_inputs = []
for i in range(self.wta_params.num_groups):
self.task_inputs.append(PoissonGroup(self.wta_params.task_input_size,
rates=self.wta_params.task_input_resting_rate, clock=self.simulation_clock))
# Create WTA network
self.wta_network = network_class(params=self.wta_params, background_input=self.background_input,
task_inputs=self.task_inputs, pyr_params=self.pyr_params, inh_params=self.inh_params,
clock=self.simulation_clock)
# Create network monitor
self.wta_monitor = WTAMonitor(self.wta_network, self.sim_params, record_neuron_state=False, record_spikes=False,
record_firing_rate=True, record_inputs=True, save_summary_only=False,
clock=self.simulation_clock)
# Create Brian network and reset clock
self.net = Network(self.background_input, self.task_inputs, self.wta_network,
self.wta_network.connections.values(), self.wta_monitor.monitors.values())
def run_trial(self, sim_params, input_freq):
self.wta_monitor.sim_params=sim_params
self.net.reinit(states=False)
@network_operation(when='start', clock=self.input_update_clock)
def set_task_inputs():
for idx in range(len(self.task_inputs)):
rate = self.wta_params.task_input_resting_rate
if sim_params.stim_start_time <= self.simulation_clock.t < sim_params.stim_end_time:
rate = input_freq[idx] * Hz + np.random.randn() * self.wta_params.input_var
if rate < self.wta_params.task_input_resting_rate:
rate = self.wta_params.task_input_resting_rate
self.task_inputs[idx]._S[0, :] = rate
@network_operation(clock=self.simulation_clock)
def inject_current():
if sim_params.dcs_start_time < self.simulation_clock.t <= sim_params.dcs_end_time:
self.wta_network.group_e.I_dcs = sim_params.p_dcs
self.wta_network.group_i.I_dcs = sim_params.i_dcs
else:
self.wta_network.group_e.I_dcs = 0 * pA
self.wta_network.group_i.I_dcs = 0 * pA
self.net.remove(set_task_inputs, inject_current)
self.net.add(set_task_inputs, inject_current)
self.net.run(sim_params.trial_duration, report='text')
dn/dt=5*(alphan*(1-n)-betan*n) : 1
alphan=-0.01/mV*(v+34*mV)/(exp(-0.1/mV*(v+34*mV))-1)/ms : Hz
betan=0.125*exp(-(v+44*mV)/(80*mV))/ms : Hz
dgExc/dt = -gExc*(1./taue) : siemens
dgInh/dt = -gInh*(1./taui) : siemens
Iapp : amp
'''
neuron = NeuronGroup(len(inputcurrents), eqs, threshold=threshold, method='RK')
sim.add(neuron)
# Init conditions
neuron.v = -65*mV
neuron.Iapp = inputcurrents
neuron.h = 1
# Monitors
vmon = StateMonitor(neuron, 'v', record=True)
nmon = StateMonitor(neuron, 'n', record=True)
sim.add(vmon, nmon)
# Run
sim.run(duration, report='text')
plt.figure("Voltage")
class VirtualSubject:
def __init__(self, subj_id, wta_params=default_params(), pyr_params=pyr_params(), inh_params=inh_params(),
plasticity_params=plasticity_params(), sim_params=simulation_params()):
self.subj_id = subj_id
self.wta_params = wta_params
self.pyr_params = pyr_params
self.inh_params = inh_params
self.plasticity_params = plasticity_params
self.sim_params = sim_params
self.simulation_clock = Clock(dt=self.sim_params.dt)
self.input_update_clock = Clock(dt=1 / (self.wta_params.refresh_rate / Hz) * second)
self.background_input = PoissonGroup(self.wta_params.background_input_size,
rates=self.wta_params.background_freq, clock=self.simulation_clock)
self.task_inputs = []
for i in range(self.wta_params.num_groups):
self.task_inputs.append(PoissonGroup(self.wta_params.task_input_size,
rates=self.wta_params.task_input_resting_rate, clock=self.simulation_clock))
# Create WTA network
self.wta_network = WTANetworkGroup(params=self.wta_params, background_input=self.background_input,
task_inputs=self.task_inputs, pyr_params=self.pyr_params, inh_params=self.inh_params,
plasticity_params=self.plasticity_params, clock=self.simulation_clock)
# Create network monitor
self.wta_monitor = WTAMonitor(self.wta_network, None, None, self.sim_params, record_lfp=False,
record_voxel=False, record_neuron_state=False, record_spikes=False,
record_firing_rate=True, record_inputs=True, record_connections=None,
save_summary_only=False, clock=self.simulation_clock)
# Create Brian network and reset clock
self.net = Network(self.background_input, self.task_inputs, self.wta_network,
self.wta_network.connections.values(), self.wta_monitor.monitors.values())
def run_trial(self, sim_params, input_freq):
self.wta_monitor.sim_params=sim_params
self.net.reinit(states=False)
@network_operation(when='start', clock=self.input_update_clock)
def set_task_inputs():
for idx in range(len(self.task_inputs)):
rate = self.wta_params.task_input_resting_rate
if sim_params.stim_start_time <= self.simulation_clock.t < sim_params.stim_end_time:
rate = input_freq[idx] * Hz + np.random.randn() * self.wta_params.input_var
if rate < self.wta_params.task_input_resting_rate:
rate = self.wta_params.task_input_resting_rate
self.task_inputs[idx]._S[0, :] = rate
@network_operation(clock=self.simulation_clock)
def inject_current():
if sim_params.dcs_start_time < self.simulation_clock.t <= sim_params.dcs_end_time:
self.wta_network.group_e.I_dcs = sim_params.p_dcs
self.wta_network.group_i.I_dcs = sim_params.i_dcs
else:
self.wta_network.group_e.I_dcs = 0 * pA
self.wta_network.group_i.I_dcs = 0 * pA
@network_operation(when='start', clock=self.simulation_clock)
def inject_muscimol():
if sim_params.muscimol_amount > 0:
self.wta_network.groups_e[sim_params.injection_site].g_muscimol = sim_params.muscimol_amount
self.net.remove(set_task_inputs, inject_current, inject_muscimol, self.wta_network.stdp.values())
self.net.add(set_task_inputs, inject_current, inject_muscimol)
if sim_params.plasticity:
self.net.add(self.wta_network.stdp.values())
self.net.run(sim_params.trial_duration, report='text')
#self.wta_monitor.plot()
self.net.remove(set_task_inputs, inject_current, inject_muscimol, self.wta_network.stdp.values())
PoissonInput,
mV, ms, second, Hz)
import numpy as np
network = Network()
tau = 20*ms
eqs = "dV/dt = -V/tau : volt"
lifgroup = NeuronGroup(10, eqs, threshold="V>=(20*mV)", reset=0*mV)
weights = np.linspace(0.1, 1, 10)
rates = np.arange(10, 100, 10)
inputgroups = []
for idx, (w, r) in enumerate(zip(weights, rates)):
inpgrp = PoissonInput(lifgroup[idx], 20, r*Hz, w*mV, state="V")
inputgroups.append(inpgrp)
network.add(lifgroup)
network.add(*inputgroups)
spikemon = SpikeMonitor(lifgroup)
vmon = StateMonitor(lifgroup, "V", record=True)
network.add(spikemon, vmon)
network.run(10*second, report="stdout")
spikes = spikemon.spiketimes.values()
voltage = vmon.values
np.savez("results.npz",
spikes=spikes,
voltages=voltage)
print("DONE")
inputgroups = []
connections = []
print("Setting up ...")
for idx, c in enumerate(configs):
n, f, w = c
inp = PoissonGroup(n, f)
conn = Connection(inp, nrn[idx], state="V", weight=w)
inputgroups.append(inp)
connections.append(conn)
print("\r{}/{}".format(idx + 1, Nsims), end="")
sys.stdout.flush()
print()
spikemon = SpikeMonitor(nrn)
sim.add(*inputgroups)
sim.add(*connections)
sim.add(nrn)
sim.add(spikemon)
duration = 1000 * ms
print("Running for {} s".format(duration))
sim.run(duration, report="text")
plt.figure()
inputvolts = np.array([c[0] * c[1] * c[2] * tau for c in configs])
spikerates = np.array([len(sp) for sp in spikemon.spiketimes.itervalues()])
for idx in range(Nsims):
iv = inputvolts[idx]
sr = spikerates[idx]
plt.plot(iv, sr, "b.")
from brian import (NeuronGroup, Network, StateMonitor,
second, ms, volt, mV)
import numpy as np
import matplotlib.pyplot as plt
network = Network()
XT = -50*mV
DeltaT = 0.05*mV/ms
eqs = "dX/dt = DeltaT*exp((X-XT)/DeltaT) : volt"
neuron = NeuronGroup(1, eqs, threshold="X>=XT", reset=-65*mV)
neuron.X = -65*mV
network.add(neuron)
vmon = StateMonitor(neuron, "X", record=True)
network.add(vmon)
network.run(1*second)
plt.figure("Voltage")
plt.plot(vmon.times, vmon[0])
plt.show()
Nnrns = 4
Ningroups = 1
Nin_per_group = 50
fin = 20*Hz
ingroup_sync = [0.5]
sigma = 0*ms
weight = 2.0*mV
Nallin = Nin_per_group*Ningroups
Nin = 25 # total number of connections each cell receives
lifeq_exc = Equations("dV/dt = (Vrest-V)/tau : volt")
lifeq_exc.prepare()
nrngroup = NeuronGroup(Nnrns, lifeq_exc, threshold="V>Vth", reset=Vrest,
refractory=2*ms)
nrngroup.V = Vrest
network.add(nrngroup)
print("Setting up inputs and connections ...")
ingroups = []
inpconns = []
for ing in range(Ningroups):
ingroup = sl.tools.fast_synchronous_input_gen(Nin_per_group, fin,
ingroup_sync[ing], sigma, duration,
shuffle=False)
inpconn = Connection(ingroup, nrngroup, 'V')
ingroups.append(ingroup)
inpconns.append(inpconn)
inputneurons = []
# CONNECTIONS
Sin = []
for nrn in range(Nnrns):
