def __init__(self, model, parameters):
BaseComponent.__init__(self, model, parameters)
self.sim = self.model.sim
self.name = parameters.name # the name of the population
self.model.register_sheet(self)
self._pop = None
# We want to be able to define in cell.params the cell parameters as also PyNNDistributions so we can get variably parametrized populations
# The problem is that the pyNN.Population can accept only scalar parameters. There fore we will remove from cell.params all parameters
# that are PyNNDistributions, and will initialize them later just after the population is initialized (in property pop())
self.dist_params = {}
for k in self.parameters.cell.params.keys():
if isinstance(self.parameters.cell.params[k],PyNNDistribution):
self.dist_params[k]=self.parameters.cell.params[k]
del self.parameters.cell.params[k]
def __init__(self, sim, num_threads, parameters):
BaseComponent.__init__(self, self, parameters)
self.first_time = True
self.sim = sim
self.node = sim.setup(timestep=self.parameters.time_step, min_delay=self.parameters.min_delay, max_delay=self.parameters.max_delay, threads=num_threads) # should have some parameters here
self.sheets = {}
self.connectors = {}
# Set-up the input space
if self.parameters.input_space != None:
input_space_type = load_component(self.parameters.input_space_type)
self.input_space = input_space_type(self.parameters.input_space)
else:
self.input_space = None
self.simulator_time = 0
def __init__(self, model, name, source, target, parameters):
logger.info("Creating %s between %s and %s" % (self.__class__.__name__,
source.__class__.__name__,
target.__class__.__name__))
BaseComponent.__init__(self, model, parameters)
self.name = name
self.model.register_connector(self)
self.sim = self.model.sim
self.source = source
self.target = target
self.input = source
self.target.input = self
self.weight_scaler = 1.0 # This scaler has to be always applied to all weights just before sent to pyNN connect command
# This is because certain pyNN synaptic models interpret weights with different units and the Connector
# function here corrects for these - ie. the Connectors in Mozaik will always assume the weights to be in nano-siemens
if self.parameters.short_term_plasticity != None:
self.weight_scaler = 1000.0
def __init__(self, model, name, source, target, parameters):
logger.info("Creating %s between %s and %s" %
(self.__class__.__name__, source.__class__.__name__,
target.__class__.__name__))
BaseComponent.__init__(self, model, parameters)
self.name = name
self.model.register_connector(self)
self.sim = self.model.sim
self.source = source
self.target = target
self.input = source
self.target.input = self
self.weight_scaler = 1.0 # This scaler has to be always applied to all weights just before sent to pyNN connect command
# This is because certain pyNN synaptic models interpret weights with different units and the Connector
# function here corrects for these - ie. the Connectors in Mozaik will always assume the weights to be in nano-siemens
if self.parameters.short_term_plasticity != None:
self.weight_scaler = 1000.0
def __init__(self, sim, num_threads, parameters):
BaseComponent.__init__(self, self, parameters)
self.first_time = True
self.sim = sim
self.node = sim.setup(
timestep=self.parameters.time_step,
min_delay=self.parameters.min_delay,
max_delay=self.parameters.max_delay,
threads=num_threads) # should have some parameters here
self.sheets = OrderedDict()
self.connectors = OrderedDict()
self.num_threads = num_threads
# Set-up the input space
if self.parameters.input_space != None:
input_space_type = load_component(self.parameters.input_space_type)
self.input_space = input_space_type(self.parameters.input_space)
else:
self.input_space = None
self.simulator_time = 0
def __init__(self, network, lgn_on, lgn_off, target, parameters, name):
from numpy import random
random.seed(1023)
BaseComponent.__init__(self, network, parameters)
self.name = name
t_size = target.size_in_degrees()
or_map = None
if self.parameters.or_map:
f = open(self.parameters.or_map_location, 'r')
or_map = pickle.load(f)*numpy.pi
coords_x = numpy.linspace(-t_size[0]/2.0,
t_size[0]/2.0,
numpy.shape(or_map)[0])
coords_y = numpy.linspace(-t_size[1]/2.0,
t_size[1]/2.0,
numpy.shape(or_map)[1])
print min(coords_x), max(coords_x)
print min(coords_y), max(coords_y)
X, Y = numpy.meshgrid(coords_x, coords_y)
or_map = NearestNDInterpolator(zip(X.flatten(), Y.flatten()),
or_map.flatten())
phase_map = None
if self.parameters.phase_map:
f = open(self.parameters.phase_map_location, 'r')
phase_map = pickle.load(f)
coords_x = numpy.linspace(-t_size[0]/2.0,
t_size[0]/2.0,
numpy.shape(phase_map)[0])
coords_y = numpy.linspace(-t_size[1]/2.0,
t_size[1]/2.0,
numpy.shape(phase_map)[1])
X, Y = numpy.meshgrid(coords_x, coords_y)
phase_map = NearestNDInterpolator(zip(X.flatten(), Y.flatten()),
phase_map.flatten())
print min(target.pop.positions[0]), max(target.pop.positions[0])
print min(target.pop.positions[1]), max(target.pop.positions[1])
for (j, neuron2) in enumerate(target.pop.all()):
if or_map:
orientation = or_map(target.pop.positions[0][j],
target.pop.positions[1][j])
else:
orientation = parameters.orientation_preference.next()[0]
if phase_map:
phase = phase_map(target.pop.positions[0][j],
target.pop.positions[1][j])
else:
phase = parameters.phase.next()[0]
aspect_ratio = parameters.aspect_ratio.next()[0]
frequency = parameters.frequency.next()[0]
size = parameters.size.next()[0]
assert orientation < numpy.pi
target.add_neuron_annotation(j, 'LGNAfferentOrientation', orientation, protected=True)
target.add_neuron_annotation(j, 'LGNAfferentAspectRatio', aspect_ratio, protected=True)
target.add_neuron_annotation(j, 'LGNAfferentFrequency', frequency, protected=True)
target.add_neuron_annotation(j, 'LGNAfferentSize', size, protected=True)
target.add_neuron_annotation(j, 'LGNAfferentPhase', phase, protected=True)
if self.parameters.topological:
target.add_neuron_annotation(j, 'LGNAfferentX', target.pop.positions[0][j], protected=True)
target.add_neuron_annotation(j, 'LGNAfferentY', target.pop.positions[1][j], protected=True)
else:
target.add_neuron_annotation(j, 'LGNAfferentX', 0, protected=True)
target.add_neuron_annotation(j, 'LGNAfferentY', 0, protected=True)
ps = ParameterSet({ 'target_synapses' : 'excitatory',
'weight_functions' : { 'f1' : {
'component' : 'mozaik.connectors.vision.GaborArborization',
'params' : {
'ON' : True,
}
}
},
'delay_functions' : {},
'weight_expression' : 'f1', # a python expression that can use variables f1..fn where n is the number of functions in weight_functions, and fi corresponds to the name given to a ModularConnectorFunction in weight_function ParameterSet. It determines how are the weight functions combined to obtain the weights
'delay_expression' : str(self.parameters.delay),
'short_term_plasticity' : self.parameters.short_term_plasticity,
'base_weight' : self.parameters.base_weight,
'num_samples' : self.parameters.num_samples,
'fan_in' : self.parameters.fan_in,
})
ModularSamplingProbabilisticConnector(network,name+'On',lgn_on,target,ps).connect()
ps['weight_functions.f1.params.ON']=False
ModularSamplingProbabilisticConnector(network,name+'Off',lgn_off,target,ps).connect()
def __init__(self, network, lgn_on, lgn_off, target, parameters, name):
from numpy import random
random.seed(1023)
BaseComponent.__init__(self, network, parameters)
self.name = name
t_size = target.size_in_degrees()
or_map = None
if self.parameters.or_map:
f = open(self.parameters.or_map_location, 'r')
or_map = pickle.load(f) * numpy.pi
#or_map = pickle.load(f)*numpy.pi*2
#or_map = numpy.cos(or_map) + 1j*numpy.sin(or_map)
coords_x = numpy.linspace(-t_size[0] / 2.0, t_size[0] / 2.0,
numpy.shape(or_map)[0])
coords_y = numpy.linspace(-t_size[1] / 2.0, t_size[1] / 2.0,
numpy.shape(or_map)[1])
X, Y = numpy.meshgrid(coords_x, coords_y)
or_map = NearestNDInterpolator(zip(X.flatten(), Y.flatten()),
or_map.flatten())
#or_map = CloughTocher2DInterpolator(zip(X.flatten(), Y.flatten()),
# or_map.flatten())
phase_map = None
if self.parameters.phase_map:
f = open(self.parameters.phase_map_location, 'r')
phase_map = pickle.load(f)
coords_x = numpy.linspace(-t_size[0] / 2.0, t_size[0] / 2.0,
numpy.shape(phase_map)[0])
coords_y = numpy.linspace(-t_size[1] / 2.0, t_size[1] / 2.0,
numpy.shape(phase_map)[1])
X, Y = numpy.meshgrid(coords_x, coords_y)
phase_map = NearestNDInterpolator(zip(X.flatten(), Y.flatten()),
phase_map.flatten())
for (j, neuron2) in enumerate(target.pop.all()):
if or_map:
orientation = or_map(target.pop.positions[0][j],
target.pop.positions[1][j])
#orientation = (numpy.angle(or_map(target.pop.positions[0][j],
# target.pop.positions[1][j]))+numpy.pi)/2.0
else:
orientation = parameters.orientation_preference.next()
if phase_map:
phase = phase_map(target.pop.positions[0][j],
target.pop.positions[1][j])
else:
phase = parameters.phase.next()
aspect_ratio = parameters.aspect_ratio.next()
frequency = parameters.frequency.next()
size = parameters.size.next()
assert orientation < numpy.pi
target.add_neuron_annotation(j,
'LGNAfferentOrientation',
orientation,
protected=True)
target.add_neuron_annotation(j,
'LGNAfferentAspectRatio',
aspect_ratio,
protected=True)
target.add_neuron_annotation(j,
'LGNAfferentFrequency',
frequency,
protected=True)
target.add_neuron_annotation(j,
'LGNAfferentSize',
size,
protected=True)
target.add_neuron_annotation(j,
'LGNAfferentPhase',
phase,
protected=True)
target.add_neuron_annotation(j,
'aff_samples',
self.parameters.num_samples.next(),
protected=True)
if self.parameters.topological:
target.add_neuron_annotation(j,
'LGNAfferentX',
target.pop.positions[0][j] +
parameters.rf_jitter.next(),
protected=True)
target.add_neuron_annotation(j,
'LGNAfferentY',
target.pop.positions[1][j] +
parameters.rf_jitter.next(),
protected=True)
else:
target.add_neuron_annotation(j,
'LGNAfferentX',
parameters.rf_jitter.next(),
protected=True)
target.add_neuron_annotation(j,
'LGNAfferentY',
parameters.rf_jitter.next(),
protected=True)
ps = ParameterSet({
'target_synapses': 'excitatory',
'weight_functions': {
'f1': {
'component': 'mozaik.connectors.vision.GaborArborization',
'params': {
'ON': True,
}
}
},
'delay_functions': self.parameters.delay_functions,
'weight_expression':
'f1', # a python expression that can use variables f1..fn where n is the number of functions in weight_functions, and fi corresponds to the name given to a ModularConnectorFunction in weight_function ParameterSet. It determines how are the weight functions combined to obtain the weights
'delay_expression': self.parameters.delay_expression,
'short_term_plasticity': self.parameters.short_term_plasticity,
'base_weight': self.parameters.base_weight,
'num_samples': 0,
'annotation_reference_name': 'aff_samples',
})
ModularSamplingProbabilisticConnectorAnnotationSamplesCount(
network, name + 'On', lgn_on, target, ps).connect()
ps['weight_functions.f1.params.ON'] = False
ps['base_weight'] = self.parameters.base_weight * self.parameters.off_bias
ModularSamplingProbabilisticConnectorAnnotationSamplesCount(
network, name + 'Off', lgn_off, target, ps).connect()
