def run_sim(ncell):
print "Cells: ", ncell
setup0 = time.time()
sim.setup(timestep=0.1)
hh_cell_type = sim.HH_cond_exp()
hh = sim.Population(ncell, hh_cell_type)
pulse = sim.DCSource(amplitude=0.5, start=20.0, stop=80.0)
pulse.inject_into(hh)
hh.record('v')
setup1 = time.time()
t0 = time.time()
sim.run(100.0)
v = hh.get_data()
sim.end()
t1 = time.time()
setup_total = setup1 - setup0
run_total = t1 - t0
print "Setup: ", setup_total
print "Run: ", run_total
print "Total sim time: ", setup_total + run_total
return run_total
def run_pynn(end_t):
pynn_now = pynnn.get_current_time()
pynn_now_round = round(pynn_now, PYNN_TIME_ROUNDING)
delta_t = round(end_t - pynn_now_round, PYNN_TIME_ROUNDING)
if pynn_now <= pynn_now_round and delta_t > PYNN_TIME_STEP:
delta_t = round(delta_t - PYNN_TIME_STEP, PYNN_TIME_ROUNDING)
if delta_t > 0: # necessary because run(0) may run PyNN by timestep
pynnn.run(delta_t) # neuralensemble.org/trac/PyNN/ticket/200
def run_pynn(end_t):
pynn_now = pynnn.get_current_time()
pynn_now_round = round(pynn_now, PYNN_TIME_ROUNDING)
delta_t = round(end_t - pynn_now_round, PYNN_TIME_ROUNDING)
if pynn_now <= pynn_now_round and delta_t > PYNN_TIME_STEP:
delta_t = round(delta_t - PYNN_TIME_STEP, PYNN_TIME_ROUNDING)
if delta_t > 0: # necessary because run(0) may run PyNN by timestep
pynnn.run(delta_t) # neuralensemble.org/trac/PyNN/ticket/200
def run_network(self, duration=1000.):
"""
Run the network for the specified duration. Returns spikes of target
population in GDF format.
"""
pynn.run(duration)
spikes = self.target.getSpikes()
return spikes
def generate_data(label):
spikesTrain = []
organisedData = {}
for i in range(input_class):
for j in range(input_len):
neuid = (i, j)
organisedData[neuid] = []
for i in range(input_len):
neuid = (label, i)
organisedData[neuid].append(i * v_co)
# if neuid not in organisedData:
# organisedData[neuid]=[i*v_co]
# else:
# organisedData[neuid].append(i*v_co)
for i in range(input_class):
for j in range(input_len):
neuid = (i, j)
organisedData[neuid].sort()
spikesTrain.append(organisedData[neuid])
runTime = int(max(max(spikesTrain)))
sim.setup(timestep=1)
noise = sim.Population(input_size, sim.SpikeSourcePoisson(), label='noise')
noise.record(['spikes']) #noise
sim.run(runTime)
neonoise = noise.get_data(["spikes"])
spikesnoise = neonoise.segments[0].spiketrains #noise
sim.end()
for i in range(input_size):
for noisespike in spikesnoise[i]:
spikesTrain[i].append(noisespike)
spikesTrain[i].sort()
return spikesTrain
import pyNN.brian as sim
sim.setup()
cell = sim.Population(1, sim.HH_cond_exp())
cell.record('v')
sim.run(100)
data = cell.get_data()
sim.end()
static_synapse,
receptor_type='excitatory')
E_E_connection = sim.Projection(Pexc,
Pexc,
sim.FixedProbabilityConnector(p_connect=0.5),
depressing_synapse_ee,
receptor_type='excitatory')
Excinp.record('spikes')
# Excinp[1].record('v')
Pexc.record('spikes')
Pexc[5:6].record('v')
for i in range(no_run):
sim.run(run_time)
spikes = Excinp.get_data()
spike = Pexc.get_data()
# print connection.get('weight',format = 'array')
# print E_E_connection.get('weight', format = 'array')
# print connection.get('tau_facil', format = 'array')
# connection.set(weight = 0.05, delay = 0.2, U = 0.5, tau_rec = 800.0, tau_facil = 0.01)
# connection.set(weight = 0.05, delay = 0.5, U = 0.05, tau_rec = 100.0, tau_facil = 1000)
# E_E_connection.set(weight = 0.05)
# print Pexc.get('i_offset')
# Pexc.set(tau_refrac = 100, v_thresh = -50.0, tau_m = 20.0, tau_syn_E = 0.5, v_rest = -65.0, \
# cm = 1.0, v_reset = -65000.0, tau_syn_I = 0.5, i_offset = 0.0)
# print Pexc.get('v_rest','cm', 'v_reset', 'tau_syn_I', 'i_offset')
# print spikes.segments[i].spiketrains[2]
# print type(spike.segments[i])
fig_settings = {
def main():
## Uninteresting setup, start up the visu process,...
logfile = make_logfile_name()
ensure_dir(logfile)
f_h = logging.FileHandler(logfile)
f_h.setLevel(SUBDEBUG)
d_h = logging.StreamHandler()
d_h.setLevel(INFO)
utils.configure_loggers(debug_handler=d_h, file_handler=f_h)
parent_conn, child_conn = multiprocessing.Pipe()
p = multiprocessing.Process(
target=visualisation.visualisation_process_f,
name="display_process", args=(child_conn, LOGGER))
p.start()
pynnn.setup(timestep=SIMU_TIMESTEP)
init_logging("logfile", debug=True)
LOGGER.info("Simulation started with command: %s", sys.argv)
## Network setup
# First population
p1 = pynnn.Population(100, pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
p1.set({'tau_m':20, 'v_rest':-65})
# Second population
p2 = pynnn.Population(20, pynnn.IF_curr_alpha,
cellparams={'tau_m': 15.0, 'cm': 0.9})
# Projection 1 -> 2
prj1_2 = pynnn.Projection(
p1, p2, pynnn.AllToAllConnector(allow_self_connections=False),
target='excitatory')
# I may need to make own PyNN Connector class. Otherwise, this is
# neat: exponentially decaying probability of connections depends
# on distance. Distance is only calculated using x and y, which
# are on a toroidal topo with boundaries at 0 and 500.
connector = pynnn.DistanceDependentProbabilityConnector(
"exp(-abs(d))",
space=pynnn.Space(
axes='xy', periodic_boundaries=((0,500), (0,500), None)))
# Alternately, the powerful connection set algebra (python CSA
# module) can be used.
weight_distr = pynnn.RandomDistribution(distribution='gamma',
parameters=[1,0.1])
prj1_2.randomizeWeights(weight_distr)
# This one is in NEST but not in Brian:
# source = pynnn.NoisyCurrentSource(
# mean=100, stdev=50, dt=SIMU_TIMESTEP,
# start=10.0, stop=SIMU_DURATION, rng=pynnn.NativeRNG(seed=100))
source = pynnn.DCSource(
start=10.0, stop=SIMU_DURATION, amplitude=100)
source.inject_into(list(p1.sample(50).all()))
p1.record(to_file=False)
p2.record(to_file=False)
## Build and send the visualizable network structure
adapter = pynn_to_visu.PynnToVisuAdapter(LOGGER)
adapter.add_pynn_population(p1)
adapter.add_pynn_population(p2)
adapter.add_pynn_projection(p1, p2, prj1_2.connection_manager)
adapter.commit_structure()
parent_conn.send(adapter.output_struct)
# Number of chunks to run the simulation:
n_chunks = SIMU_DURATION // SIMU_TO_VISU_MESSAGE_PERIOD
last_chunk_duration = SIMU_DURATION % SIMU_TO_VISU_MESSAGE_PERIOD
# Run the simulator
for visu_i in xrange(n_chunks):
pynnn.run(SIMU_TO_VISU_MESSAGE_PERIOD)
parent_conn.send(adapter.make_activity_update_message())
LOGGER.debug("real current p1 spike counts: %s",
p1.get_spike_counts().values())
if last_chunk_duration > 0:
pynnn.run(last_chunk_duration)
parent_conn.send(adapter.make_activity_update_message())
# Cleanup
pynnn.end()
# Wait for the visualisation process to terminate
p.join(VISU_PROCESS_JOIN_TIMEOUT)
def train(label, untrained_weights=None):
organisedStim = {}
labelSpikes = []
spikeTimes = generate_data(label)
for i in range(output_size):
labelSpikes.append([])
labelSpikes[label] = [int(max(max(spikeTimes))) + 1]
if untrained_weights == None:
untrained_weights = RandomDistribution('uniform',
low=wMin,
high=wMaxInit).next(input_size *
output_size)
#untrained_weights = RandomDistribution('normal_clipped', mu=0.1, sigma=0.05, low=wMin, high=wMaxInit).next(input_size*output_size)
untrained_weights = np.around(untrained_weights, 3)
#saveWeights(untrained_weights, 'untrained_weightssupmodel1traj')
print("init!")
print "length untrained_weights :", len(untrained_weights)
if len(untrained_weights) > input_size:
training_weights = [[0 for j in range(output_size)]
for i in range(input_size)
] #np array? size 1024x25
k = 0
#for i in untrained_weights:
# training_weights[i[0]][i[1]]=i[2]
for i in range(input_size):
for j in range(output_size):
training_weights[i][j] = untrained_weights[k]
k += 1
else:
training_weights = untrained_weights
connections = []
for n_pre in range(input_size): # len(untrained_weights) = input_size
for n_post in range(
output_size
): # len(untrained_weight[0]) = output_size; 0 or any n_pre
connections.append((n_pre, n_post, training_weights[n_pre][n_post],
__delay__)) #index
runTime = int(max(max(spikeTimes))) + 100
#####################
sim.setup(timestep=1)
#def populations
layer1 = sim.Population(input_size,
sim.SpikeSourceArray, {'spike_times': spikeTimes},
label='inputspikes')
layer2 = sim.Population(output_size,
sim.IF_curr_exp,
cellparams=cell_params_lif,
label='outputspikes')
supsignal = sim.Population(output_size,
sim.SpikeSourceArray,
{'spike_times': labelSpikes},
label='supersignal')
#def learning rule
stdp = sim.STDPMechanism(
#weight=untrained_weights,
#weight=0.02, # this is the initial value of the weight
#delay="0.2 + 0.01*d",
timing_dependence=sim.SpikePairRule(tau_plus=tauPlus,
tau_minus=tauMinus,
A_plus=aPlus,
A_minus=aMinus),
#weight_dependence=sim.MultiplicativeWeightDependence(w_min=wMin, w_max=wMax),
weight_dependence=sim.AdditiveWeightDependence(w_min=wMin, w_max=wMax),
dendritic_delay_fraction=0)
#def projections
stdp_proj = sim.Projection(layer1,
layer2,
sim.FromListConnector(connections),
synapse_type=stdp)
inhibitory_connections = sim.Projection(
layer2,
layer2,
sim.AllToAllConnector(allow_self_connections=False),
synapse_type=sim.StaticSynapse(weight=inhibWeight, delay=__delay__),
receptor_type='inhibitory')
stim_proj = sim.Projection(supsignal,
layer2,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(
weight=stimWeight, delay=__delay__))
layer1.record(['spikes'])
layer2.record(['v', 'spikes'])
supsignal.record(['spikes'])
sim.run(runTime)
print("Weights:{}".format(stdp_proj.get('weight', 'list')))
weight_list = [
stdp_proj.get('weight', 'list'),
stdp_proj.get('weight', format='list', with_address=False)
]
neo = layer2.get_data(["spikes", "v"])
spikes = neo.segments[0].spiketrains
v = neo.segments[0].filter(name='v')[0]
neostim = supsignal.get_data(["spikes"])
print(label)
spikestim = neostim.segments[0].spiketrains
neoinput = layer1.get_data(["spikes"])
spikesinput = neoinput.segments[0].spiketrains
plt.close('all')
pplt.Figure(pplt.Panel(v,
ylabel="Membrane potential (mV)",
xticks=True,
yticks=True,
xlim=(0, runTime)),
pplt.Panel(spikesinput,
xticks=True,
yticks=True,
markersize=2,
xlim=(0, runTime)),
pplt.Panel(spikestim,
xticks=True,
yticks=True,
markersize=2,
xlim=(0, runTime)),
pplt.Panel(spikes,
xticks=True,
xlabel="Time (ms)",
yticks=True,
markersize=2,
xlim=(0, runTime)),
title="Training" + str(label),
annotations="Training" +
str(label)).save('plot/' + str(trylabel) + str(label) +
'_training.png')
#plt.hist(weight_list[1], bins=100)
#plt.show()
plt.close('all')
print(wMax)
'''
plt.hist([weight_list[1][0:input_size], weight_list[1][input_size:input_size*2], weight_list[1][input_size*2:]], bins=20, label=['neuron 0', 'neuron 1', 'neuron 2'], range=(0, wMax))
plt.title('weight distribution')
plt.xlabel('Weight value')
plt.ylabel('Weight count')
'''
#plt.show()
#plt.show()
sim.end()
for i in weight_list[0]:
#training_weights[int(i[0])][int(i[1])]=float(i[2])
weight_list[1][int(i[0]) * output_size + int(i[1])] = i[2]
return weight_list[1]
def test(spikeTimes, trained_weights, label):
#spikeTimes = extractSpikes(sample)
runTime = int(max(max(spikeTimes))) + 100
##########################################
sim.setup(timestep=1)
pre_pop = sim.Population(input_size,
sim.SpikeSourceArray, {'spike_times': spikeTimes},
label="pre_pop")
post_pop = sim.Population(output_size,
sim.IF_curr_exp,
cell_params_lif,
label="post_pop")
'''
if len(untrained_weights)>input_size:
training_weights = [[0 for j in range(output_size)] for i in range(input_size)] #np array? size 1024x25
k=0
for i in untrained_weights:
training_weights[i[0]][i[1]]=i[2]
'''
if len(trained_weights) > input_size:
weigths = [[0 for j in range(output_size)]
for i in range(input_size)] #np array? size 1024x25
k = 0
for i in range(input_size):
for j in range(output_size):
weigths[i][j] = trained_weights[k]
k += 1
else:
weigths = trained_weights
connections = []
#k = 0
for n_pre in range(input_size): # len(untrained_weights) = input_size
for n_post in range(
output_size
): # len(untrained_weight[0]) = output_size; 0 or any n_pre
#connections.append((n_pre, n_post, weigths[n_pre][n_post]*(wMax), __delay__))
connections.append((n_pre, n_post, weigths[n_pre][n_post] *
(wMax) / max(trained_weights), __delay__)) #
#k += 1
prepost_proj = sim.Projection(
pre_pop,
post_pop,
sim.FromListConnector(connections),
synapse_type=sim.StaticSynapse(),
receptor_type='excitatory') # no more learning !!
#inhib_proj = sim.Projection(post_pop, post_pop, sim.AllToAllConnector(), synapse_type=sim.StaticSynapse(weight=inhibWeight, delay=__delay__), receptor_type='inhibitory')
# no more lateral inhib
post_pop.record(['v', 'spikes'])
sim.run(runTime)
neo = post_pop.get_data(['v', 'spikes'])
spikes = neo.segments[0].spiketrains
v = neo.segments[0].filter(name='v')[0]
f1 = pplt.Figure(
# plot voltage
pplt.Panel(v,
ylabel="Membrane potential (mV)",
xticks=True,
yticks=True,
xlim=(0, runTime + 100)),
# raster plot
pplt.Panel(spikes,
xlabel="Time (ms)",
xticks=True,
yticks=True,
markersize=2,
xlim=(0, runTime + 100)),
title='Test with label ' + str(label),
annotations='Test with label ' + str(label))
f1.save('plot/' + str(trylabel) + str(label) + '_test.png')
f1.fig.texts = []
print("Weights:{}".format(prepost_proj.get('weight', 'list')))
weight_list = [
prepost_proj.get('weight', 'list'),
prepost_proj.get('weight', format='list', with_address=False)
]
#predict_label=
sim.end()
return spikes
steps.inject_into(ifcell[(1,7,9)])
ifcell.record('v')
sim.run(250.0)
data = ifcell.get_data()
sim.end()
'''
noise = sim.NoisyCurrentSource(mean=1.5,
stdev=1.0,
start=50.0,
stop=450.0,
dt=1.0)
ifcell.inject(noise)
ifcell.record('v')
sim.run(500.0)
data = ifcell.get_data()
sim.end()
for segment in data.segments:
vm = segment.analogsignals[0]
print(type(vm))
for i in range(vm.shape[1]):
#v=vm[:,i]
#print(v.shape)
plt.plot(vm.times, vm[:, i], label=str(i))
#plt.plot(vm.times, pulse.amplitudes,label='current')
plt.legend(loc="upper left")
plt.xlabel("Time (%s)" % vm.times.units._dimensionality)
plt.ylabel("Membrane potential (%s)" % vm.units._dimensionality)
neuron,
sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.04, delay=timingPrePostStim),
receptor_type='excitatory')
# create plastic synapse
prj = sim.Projection(spikeSourcePlastic, neuron, sim.AllToAllConnector(), stdp)
weightBefore = prj.get('weight', format='list')
prj.set(weight=0.15)
print weightBefore
neuron.record('spikes')
lastInputSpike = np.max(np.concatenate((stimulus, stimulusPlastic)))
runtime = lastInputSpike + stimulusOffset
sim.run(runtime)
weightAfter = prj.get('weight', format='list')
print weightAfter
result = neuron.get_data()
sim.end()
spikeTimes = result.segments[0].spiketrains[0]
# analysis
print 'Number of stimulating / presynaptic / postsynaptic spikes:', len(
stimulus), len(stimulusPlastic), len(spikeTimes)
if len(stimulusPlastic) != len(spikeTimes):
print 'Not each presynaptic spike has a single postsynaptic partner!'
import pyNN.brian as sim # can of course replace `nest` with `neuron`, `brian`, etc.
import matplotlib.pyplot as plt
from quantities import nA
sim.setup()
cell = sim.Population(1, sim.HH_cond_exp())
step_current = sim.DCSource(start=20.0, stop=80.0)
step_current.inject_into(cell)
cell.record('v')
for amp in (-0.2, -0.1, 0.0, 0.1, 0.2):
step_current.amplitude = amp
sim.run(100.0)
sim.reset(annotations={"amplitude": amp * nA})
data = cell.get_data()
sim.end()
for segment in data.segments:
vm = segment.analogsignals[0]
plt.plot(vm.times, vm,
label=str(segment.annotations["amplitude"]))
plt.legend(loc="upper left")
plt.xlabel("Time (%s)" % vm.times.units._dimensionality)
plt.ylabel("Membrane potential (%s)" % vm.units._dimensionality)
plt.show()
tau_facil=1000)
connection = sim.Projection(Excinp,
Pexc,
sim.AllToAllConnector(),
facilitating_synapse_ee,
receptor_type='excitatory')
# E_E_connection = sim.Projection(Pexc, Pexc, sim.FixedProbabilityConnector(p_connect = 0.5), depressing_synapse_ee, receptor_type = 'excitatory')
Excinp.record('spikes')
# Excinp[1].record('v')
Pexc.record('spikes')
Pexc[5:6].record('v')
for i in range(2):
sim.run(500)
spikes = Excinp.get_data()
spike = Pexc.get_data()
# print connection.get('weight',format = 'array')
# print E_E_connection.get('weight', format = 'array')
sim.reset()
# print connection.get('tau_facil', format = 'array')
# connection.set(weight = 0.05, delay = 0.2, U = 0.5, tau_rec = 800.0, tau_facil = 0.01)
connection.set(weight=0.05,
delay=0.5,
U=0.05,
tau_rec=100.0,
tau_facil=1000)
# E_E_connection.set(weight = 0.05)
# print Pexc.get('i_offset')
# Pexc.set(tau_refrac = 100, v_thresh = -50.0, tau_m = 20.0, tau_syn_E = 0.5, v_rest = -65.0, \
def main():
## Uninteresting setup, start up the visu process,...
logfile = make_logfile_name()
ensure_dir(logfile)
f_h = logging.FileHandler(logfile)
f_h.setLevel(SUBDEBUG)
d_h = logging.StreamHandler()
d_h.setLevel(INFO)
utils.configure_loggers(debug_handler=d_h, file_handler=f_h)
parent_conn, child_conn = multiprocessing.Pipe()
p = multiprocessing.Process(target=visualisation.visualisation_process_f,
name="display_process",
args=(child_conn, LOGGER))
p.start()
pynnn.setup(timestep=SIMU_TIMESTEP)
init_logging("logfile", debug=True)
LOGGER.info("Simulation started with command: %s", sys.argv)
## Network setup
# First population
p1 = pynnn.Population(100,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
p1.set({'tau_m': 20, 'v_rest': -65})
# Second population
p2 = pynnn.Population(20,
pynnn.IF_curr_alpha,
cellparams={
'tau_m': 15.0,
'cm': 0.9
})
# Projection 1 -> 2
prj1_2 = pynnn.Projection(
p1,
p2,
pynnn.AllToAllConnector(allow_self_connections=False),
target='excitatory')
# I may need to make own PyNN Connector class. Otherwise, this is
# neat: exponentially decaying probability of connections depends
# on distance. Distance is only calculated using x and y, which
# are on a toroidal topo with boundaries at 0 and 500.
connector = pynnn.DistanceDependentProbabilityConnector(
"exp(-abs(d))",
space=pynnn.Space(axes='xy',
periodic_boundaries=((0, 500), (0, 500), None)))
# Alternately, the powerful connection set algebra (python CSA
# module) can be used.
weight_distr = pynnn.RandomDistribution(distribution='gamma',
parameters=[1, 0.1])
prj1_2.randomizeWeights(weight_distr)
# This one is in NEST but not in Brian:
# source = pynnn.NoisyCurrentSource(
# mean=100, stdev=50, dt=SIMU_TIMESTEP,
# start=10.0, stop=SIMU_DURATION, rng=pynnn.NativeRNG(seed=100))
source = pynnn.DCSource(start=10.0, stop=SIMU_DURATION, amplitude=100)
source.inject_into(list(p1.sample(50).all()))
p1.record(to_file=False)
p2.record(to_file=False)
## Build and send the visualizable network structure
adapter = pynn_to_visu.PynnToVisuAdapter(LOGGER)
adapter.add_pynn_population(p1)
adapter.add_pynn_population(p2)
adapter.add_pynn_projection(p1, p2, prj1_2.connection_manager)
adapter.commit_structure()
parent_conn.send(adapter.output_struct)
# Number of chunks to run the simulation:
n_chunks = SIMU_DURATION // SIMU_TO_VISU_MESSAGE_PERIOD
last_chunk_duration = SIMU_DURATION % SIMU_TO_VISU_MESSAGE_PERIOD
# Run the simulator
for visu_i in xrange(n_chunks):
pynnn.run(SIMU_TO_VISU_MESSAGE_PERIOD)
parent_conn.send(adapter.make_activity_update_message())
LOGGER.debug("real current p1 spike counts: %s",
p1.get_spike_counts().values())
if last_chunk_duration > 0:
pynnn.run(last_chunk_duration)
parent_conn.send(adapter.make_activity_update_message())
# Cleanup
pynnn.end()
# Wait for the visualisation process to terminate
p.join(VISU_PROCESS_JOIN_TIMEOUT)
