A class to manage hierarchical parameter sets.
Usage example:
>>> sim_params = ParameterSet({'dt': 0.1, 'tstop': 1000.0})
>>> exc_cell_params = ParameterSet("http://neuralensemble.org/svn/NeuroTools/example.params")
>>> inh_cell_params = ParameterSet({'tau_m': 15.0, 'cm': 0.5})
>>> network_params = ParameterSet({'excitatory_cells': exc_cell_params, 'inhibitory_cells': inh_cell_params})
>>> P = ParameterSet({'sim': sim_params, 'network': network_params})
>>> P.sim.dt
0.1
>>> P.network.inhibitory_cells.tau_m
15.0
>>> print P.pretty()
Like __setitem__, but it will add ParameterSet({}) objects into the namespace tree if needed.
Return a unicode string representing the structure of the ParameterSet. evaluating the string should recreate the object.
ParameterSet definition s should be a Python dict definition string, containing objects of types int, float, str, list, dict plus the classes defined in this module, Parameter, ParameterRange, etc. No other object types are allowed, except the function url(‘some_url’) or ref(‘point.delimited.path’), e.g.:
{ 'a' : {'A': 3, 'B': 4},
'b' : [1,2,3],
'c' : 'hello world',
'd' : url('http://example.com/my_cool_parameter_set')
'e' : ref('level1_param_name.level2_param_name.level3_param_name') }
This is largely the JSON (www.json.org) format, but with extra keywords in the namespace such as ParameterRange, GammaDist, etc.
This expects its arguments to be in the form path=value, where path is a . (dot) delimited path to a parameter in the parameter tree rooted in this ParameterSet instance.
This function replaces the values of each parameter in the args with the corresponding values supplied in the arguments.
Write the parameter set to a text file.
The text file syntax is open to discussion. My idea is that it should be valid Python code, preferably importable as a module.
If url is None, try to save to self._url (if it is not None), otherwise save to url.
Bases: parameters.ParameterSet
A sub-class of ParameterSet that can represent a table of parameters.
i.e., it is limited to one-level of nesting, and each sub-dict must have the same keys. In addition to the possible initialisers for ParameterSet, a ParameterTable can be initialised from a multi-line string, e.g.:
>>> pt = ParameterTable('''
... # col1 col2 col3
... row1 1 2 3
... row2 4 5 6
... row3 7 8 9
... ''')
>>> pt.row2.col3
6.0
>>> pt.column('col1')
{'row1': 1.0, 'row2': 4.0, 'row3': 7.0}
>>> pt.transpose().col3.row2
6.0
A collection of ParameterSets, representing multiple points in parameter space. Created by putting ParameterRange and/or ParameterDist objects within a ParameterSet.
Return a dict with the keys and values of the parameters with ParameterRanges
Example:
>>> p = ParameterSpace({})
>>> p.b = ParameterRange([1,2,3])
>>> p.a = ParameterRange(['p','y','t','h','o','n'])
>>> data = p.get_ranges_values()
>>> data
{'a': ['p', 'y', 't', 'h', 'o', 'n'], 'b': [1, 2, 3]}
An iterator of the ParameterSpace which yields ParameterSets with all combinations of ParameterRange elements
An iterator of the ParameterSpace which yields ParameterSets with all combinations of ParameterRange elements which are given by the keys list.
Note: each newly yielded value is one and the same object so storing the returned values results in a collection of many of the lastly yielded object.
copy=True causes each yielded object to be a newly created object, but be careful because this is spawning many dictionaries!
An iterator of the ParameterSpace which yields the ParameterSet with the ParameterRange given by range_key replaced with each of its values
Return the number of ParameterSets that will be returned by the iter_inner() method.
Return the dimensions and labels of the keys for those elements which are ParameterRanges. range_keys are sorted to ensure the same ordering each time.
Return the index of the current experiment in the dimension of the parameter space i.e. parameter space dimension: [2,3] i.e. index: (1,0)
Example:
p = ParameterSet({})
p.b = ParameterRange([1,2,3])
p.a = ParameterRange(['p','y','t','h','o','n'])
results_dim, results_label = p.parameter_space_dimension_labels()
results = numpy.empty(results_dim)
for experiment in p.iter_inner():
index = p.parameter_space_index(experiment)
results[index] = 2.
Bases: parameters.random.ParameterDist
gamma.pdf(x,a,b) = x**(a-1)*exp(-x/b)/gamma(a)/b**a
Yields strictly positive numbers. Generally the distribution is implemented by scipy.stats.gamma.pdf(x/b,a)/b For more info, in ipython type:
>>> ? scipy.stats.gamma
Bases: parameters.random.ParameterDist
normal distribution with parameters mean + std
Bases: parameters.random.ParameterDist
uniform distribution with min,max
A sub-class of ParameterSet against which other ParameterSets can be validated.
Presently, it is more or less a ParameterSet, with all leafs(values) which are not explicitly a subclass of the SchemaBase object replaced by a Subclass(type=<leaf(value) type>) instance.
ParameterSchema may contain arbitrary Schema objects subclassed from SchemaBase which validate leafs by the member function validate(leaf) returning True or false if the given leaf in the ParameterSet at the same path should be validated or not, e.g.:
LambdaSchema('isinstance(x,str)',var='x'),
*unimplemented* Timedate('%.2d-%.2m-%.2y'), etc.
*unimplemented* Email()
*unimplemented* Url()
*unimplemented* File()
*unimplemented* FileExists()
etc.
Example:
>>> schema = ParameterSchema({'age': 0, 'height': Subclass(float)})
>>> # is equivalent to
>>> schema = ParameterSchema({'age': Subclass(int), 'height': Subclass(float)})
See also: SchemaBase, Eval, Subclass
A CongruencyValidator validates a ParameterSet against a ParameterSchema either returning True, or raising a ValidationError with the path, SchemaBase subclass and parameter value for which the validation failed.
The CongruencyValidator expects all names defined in the schema to be present in the parameter set and vice-versa, and will run validation for each item in the namespace tree.
The validation functionality is available via the “validate” member CongruencyValidator.validate(parameter_set, parameter_schema)
Example:
validator = CongruencyValidator()
try:
validator.validate(parameter_set,parameter_schema)
except ValidationError, e:
See also: ParameterSet, ParameterSchema
Validates a ParameterSet against a ParameterSchema either returning True, or raising a ValidationError with the path and SchemaBase subclass for which validation failed.
Expects all names defined in the schema to be present in the parameter set and vice-versa, and will run validation for each item in the namespace tree.
See also: CongruencyValidator.
The base class of all “active” Schema objects to be placed in a ParameterSchema.
Schema objects define the “validate” member which accepts the to-be-validated ParameterSet value from the same path as the Schema object in the ParameterSchema and returns True if the value is valid, otherwise False.
Bases: parameters.validators.SchemaBase
To be used as a value in a ParameterSchema. Validates the same-path ParameterSet value if it is of the specified type.
See also: SchemaBase
Bases: parameters.validators.SchemaBase
To be used as a value in a ParameterSchema. Validates the same-path ParameterSet value if the provided expression (with leaf(value) mapped to var in eval local namespace) evaluates to True.
See also: SchemaBase