def translate(self, parameters, copy=True):
"""Translate standardized model parameters to simulator-specific parameters."""
if copy:
_parameters = deepcopy(parameters)
else:
_parameters = parameters
cls = self.__class__
if parameters.schema != self.get_schema():
raise Exception(
"Schemas do not match: %s != %s" %
(parameters.schema, self.get_schema())
) # should replace this with a PyNN-specific exception type
native_parameters = {}
for name in parameters.keys():
D = self.translations[name]
pname = D['translated_name']
if callable(D['forward_transform']):
pval = D['forward_transform'](**_parameters)
else:
try:
pval = eval(D['forward_transform'], globals(), _parameters)
except NameError as errmsg:
raise NameError(
"Problem translating '%s' in %s. Transform: '%s'. Parameters: %s. %s"
% (pname, cls.__name__, D['forward_transform'],
parameters, errmsg))
except ZeroDivisionError:
raise
#pval = 1e30 # this is about the highest value hoc can deal with
native_parameters[pname] = pval
return ParameterSpace(native_parameters,
schema=None,
shape=parameters.shape)
def set(self, **attributes):
"""
Set connection attributes for all connections on the local MPI node.
Attribute names may be 'weights', 'delays', or the name of any parameter
of a synapse dynamics model (e.g. 'U' for TsodyksMarkramSynapse).
Each attribute value may be:
(1) a single number
(2) a RandomDistribution object
(3) a list/1D array of the same length as the number of local connections
(4) a 2D array with the same dimensions as the connectivity matrix
(as returned by `get(format='array')`
(5) a mapping function, which accepts a single float argument (the
distance between pre- and post-synaptic cells) and returns a single value.
Weights should be in nA for current-based and µS for conductance-based
synapses. Delays should be in milliseconds.
"""
# should perhaps add a "distribute" argument, for symmetry with "gather" in get()
parameter_space = ParameterSpace(attributes,
self.synapse_type.get_schema(),
(self.pre.size, self.post.size))
if isinstance(self.synapse_type, StandardSynapseType):
parameter_space = self.synapse_type.translate(parameter_space)
self._set_attributes(parameter_space)
def test_create_with_list_of_lists(self):
schema = {'a': Sequence}
ps = ParameterSpace({'a': [[1, 2, 3], [4, 5, 6]]}, schema, shape=(2, ))
ps.evaluate()
assert_array_equal(
ps['a'],
np.array(
[Sequence([1, 2, 3]), Sequence([4, 5, 6])], dtype=Sequence))
def test_create_with_tuple(self):
schema = {'a': Sequence}
ps = ParameterSpace({'a': (1, 2, 3)}, schema, shape=(2, ))
ps.evaluate()
assert_array_equal(
ps['a'],
np.array(
[Sequence([1, 2, 3]), Sequence([1, 2, 3])], dtype=Sequence))
def _get_parameters(self, *names):
"""
return a ParameterSpace containing native parameters
"""
parameter_dict = {}
for name in names:
parameter_dict[name] = simplify(self._parameters[name])
return ParameterSpace(parameter_dict, shape=(self.local_size, ))
def test_iteration_items(self):
ps = ParameterSpace({'a': [2, 3, 5, 8, 13], 'b': 7, 'c': lambda i: 3 * i + 2}, shape=(5,))
ps.evaluate(mask=[1, 3, 4])
expected = {'a': np.array([3, 8, 13]),
'c': np.array([5, 11, 14]),
'b': np.array([7, 7, 7])}
for key, value in ps.items():
assert_array_equal(expected[key], value)
def test_evaluate_with_mask(self):
ps = ParameterSpace({'a': [2, 3, 5, 8, 13], 'b': 7, 'c': lambda i: 3 * i + 2}, shape=(5,))
ps.evaluate(mask=[1, 3, 4])
expected = {'a': np.array([3, 8, 13]),
'c': np.array([5, 11, 14]),
'b': np.array([7, 7, 7])}
for key in expected:
assert_array_equal(expected[key], ps[key])
def __init__(self, **parameters):
self._device = nest.Create(self.nest_name)
self.cell_list = []
self.parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1,))
if parameters:
self.parameter_space.update(**parameters)
def __init__(self, **parameters):
"""
`parameters` should be a mapping object, e.g. a dict
"""
self.parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=None)
if parameters:
self.parameter_space.update(**parameters)
def __init__(self, **parameters):
self._device = nest.Create(self.nest_name)
self.cell_list = []
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1,))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
def _get_parameters(self, *names):
"""
return a ParameterSpace containing native parameters
"""
parameter_dict = {}
for name in names:
value = simplify(getattr(self.brian_group, name))
parameter_dict[name] = value
return ParameterSpace(parameter_dict, shape=(self.size, ))
def _get_parameters(self, *names):
"""Return a ParameterSpace containing native parameters"""
parameter_space = {}
for name in names:
value = simplify(self.celltype.parameter_space[name])
if isinstance(value, np.ndarray):
value = value[self.mask]
parameter_space[name] = value
return ParameterSpace(parameter_space, shape=(self.size, ))
def test_columnwise_iteration_single_column(self):
ps2d = ParameterSpace({'a': [[2, 3, 5, 8, 13], [21, 34, 55, 89, 144]],
'b': 7,
'c': lambda i, j: 3 * i - 2 * j}, shape=(2, 5))
ps2d.evaluate(mask=(slice(None), 3))
expected = [{'a': np.array([8, 89]), 'b': np.array([7, 7]), 'c': np.array([-6, -3])}]
actual = list(ps2d.columns())
for x, y in zip(actual, expected):
for key in y:
assert_array_equal(x[key], y[key])
def parameter_space(self):
timing_parameters = self.timing_dependence.parameter_space
weight_parameters = self.weight_dependence.parameter_space
parameters = ParameterSpace({'weight': self.weight,
'delay': self.delay,
'dendritic_delay_fraction': self.dendritic_delay_fraction},
self.get_schema())
parameters.update(**timing_parameters)
parameters.update(**weight_parameters)
return parameters
def test_evaluate(self):
ps = ParameterSpace(
{
'a': [2, 3, 5, 8],
'b': 7,
'c': lambda i: 3 * i + 2
}, shape=(4, ))
self.assertIsInstance(ps['c'], LazyArray)
ps.evaluate()
assert_array_equal(ps['c'], np.array([2, 5, 8, 11]))
def test_reverse_translate():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3, 'c': 44.4}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 1000.0),
('c', 'C', 'c + a', 'C - A'),
)
assert_equal(_parameter_space_to_dict(M().reverse_translate(ParameterSpace({'A': 23.4, 'B': 34500.0, 'C': 69.0})), 88),
{'a': 23.4, 'b': 34.5, 'c': 45.6})
def test_columnwise_iteration(self):
ps2d = ParameterSpace({'a': [[2, 3, 5, 8, 13], [21, 34, 55, 89, 144]],
'b': 7,
'c': lambda i, j: 3 * i - 2 * j}, shape=(2, 5))
ps2d.evaluate(mask=(slice(None), [1, 3, 4]))
expected = [{'a': np.array([3, 34]), 'b': np.array([7, 7]), 'c': np.array([-2, 1])},
{'a': np.array([8, 89]), 'b': np.array([7, 7]), 'c': np.array([-6, -3])},
{'a': np.array([13, 144]), 'b': np.array([7, 7]), 'c': np.array([-8, -5])}]
for x, y in zip(ps2d.columns(), expected):
for key in y:
assert_array_equal(x[key], y[key])
def _get_parameters(self, *names):
"""
return a ParameterSpace containing native parameters
"""
parameter_dict = {}
for name in names:
value = getattr(self.brian2_group, name)
if hasattr(value, "shape") and value.shape:
value = value[self.mask]
parameter_dict[name] = simplify(value)
return ParameterSpace(parameter_dict, shape=(self.size,))
def _get_parameters(self, *names):
"""
return a ParameterSpace containing native parameters
"""
parameter_dict = {}
for name in names:
value = simplify(getattr(self.brian_group, name))
if isinstance(value, numpy.ndarray):
value = value[self.mask]
parameter_dict[name] = value
return ParameterSpace(parameter_dict, shape=(self.size, ))
def _get_parameters(self, *names):
"""
return a ParameterSpace containing native parameters
"""
parameter_dict = {}
for name in names:
if name == 'spike_times': # hack
parameter_dict[name] = [Sequence(getattr(id._cell, name)) for id in self]
else:
parameter_dict[name] = simplify(numpy.array([getattr(id._cell, name) for id in self]))
return ParameterSpace(parameter_dict, shape=(self.local_size,))
def __init__(self, **parameters):
self._device = nest.Create(self.nest_name)
self.cell_list = []
self.parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1, ))
if parameters:
self.parameter_space.update(**parameters)
self.min_delay = state.min_delay
self.timestep = state.dt # NoisyCurrentSource has a parameter called "dt", so use "timestep" here
def _get_parameters(self, *names):
"""Return a ParameterSpace containing native parameters"""
parameter_space = {}
for name in names:
value = self.celltype.parameter_space[name]
value = simplify(value)
# lazyarray cannot handle np.bool_
if isinstance(value, np.bool_):
value = bool(value)
parameter_space[name] = value
return ParameterSpace(parameter_space, shape=(self.size, ))
def test_instantiate():
"""
Instantiating a StandardModelType should set self.parameter_space to a
ParameterSpace object containing the provided parameters.
"""
M = StandardModelType
M.default_parameters = {'a': 0.0, 'b': 0.0}
P1 = {'a': 22.2, 'b': 33.3}
m = M(**P1)
assert_equal(m.parameter_space._parameters, ParameterSpace(P1, None, None)._parameters)
M.default_parameters = {}
def __init__(self, **parameters):
super(StandardCurrentSource, self).__init__(**parameters)
self.cell_list = []
self.indices = []
simulator.state.current_sources.append(self)
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1, ))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
def _get_parameters(self, *names):
"""
return a ParameterSpace containing native parameters
"""
parameter_dict = {}
for name in names:
value = self.parent._parameters[name]
if isinstance(value, np.ndarray):
value = value[self.mask]
parameter_dict[name] = simplify(value)
return ParameterSpace(parameter_dict, shape=(self.size,)) # or local size?
def test_evaluate_with_mask_2D(self):
ps2d = ParameterSpace(
{
'a': [[2, 3, 5, 8, 13], [21, 34, 55, 89, 144]],
'b': 7,
'c': lambda i, j: 3 * i - 2 * j
},
shape=(2, 5))
ps2d.evaluate(mask=(slice(None), [1, 3, 4]))
assert_array_equal(ps2d['a'], np.array([[3, 8, 13], [34, 89, 144]]))
assert_array_equal(ps2d['c'], np.array([[-2, -6, -8], [1, -3, -5]]))
def test_translate_with_invalid_transformation():
M = StandardModelType
M.translations = build_translations(
('a', 'A'),
('b', 'B', 'b + z', 'B-Z'),
)
M.default_parameters = {'a': 22.2, 'b': 33.3}
# really we should trap such errors in build_translations(), not in translate()
m = M()
assert_raises(NameError,
m.translate,
ParameterSpace({'a': 23.4, 'b': 34.5}, m.get_schema(), None))
def test_translate_with_divide_by_zero_error():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 'b/0', 'B*0'),
)
m = M()
native_parameters = m.translate(ParameterSpace({'a': 23.4, 'b': 34.5}, m.get_schema(), 77))
assert_raises(ZeroDivisionError,
native_parameters.evaluate,
simplify=True)
def __init__(self, **parameters):
self._devices = []
self.cell_list = []
self._amplitudes = None
self._times = None
self._h_iclamps = {}
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1, ))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
def __init__(self, **parameters):
super(StandardCurrentSource, self).__init__(**parameters)
global current_sources
self.cell_list = []
self.indices = []
self.ind = len(current_sources) # Todo use self.indices instead...
current_sources.append(self)
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1,))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
