def make_model():
sinePeriod = 50
maxFiringRate = 10
refractT = 0.05
for i in range(20):
moose.setClock(i, dt)
############### Create objects ###############
stim = moose.StimulusTable('stim')
spike = moose.RandSpike('spike')
syn = moose.SimpleSynHandler('syn')
fire = moose.IntFire('fire')
stats1 = moose.SpikeStats('stats1')
stats2 = moose.Stats('stats2')
plots = moose.Table('plots')
plot1 = moose.Table('plot1')
plot2 = moose.Table('plot2')
plotf = moose.Table('plotf')
############### Set up parameters ###############
stim.vector = [
maxFiringRate * numpy.sin(x * 2 * numpy.pi / sinePeriod)
for x in range(sinePeriod)
]
stim.startTime = 0
stim.stopTime = sinePeriod
stim.loopTime = sinePeriod
stim.stepSize = 0
stim.stepPosition = 0
stim.doLoop = 1
spike.refractT = refractT
syn.synapse.num = 1
syn.synapse[0].weight = 1
syn.synapse[0].delay = 0
fire.thresh = 100 # Don't want it to spike, just to integrate
fire.tau = 1.0 / maxFiringRate
stats1.windowLength = int(1 / dt)
stats2.windowLength = int(1 / dt)
############### Connect up circuit ###############
moose.connect(stim, 'output', spike, 'setRate')
moose.connect(spike, 'spikeOut', syn.synapse[0], 'addSpike')
moose.connect(spike, 'spikeOut', stats1, 'addSpike')
moose.connect(syn, 'activationOut', fire, 'activation')
moose.connect(stats2, 'requestOut', fire, 'getVm')
moose.connect(plots, 'requestOut', stim, 'getOutputValue')
moose.connect(plot1, 'requestOut', stats1, 'getWmean')
moose.connect(plot2, 'requestOut', stats2, 'getWmean')
moose.connect(plotf, 'requestOut', fire, 'getVm')
def make_network():
size = 1024
dt = 0.2
runsteps = 50
delayMin = 0
delayMax = 4
weightMax = 1
Vmax = 1.0
thresh = 0.4
refractoryPeriod = 0.4
tau = 0.5
connectionProbability = 0.01
random.seed( 123 )
nprand.seed( 456 )
t0 = time.time()
network = moose.IntFire( 'network', size );
syns = moose.SimpleSynHandler( '/network/syns', size );
moose.connect( syns, 'activationOut', network, 'activation', 'OneToOne' )
moose.le( '/network' )
syns.vec.numSynapses = [1] * size
sv = moose.vec( '/network/syns/synapse' )
print(('before connect t = ', time.time() - t0))
mid = moose.connect( network, 'spikeOut', sv, 'addSpike', 'Sparse')
print(('after connect t = ', time.time() - t0))
#print mid.destFields
m2 = moose.element( mid )
m2.setRandomConnectivity( connectionProbability, 5489 )
print(('after setting connectivity, t = ', time.time() - t0))
#network.vec.Vm = [(Vmax*random.random()) for r in range(size)]
network.vec.Vm = nprand.rand( size ) * Vmax
network.vec.thresh = thresh
network.vec.refractoryPeriod = refractoryPeriod
network.vec.tau = tau
numSynVec = syns.vec.numSynapses
print(('Middle of setup, t = ', time.time() - t0))
numTotSyn = sum( numSynVec )
print((numSynVec.size, ', tot = ', numTotSyn, ', numSynVec = ', numSynVec))
for item in syns.vec:
sh = moose.element( item )
sh.synapse.delay = delayMin + (delayMax - delayMin ) * nprand.rand( len( sh.synapse ) )
#sh.synapse.delay = [ (delayMin + random.random() * (delayMax - delayMin ) for r in range( len( sh.synapse ) ) ]
sh.synapse.weight = nprand.rand( len( sh.synapse ) ) * weightMax
print(('after setup, t = ', time.time() - t0))
numStats = 100
stats = moose.SpikeStats( '/stats', numStats )
stats.vec.windowLength = 1 # timesteps to put together.
plots = moose.Table( '/plot', numStats )
convergence = size / numStats
for i in range( numStats ):
for j in range( size/numStats ):
k = i * convergence + j
moose.connect( network.vec[k], 'spikeOut', stats.vec[i], 'addSpike' )
moose.connect( plots, 'requestOut', stats, 'getMean', 'OneToOne' )
#moose.useClock( 0, '/network/syns,/network', 'process' )
moose.useClock( 0, '/network/syns', 'process' )
moose.useClock( 1, '/network', 'process' )
moose.useClock( 2, '/stats', 'process' )
moose.useClock( 3, '/plot', 'process' )
moose.setClock( 0, dt )
moose.setClock( 1, dt )
moose.setClock( 2, dt )
moose.setClock( 3, dt )
moose.setClock( 9, dt )
t1 = time.time()
moose.reinit()
print(('reinit time t = ', time.time() - t1))
network.vec.Vm = nprand.rand( size ) * Vmax
print(('setting Vm , t = ', time.time() - t1))
t1 = time.time()
print('starting')
moose.start(runsteps * dt)
print(('runtime, t = ', time.time() - t1))
print((network.vec.Vm[99:103], network.vec.Vm[900:903]))
t = [i * dt for i in range( plots.vec[0].vector.size )]
i = 0
for p in plots.vec:
pylab.plot( t, p.vector, label=str( i) )
i += 1
pylab.xlabel( "Time (s)" )
pylab.ylabel( "Vm (mV)" )
pylab.legend()
pylab.show()
def make_network():
"""
This snippet sets up a recurrent network of IntFire objects, using
SimpleSynHandlers to deal with spiking events.
It isn't very satisfactory as activity runs down after a while.
It is a good example for using the IntFire, setting up random
connectivity, and using SynHandlers.
"""
global all_done_
done = mp.Value('i', 0)
q = mp.Queue()
th = mp.Process(target=streamer_handler, args=(done, q))
th.start()
size = 1024
dt = 0.2
runsteps = 10
delayMin = 0
delayMax = 4
weightMax = 1
Vmax = 1.0
thresh = 0.4
refractoryPeriod = 0.4
tau = 0.5
connectionProbability = 0.01
random.seed(123)
np.random.seed(456)
t0 = time.time()
network = moose.IntFire('network', size)
syns = moose.SimpleSynHandler('/network/syns', size)
moose.connect(syns, 'activationOut', network, 'activation', 'OneToOne')
moose.le('/network')
syns.vec.numSynapses = [1] * size
sv = moose.vec('/network/syns/synapse')
print('before connect t = %.3f' % (time.time() - t0))
mid = moose.connect(network, 'spikeOut', sv, 'addSpike', 'Sparse')
print('after connect t = %.3f' % (time.time() - t0))
#print mid.destFields
m2 = moose.element(mid)
m2.setRandomConnectivity(connectionProbability, 5489)
print('after setting connectivity, t=%.3f' % (time.time() - t0))
#network.vec.Vm = [(Vmax*random.random()) for r in range(size)]
network.vec.Vm = np.random.rand(size) * Vmax
network.vec.thresh = thresh
network.vec.refractoryPeriod = refractoryPeriod
network.vec.tau = tau
numSynVec = syns.vec.numSynapses
print('Middle of setup, t = %.3f' % (time.time() - t0))
numTotSyn = sum(numSynVec)
print((numSynVec.size, ', tot = ', numTotSyn, ', numSynVec = ', numSynVec))
for item in syns.vec:
h = moose.element(item)
h.synapse.delay = delayMin + (delayMax - delayMin) * np.random.rand(
len(h.synapse))
h.synapse.weight = np.random.rand(len(h.synapse)) * weightMax
print('After setup, t = %.3f' % (time.time() - t0))
numStats = 100
stats = moose.SpikeStats('/stats', numStats)
stats.vec.windowLength = 1 # timesteps to put together.
plots = moose.Table('/plot', numStats)
convergence = size // numStats
for i in range(numStats):
for j in range(size // numStats):
k = i * convergence + j
moose.connect(network.vec[k], 'spikeOut', stats.vec[i], 'addSpike')
moose.connect(plots, 'requestOut', stats, 'getMean', 'OneToOne')
t1 = time.time()
moose.reinit()
print('reinit time t = %.3f' % (time.time() - t1))
network.vec.Vm = np.random.rand(size) * Vmax
print('setting Vm , t = %.3f' % (time.time() - t1))
t1 = time.time()
moose.start(runsteps * dt, 1)
time.sleep(0.1)
done.value = 1
print('runtime, t = %.3f' % (time.time() - t1))
print(network.vec.Vm[99:103], network.vec.Vm[900:903])
res = q.get()
for tabPath in res:
aWithTime = res[tabPath]
a = aWithTime[1::2]
b = moose.element(tabPath).vector
print(tabPath, len(a), len(b))
if len(a) == len(b):
assert np.equal(a, b).all()
else:
print("Table did not equal size. The last table is allowed to "
" have fewer entries.")
th.join()
print('All done')
