class ImageSampler(param.Parameterized):
"""
A class of objects that, when called, sample an image.
"""
__abstract = True
def _get_image(self):
# CB: In general, might need to consider caching to avoid
# loading of image/creation of scs and application of wpofs
# every time/whatever the sampler does to set up the image
# before sampling
return self._image
def _set_image(self, image):
self._image = image
def _del_image(self):
del self._image
# As noted by JP in FastImageSampler, this isn't easy to figure out.
def __call__(self,
image,
x,
y,
sheet_xdensity,
sheet_ydensity,
width=1.0,
height=1.0):
raise NotImplementedError
image = overridable_property(_get_image, _set_image, _del_image)
class SheetMask(param.Parameterized):
"""
An abstract class that defines a mask over a ProjectionSheet object.
This class is typically used for optimization, where mask
indicates which neurons are active and should be processed
further. A mask can also be used for lesion experiments, to
specify which units should be kept inactive.
See the code for CFProjection and CFResponseFn to see how this
class can be used to restrict the computation to only those
neurons that the Mask lists as active.
"""
# JPALERT: Is there anything about this class that assumes its
# sheet is a ProjectionSheet?
def _get_data(self):
assert (self._sheet != None)
return self._data
def _set_data(self, data):
assert (self._sheet != None)
self._data = data
data = overridable_property(_get_data,
_set_data,
doc="""
Ensure that whenever somebody accesses the data they are not None.""")
def _get_sheet(self):
assert (self._sheet != None)
return self._sheet
def _set_sheet(self, sheet):
self._sheet = sheet
if (self._sheet != None): self.reset()
sheet = overridable_property(_get_sheet, _set_sheet)
def __init__(self, sheet=None, **params):
super(SheetMask, self).__init__(**params)
self.sheet = sheet
def __and__(self, mask):
return AndMask(self._sheet, submasks=[self, mask])
def __or__(self, mask):
return OrMask(self._sheet, submasks=[self, mask])
# JABALERT: Shouldn't this just keep one matrix around and zero it out,
# instead of allocating a new one each time?
def reset(self):
"""Initialize mask to default value (with no neurons masked out)."""
self.data = ones(self.sheet.shape)
def calculate(self):
"""
Calculate a new mask based on the activity of the sheet.
For instance, in an algorithm like LISSOM that is based on a
process of feedforward activation followed by lateral settling,
the calculation is done at the beginning of each iteration after
the feedforward activity has been calculated.
Subclasses should override this method to compute some non-default
mask.
"""
pass
# JABALERT: Not clear what the user should do with this.
def update(self):
"""
Update the current mask based on the current activity and a previous mask.
Should be called only if calculate() has already been called since the last
reset(); potentially faster to compute than redoing the entire calculate().
Subclasses should override this method to compute some non-default
mask.
"""
pass