| |
This class represents any parameterized object, and is intended to be
subclassed so that you may use these features in your own objects. In
particular, DataInterface and NetInterface inherit from it.
It has a collection of parameters, params, and functions for adding, saving,
and laoding parameters, so far. Each parameter has a name, and the Parameter
object can be accessed via getParameter(name). The parameter's value can
easily be accessed and modified by self[name] and self[name]=, or equivalently
by getValue(name) and setValue(name,value).
When subclassing Parameterized, it is recommended that you avoid adding
parameters which are dependent on each other. For example, adding parameters
'myParameter'=2 and 'twiceMyParameter'=4 is bad. Then, when you change
'myParameter', you also have to change 'twiceMyParameter'. Instead, there
are two alternatives. First, you could add methods such as
twiceMyParameter() to calculate this parameter on the fly. Second, you can
calculate derived member data (e.g. self.twiceMyParameter) by overriding the
method calculateStateFromParams(). In this way, the derived parameters
are all generated at once.
Also, when pickling a Parameterized, all data is saved, as normal.
However, this is not always what you want; rather, you want to save the
parameters, since everything else is just described by those. So, you
should save parameters by calling Parameterized.savable(). That will get
a copy of just the parameters. This is what the Test class does to save
the results of an experiment.
|
| |
Methods defined here:
- __getitem__(self, name)
- Overload the [] operator to get parameter values.
- __init__(self)
- __repr__(self)
- __setitem__(self, name, value)
- Overload the [] operator to set parameter values.
- __str__(self)
- Adding a __str__ method will make str(parameterized) work.
- addParam(self, name, **attributes)
- Create a parameter with the given name and attributes.
The attributes must contain one of type, value, or default, since the
parameter must somehow determine its type. The calling syntax is the same
as Parameter.__init__.
- calculateStateFromParams()
- Override this to calculate derived state from parameters.
This is important because when saving, it is preferable to save only
parameters. Thus, upon loading (or upon changing parameters) this derived
information must be regenerated.
- getParam(self, name)
- Get the named parameter; this is NOT for getting the parameter's value.
- getValue(self, name)
- Get the value of the named parameter.
- getoptOptions(self)
- Get the getopt options for my parameters.
- hasParam(self, name)
- iterate(self, name=None, parameter=None, **iterParams)
- Iterate over the named parameter in numSteps even-sized steps from its
minimum to maximum value.
The resulting iterator iterates over copies of this Parameterized object
with different parameter values set. This makes it possible to use
recursively. It should be mentioned that all data is copied by reference,
except for the named parameter, which is duplicated in every copy.
Either the parameter should be named, or a parameter should be given to
iterate over.
Parameters
----------
name: The name of the parameter.
parameter: The parameter to iterate over.
iterParams: Extra parameters will be passed to the Parameter's
iterate method. Ordinarily, no other parameters need be passed.
- loadGetoptOptions(self, options)
- Read the parameters for my parameters from the options array while
ignoring unrelated options.
See the getopt library for more on getopt.
- loadParams(self, filename)
- Load parameters from a file.
- paramNames(self)
- Get all the names of my parameters
- printGetoptMessage(self)
- Print a list of options
- savable(self, *args, **keywordArgs)
- Create a savable copy of this Parameterized object containing just its
parameters and none of its other member data.
This is handy for saving Parameterized objects without all their messy
member data, such as generated data points or learned matrices. Saving
self, rather than savable(), can produce copious data. Of course, you
can override this to save additional data if you like.
Note: This function takes arguments and keyword arguments to pass
to the constructor of your class BUT nothing external should ever
use them. They are here to make it easy to override this method.
Suppose your class takes two non-optional parameters (param1 and
keywordParam) to its constructor. You can then easily override
Parameterized.savable() with the following code:
def savable(self):
return Parameterized.savable(self, param1, keywordParam)
- saveParams(self, filename)
- Save parameters to a file.
- setParam(self, name, param)
- Set the named parameter; this is NOT for setting the parameter's value.
- setValue(self, name, value)
- Set the value of the named parameter.
- valuesEqual(self, other, ignoredParams=[])
- Test whether the two Parameterized objects have the same parameters.
Note that this does _NOT_ check any other member data!
You should have all the important information as parameters.
Parameters
----------
other: Another Parameterized object to compare with
ignoredParams: Parameters to ignore when comparing values (e.g. one
might want to neglect the 'prefix' parameter).
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
|