def __init__(self, sheet, parameters):
DirectStimulator.__init__(self, sheet,parameters)
exc_syn = self.sheet.sim.StaticSynapse(weight=self.parameters.exc_weight)
inh_syn = self.sheet.sim.StaticSynapse(weight=self.parameters.inh_weight)
if not self.sheet.parameters.mpi_safe:
from pyNN.nest import native_cell_type
if (self.parameters.exc_firing_rate != 0 or self.parameters.exc_weight != 0):
self.np_exc = self.sheet.sim.Population(1, native_cell_type("poisson_generator"),{'rate': 0})
self.sheet.sim.Projection(self.np_exc, self.sheet.pop,self.sheet.sim.AllToAllConnector(),synapse_type=exc_syn,receptor_type='excitatory')
if (self.parameters.inh_firing_rate != 0 or self.parameters.inh_weight != 0):
self.np_inh = self.sheet.sim.Population(1, native_cell_type("poisson_generator"),{'rate': 0})
self.sheet.sim.Projection(self.np_inh, self.sheet.pop,self.sheet.sim.AllToAllConnector(),synapse_type=inh_syn,receptor_type='inhibitory')
else:
if (self.parameters.exc_firing_rate != 0 or self.parameters.exc_weight != 0):
self.ssae = self.sheet.sim.Population(self.sheet.pop.size,self.sheet.sim.SpikeSourceArray())
seeds=mozaik.get_seeds((self.sheet.pop.size,))
self.stgene = [stgen.StGen(rng=numpy.random.RandomState(seed=seeds[i])) for i in numpy.nonzero(self.sheet.pop._mask_local)[0]]
self.sheet.sim.Projection(self.ssae, self.sheet.pop,self.sheet.sim.OneToOneConnector(),synapse_type=exc_syn,receptor_type='excitatory')
if (self.parameters.inh_firing_rate != 0 or self.parameters.inh_weight != 0):
self.ssai = self.sheet.sim.Population(self.sheet.pop.size,self.sheet.sim.SpikeSourceArray())
seeds=mozaik.get_seeds((self.sheet.pop.size,))
self.stgeni = [stgen.StGen(rng=numpy.random.RandomState(seed=seeds[i])) for i in numpy.nonzero(self.sheet.pop._mask_local)[0]]
self.sheet.sim.Projection(self.ssai, self.sheet.pop,self.sheet.sim.OneToOneConnector(),synapse_type=inh_syn,receptor_type='inhibitory')
def setup_background_noise(self):
from pyNN.nest import native_cell_type
if (self.parameters.background_noise.exc_firing_rate != 0) or (self.parameters.background_noise.exc_firing_rate != 0):
np_exc = self.sim.Population(1, native_cell_type("poisson_generator"), {'rate' : self.parameters.background_noise.exc_firing_rate})
prj = self.sim.Projection(np_exc, self.pop, self.sim.AllToAllConnector(weights=self.parameters.background_noise.exc_weight),target='excitatory')
if (self.parameters.background_noise.inh_firing_rate != 0) or (self.parameters.background_noise.inh_firing_rate != 0):
np_inh = self.sim.Population(1, native_cell_type("poisson_generator"), {'rate' : self.parameters.background_noise.inh_firing_rate})
prj = self.sim.Projection(np_inh, self.pop, self.sim.AllToAllConnector(weights=self.parameters.background_noise.inh_weight),target='inhibitory')
def __init__(self, cell_params, col_params):
global seed
self.exc = sim.Population(col_params['EI_ratio']*col_params['size'],sim.native_cell_type("aeif_beuler"), cell_params)
self.inh = sim.Population(col_params['size'], sim.native_cell_type("aeif_beuler"), cell_params)
self.inh.set('b', 0.0)
uniformDistr = sim.RandomDistribution('uniform', [cell_params['V_reset'],cell_params['V_th']], rng=sim.NumpyRNG(seed))
seed += 1
self.all.initialize('v',uniformDistr)
self.w_E = col_params['wE']
self.w_I = col_params['wI']
def load_cell_types(simulator_name):
cell_type_dict = {}
if simulator_name == "NEST":
music_event_out_proxy = sim.native_cell_type('music_event_out_proxy')
music_event_in_proxy = sim.native_cell_type('music_event_in_proxy')
parrot_neuron_type = sim.native_cell_type('parrot_neuron')
model_list = [music_event_out_proxy, music_event_in_proxy, parrot_neuron_type]
for model in model_list:
model.default_initial_values = {}
model.default_parameters = {}
cell_type_dict['out'] = {'Event': music_event_out_proxy}
cell_type_dict['in'] = {'Event': music_event_in_proxy}
cell_type_dict['parrot'] = parrot_neuron_type
else:
raise Exception("Implementation for {} not found"
.format(simulator_name))
return cell_type_dict
def test_record_native_model():
if not have_nest:
raise SkipTest
nest = pyNN.nest
from pyNN.random import RandomDistribution
init_logging(logfile=None, debug=True)
nest.setup()
parameters = {'tau_m': 17.0}
n_cells = 10
p1 = nest.Population(n_cells, nest.native_cell_type("ht_neuron")(**parameters))
p1.initialize(V_m=-70.0, Theta=-50.0)
p1.set(theta_eq=-51.5)
#assert_arrays_equal(p1.get('theta_eq'), -51.5*numpy.ones((10,)))
assert_equal(p1.get('theta_eq'), -51.5)
print(p1.get('tau_m'))
p1.set(tau_m=RandomDistribution('uniform', low=15.0, high=20.0))
print(p1.get('tau_m'))
current_source = nest.StepCurrentSource(times=[50.0, 110.0, 150.0, 210.0],
amplitudes=[0.01, 0.02, -0.02, 0.01])
p1.inject(current_source)
p2 = nest.Population(1, nest.native_cell_type("poisson_generator")(rate=200.0))
print("Setting up recording")
p2.record('spikes')
p1.record('V_m')
connector = nest.AllToAllConnector()
syn = nest.StaticSynapse(weight=0.001)
prj_ampa = nest.Projection(p2, p1, connector, syn, receptor_type='AMPA')
tstop = 250.0
nest.run(tstop)
vm = p1.get_data().segments[0].analogsignals[0]
n_points = int(tstop / nest.get_time_step()) + 1
assert_equal(vm.shape, (n_points, n_cells))
assert vm.max() > 0.0 # should have some spikes
def test_ticket240():
nest = pyNN.nest
nest.setup(threads=4)
parameters = {'Tau_m': 17.0}
p1 = nest.Population(4, nest.IF_curr_exp())
p2 = nest.Population(5, nest.native_cell_type("ht_neuron")(**parameters))
conn = nest.AllToAllConnector()
syn = nest.StaticSynapse(weight=1.0)
prj = nest.Projection(p1, p2, conn, syn, receptor_type='AMPA') # This should be a nonstandard receptor type but I don't know of one to use.
connections = prj.get(('weight',), format='list')
assert len(connections) > 0
def __init__(self, sim_time, n_spike_source, n_hidden_neurons, n_output_neurons, W_in, W_re, W_out):
self.sim_time = sim_time
self.n_spike_source = int(n_spike_source)
self.n_hidden_neurons = int(n_hidden_neurons)
self.n_output_neurons = int(n_output_neurons)
self.mem_scale = 2**16 ## new new new
self.weight_scale = 2**15 ## new new new
self.parameters = {
'VBits': 32,
'VdecBits': 32,
'Vdec_sig': 0,
'V_th': 2000 * self.mem_scale / 1000, ## new new new
'wBits': 16,
'wAccBits': 20,
'wAccShift': 1,
't_ref': 0.
}
self.cell_type = sim.native_cell_type('iaf_psc_delta_int')
self.parameters_out = {
u'E_L': 0.0,
u'I_e': 1.0, # 用这个参数来表示leaky, 1.0则表示没有leak
u'V_reset': 0.0,
u'V_th': 2000, # 10000, ## new new new
u't_ref': 0.0,
}
self.cell_type_out = sim.native_cell_type('iaf_psc_delta_xxq')
# network structure
self.spike_source = None
self.hidden_neurons = None
self.output_neurons = None
self.connection_in = None
self.connection_hidden = None
self.connection_out = None
W_in = np.round(W_in * self.weight_scale) / 1000.
W_re = np.round(W_re * self.weight_scale) / 1000.
# print W_in
self.hidden_spike_cnts = []
self.connection_in_list, self.connection_hidden_list, self.connection_out_list = self.getListConnection(W_in, W_re, W_out)
self.ready()
def test_record_native_model():
nest = pyNN.nest
from pyNN.random import RandomDistribution
from pyNN.utility import init_logging
init_logging(logfile=None, debug=True)
nest.setup()
parameters = {'Tau_m': 17.0}
n_cells = 10
p1 = nest.Population(n_cells, nest.native_cell_type("ht_neuron"), parameters)
p1.initialize('V_m', -70.0)
p1.initialize('Theta', -50.0)
p1.set('Theta_eq', -51.5)
assert_equal(p1.get('Theta_eq'), [-51.5]*10)
print p1.get('Tau_m')
p1.rset('Tau_m', RandomDistribution('uniform', [15.0, 20.0]))
print p1.get('Tau_m')
current_source = nest.StepCurrentSource({'times' : [50.0, 110.0, 150.0, 210.0],
'amplitudes' : [0.01, 0.02, -0.02, 0.01]})
p1.inject(current_source)
p2 = nest.Population(1, nest.native_cell_type("poisson_generator"), {'rate': 200.0})
print "Setting up recording"
p2.record()
p1._record('V_m')
connector = nest.AllToAllConnector(weights=0.001)
prj_ampa = nest.Projection(p2, p1, connector, target='AMPA')
tstop = 250.0
nest.run(tstop)
n_points = int(tstop/nest.get_time_step()) + 1
assert_equal(p1.recorders['V_m'].get().shape, (n_points*n_cells, 3))
id, t, v = p1.recorders['V_m'].get().T
assert v.max() > 0.0 # should have some spikes
def stimulate_on_target(self, stimulus, idx):
cres=0
if (stimulus['type'] == 'Poisson_E' or stimulus['type'] == 'Poisson_EI'):
self.ext_stim = sim.Population(stimulus['N_E'], sim.native_cell_type('poisson_generator'), {'rate': stimulus['rate_E'], 'stop' : float(stimulus['duration'])})
#weight = RandomDistribution('normal', (self.w_E, self.w_E/3), boundaries=(0, self.w_E*100), constrain='redraw', rng=rng)
if stimulus["target"]=="E":
N_target=self.Ne
target_cells=self.get_exc_from_blocks(idx)
if stimulus["target"]=="I":
N_target=self.Ni
target_cells=self.get_inh_from_blocks(idx)
if stimulus["target"]=="EI":
N_target=self.Ne+self.Ni
target_cells=self.get_all_from_blocks(idx)
conn = MyConnector(numpy.repeat(stimulus['ee'],N_target), weights = stimulus['wE'], delays=self.timestep)
prj = sim.Projection(self.ext_stim, target_cells, conn, target='excitatory', rng=rng)
if self.graph==idx: self.conn_graph.make_stim_nodes(self.get_stim_idx(), conn.edg)
self.mpi_print("-->o %d excitatory connections were established from external sources ..." %prj.size())
def __init__(self, sim_time, n_spike_source, n_hidden_neurons, n_output_neurons, W_in, W_re, W_out):
self.max_mem = 0.0
self.sim_time = sim_time
self.n_spike_source = int(n_spike_source)
self.n_hidden_neurons = int(n_hidden_neurons)
self.n_output_neurons = int(n_output_neurons)
self.parameters = {
u'E_L': 0.0,
u'I_e': 1.0, # 用这个参数来表示leaky, 1.0则表示没有leak
u'V_reset': 0.0,
u'V_th': 2000,
u't_ref': 0.0,
}
self.cell_type = sim.native_cell_type('iaf_psc_delta')
# network structure
self.spike_source = None
self.hidden_neurons = None
self.output_neurons = None
self.connection_in = None
self.connection_hidden = None
self.connection_out = None
self.connection_in_list, self.connection_hidden_list, self.connection_out_list = self.getListConnection(W_in, W_re, W_out)
self.ready()
import pyNN.nest as sim
sim.nest.Install("coronetmodule")
sim.setup()
sim.nest.SetKernelStatus({"dict_miss_is_error": False})
coronet_neuron = sim.native_cell_type("coronet_neuron")
p1 = sim.Population(10, coronet_neuron)
s1 = sim.Population(10, sim.SpikeSourcePoisson, {"rate": 20})
s2 = sim.Population(10, sim.SpikeSourcePoisson, {"rate": 20})
sim.Projection(s1, p1, sim.OneToOneConnector(weights=0.02), target="EX")
sim.Projection(s2, p1, sim.OneToOneConnector(weights=0.01), target="IN")
p1.initialize("V_m", -76.0) # this works as expected
p1.record()
p1._record("V_m") # ugly
sim.run(1000)
id, t, v = p1.recorders["V_m"].get().T # ugly
import pylab as pl
import numpy as np
pl.figure()
sl = p1.getSpikes()
pl.plot(sl[:, 1], sl[:, 0], ".")
pl.figure()
id_is_0 = np.where(id == 0)
pl.plot(t[id_is_0], v[id_is_0])
pl.show()
def run_retina(params):
"""Run the retina using the specified parameters."""
print "Setting up simulation"
timer = Timer()
timer.start() # start timer on construction
pyNN.setup(timestep=params['dt'], max_delay=params['syn_delay'], threads=params['threads'], rng_seeds=params['kernelseeds'])
N = params['N']
phr_ON = pyNN.Population((N, N), pyNN.native_cell_type('dc_generator')())
phr_OFF = pyNN.Population((N, N), pyNN.native_cell_type('dc_generator')())
noise_ON = pyNN.Population((N, N), pyNN.native_cell_type('noise_generator')(mean=0.0, std=params['noise_std']))
noise_OFF = pyNN.Population((N, N), pyNN.native_cell_type('noise_generator')(mean=0.0, std=params['noise_std']))
phr_ON.set(start=params['simtime']/4, stop=params['simtime']/4*3,
amplitude=params['amplitude'] * params['snr'])
phr_OFF.set(start=params['simtime']/4, stop=params['simtime']/4*3,
amplitude=-params['amplitude'] * params['snr'])
# target ON and OFF populations
v_init = params['parameters_gc'].pop('Vinit')
out_ON = pyNN.Population((N, N), pyNN.native_cell_type('iaf_cond_exp_sfa_rr')(**params['parameters_gc']))
out_OFF = pyNN.Population((N, N), pyNN.native_cell_type('iaf_cond_exp_sfa_rr')(**params['parameters_gc']))
out_ON.initialize(v=v_init)
out_OFF.initialize(v=v_init)
#print "Connecting the network"
retina_proj_ON = pyNN.Projection(phr_ON, out_ON, pyNN.OneToOneConnector())
retina_proj_ON.set(weight=params['weight'])
retina_proj_OFF = pyNN.Projection(phr_OFF, out_OFF, pyNN.OneToOneConnector())
retina_proj_OFF.set(weight=params['weight'])
noise_proj_ON = pyNN.Projection(noise_ON, out_ON, pyNN.OneToOneConnector())
noise_proj_ON.set(weight=params['weight'])
noise_proj_OFF = pyNN.Projection(noise_OFF, out_OFF, pyNN.OneToOneConnector())
noise_proj_OFF.set(weight=params['weight'])
out_ON.record('spikes')
out_OFF.record('spikes')
# reads out time used for building
buildCPUTime = timer.elapsedTime()
print "Running simulation"
timer.start() # start timer on construction
pyNN.run(params['simtime'])
simCPUTime = timer.elapsedTime()
out_ON_DATA = out_ON.get_data().segments[0]
out_OFF_DATA = out_OFF.get_data().segments[0]
print "\nRetina Network Simulation:"
print(params['description'])
print "Number of Neurons : ", N**2
print "Output rate (ON) : ", out_ON.mean_spike_count(), \
"spikes/neuron in ", params['simtime'], "ms"
print "Output rate (OFF) : ", out_OFF.mean_spike_count(), \
"spikes/neuron in ", params['simtime'], "ms"
print "Build time : ", buildCPUTime, "s"
print "Simulation time : ", simCPUTime, "s"
return out_ON_DATA, out_OFF_DATA
def test_create_native(self):
cell_type = sim.native_cell_type('iaf_neuron')
p = sim.Population(3, cell_type())
def make_stim_pop(self, stimulus):
if (stimulus['type'] == 'Poisson_E'):
self.ext_stim = sim.Population(stimulus['N_E'], sim.native_cell_type('poisson_generator'), {'rate': stimulus['rate_E'], 'stop' : float(stimulus['duration'])})
import pyNN.nest as sim
import matplotlib.pyplot as plt
if __name__ == '__main__':
params = {
'VBits': 32,
'VdecBits': 32,
'Vdec_sig': 2**30,
'V_th': 10000000,
'wBits': 16,
'wAccBits': 20,
'wAccShift': 10,
't_ref': 0.
}
sim.setup(timestep=0.1)
cell_type = sim.native_cell_type('iaf_psc_delta_int')
neuron = cell_type(**params)
n = sim.Population(1, cell_type(**params))
s = sim.Population(1, sim.SpikeSourceArray())
o = sim.Population(1, cell_type(**params))
s[0].spike_times = [10, 15, 20, 30, 40]
p = sim.Projection(s, n, sim.FromListConnector([(0, 0, 25, 0.01)]))
p1 = sim.Projection(n, o, sim.FromListConnector([(0, 0, 25, 0.01)]))
o.record('V_m')
sim.initialize(n, V_m=0)
sim.run(128.0)
vtrace = o.get_data(clear=True).segments[0].filter(name='V_m')[0]
print p.get(['weight'], format='array')
plt.figure()
import pyNN.nest as sim
sim.nest.Install('coronetmodule')
sim.setup()
sim.nest.SetKernelStatus({'dict_miss_is_error': False})
iaf_4_cond_exp = sim.native_cell_type('iaf_4_cond_exp')
cell_params=\
{'C_m': 250.0,
'E_L': -70.0,
'E_syn_1': 0.0,
'E_syn_2': 0.0,
'E_syn_3': -85.0,
'E_syn_4': 0.0,
'I_e': 0.0,
'V_reset': -60.0,
'V_th': -55.0,
'g_L': 16.6667,
't_ref': 2.0,
'tau_syn_1': 5.0,
'tau_syn_2': 5.0,
'tau_syn_3': 25.0,
'tau_syn_4': 0.2}
p1 = sim.Population(10, iaf_4_cond_exp, cell_params)
s1 = sim.Population(10, sim.SpikeSourcePoisson, {'rate':20})
s2 = sim.Population(10, sim.SpikeSourcePoisson, {'rate':20})
s3 = sim.Population(10, sim.SpikeSourcePoisson, {'rate':20})
sim.Projection(s1, p1, sim.OneToOneConnector(weights=0.02), target="SYN_1")
sim.Projection(s2, p1, sim.OneToOneConnector(weights=0.01), target="SYN_2")
sim.Projection(s3, p1, sim.OneToOneConnector(weights=0.01), target="SYN_3")
print iaf_4_cond_exp.synapse_types
def test_create_native(self):
cell_type = sim.native_cell_type('iaf_neuron')
p = sim.Population(3, cell_type())
#!/usr/bin/env python
import faulthandler
from music_wizard.pynn import XmlFactory, Factory
import music
import pyNN.nest as sim
sim.setup()
music_setup = music.Setup()
xml = music_setup.config('xml')
detector = sim.Population(1, sim.native_cell_type('spike_detector'), {})
population_dict={'detector': detector}
model_factory = Factory.PyNNProxyFactory(sim, music_setup, acc_latency=10.0)
connector_factory = Factory.PyNNConnectorFactory(sim)
proxy_factory = XmlFactory.ProxyFactory("app1", connector_factory, model_factory, population_dict)
with open(xml, 'r') as xml_stream:
proxys = proxy_factory.create_proxys(xml_stream.read())
for i in xrange(20):
sim.run(20.0)
print nest.GetStatus(detector, 'events')
sim.setup(timestep=resolution, min_delay=1.0, threads=n_threads)
# Set population dimensions
n_neurons_e = 800;
n_neurons_i = 200;
n_neurons = n_neurons_e + n_neurons_i;
# Set synaptic weights
max_syn_weight_e = 0.0005 # max magnitude of excitatory synaptic weights
max_syn_weight_i = 0.001 # max magnitude of inhibitory synaptic weights
#----------- Build --------------
#--------------------------------
# Create Izhikevich cell type (based on native NEST model)
Izhikevich = sim.native_cell_type('izhikevich')
# Create excitatory neurons
r = np.random.rand(n_neurons_e)
c = -65.0 + 15.0 * r**2
d = 8.0 - 6.0 * r**2
population_e = sim.Population(n_neurons_e, Izhikevich,
cellparams={'a': 0.02,
'b': 0.2})
population_e.tset('c', c)
population_e.tset('d', d)
population_e.initialize('V_m', -65.0)
population_e.initialize('U_m', 0.2*(-65.0))
# Create inhibitory neurons
r = np.random.rand(n_neurons_i)
import pyNN.nest as pynn
pynn.nest.Install('brainscales_hw_module')
pynn.nest.Install('hmf_hw_module')
iaf_4_cond_exp = pynn.native_cell_type('iaf_4_cond_exp')
aeif_4_cond_exp = pynn.native_cell_type('aeif_4_cond_exp')
# __author__ = 'xxq'
import matplotlib.pyplot as plt
import numpy as np
import pyNN.nest as sim
parameters = {
u'E_L': 0.0,
u'I_e': 0.9, # 用这个参数来表示leaky
u'V_reset': 0.0,
u'V_th': 0.5,
u't_ref': .0,
}
sim.setup(timestep=01.0)
nt = sim.native_cell_type('iaf_psc_delta_xxq')
n = sim.Population(1, nt(**parameters))
s = sim.Population(1, sim.SpikeSourceArray())
s[0].spike_times = [10, 15, 20, 30, 40]
p = sim.Projection(s, n, sim.FromListConnector([(0, 0, 0.00025, 0.01)]))
# p1 = sim.Projection(n, n, sim.FromListConnector([(0, 0, 0.00025, 1.0)]))
n.record('V_m')
n.record('V_m')
sim.initialize(n, V_m=0.)
sim.run(128.0)
vtrace = n.get_data(clear=True).segments[0].filter(name='V_m')[0]
print p.get(['weight'], format='array')
plt.figure()
plt.plot(vtrace.times, vtrace, 'o')
def test_create_native(self):
cell_type = sim.native_cell_type('iaf_psc_alpha')
p = sim.Population(3, cell_type())
