class CFPLF_OutstarHebbian(CFPLearningFn): """ CFPLearningFunction applying the specified (default is Hebbian) single_cf_fn to each CF, where normalization is done in an outstar-manner. Presumably does not need a separate output_fn for normalization. NOT YET TESTED. """ single_cf_fn = param.ClassSelector( LearningFn, default=Hebbian(), doc="LearningFn that will be applied to each CF individually.") outstar_wsum = None def __call__(self, iterator, input_activity, output_activity, learning_rate, **params): single_connection_learning_rate = self.constant_sum_connection_rate( iterator.proj_n_units, learning_rate) # avoid evaluating these references each time in the loop single_cf_fn = self.single_cf_fn outstar_wsum = zeros(input_activity.shape) for cf, i in iterator(): single_cf_fn(cf.get_input_matrix(input_activity), output_activity.flat[i], cf.weights, single_connection_learning_rate) # Outstar normalization wrows, wcols = cf.weights.shape for wr in xrange(wrows): for wc in xrange(wcols): outstar_wsum[wr][wc] += cf.weights[wr][wc] # CEBHACKALERT: see ConnectionField.__init__() cf.weights *= cf.mask
class CFSPLF_Plugin(param.Parameterized): """CFSPLearningFunction applying the specified single_cf_fn to each Sparse CF.""" single_cf_fn = param.ClassSelector(LearningFn,default=Hebbian(),doc=""" Accepts a LearningFn that will be applied to each CF individually.""") def constant_sum_connection_rate(self,n_units,learning_rate): """ Return the learning rate for a single connection assuming that the total rate is to be divided evenly among all the units in the connection field. """ return float(learning_rate)/n_units def __call__(self, projection, **params): """Apply the specified single_cf_fn to every sparse CF.""" single_connection_learning_rate = self.constant_sum_connection_rate(projection.n_units,projection.learning_rate) # avoid evaluating these references each time in the loop single_cf_fn = self.single_cf_fn for cf in projection.flatcfs: temp_weights = cf.weights single_cf_fn(cf.get_input_matrix(projection.src.activity), projection.dest.activity.flat[cf.oned_idx], temp_weights, single_connection_learning_rate) temp_weights *= cf.mask cf.weights = temp_weights
class CFPLF_Trace(CFPLearningFn): """ LearningFn that incorporates a trace of recent activity, not just the current activity. Based on P. Foldiak (1991), "Learning Invariance from Transformation Sequences", Neural Computation 3:194-200. Also see Sutton and Barto (1981) and Wallis and Rolls (1997). Incorporates a decay term to keep the weight vector bounded, and so it does not normally require any output_fn normalization for stability. NOT YET TESTED. """ trace_strength = param.Number( default=0.5, bounds=(0.0, 1.0), doc= "How much the learning is dominated by the activity trace, relative to the current value." ) single_cf_fn = param.ClassSelector( LearningFn, default=Hebbian(), doc="LearningFn that will be applied to each CF individually.") def __call__(self, iterator, input_activity, output_activity, learning_rate, **params): single_connection_learning_rate = self.constant_sum_connection_rate( iterator.proj_n_units, learning_rate) ##Initialise traces to zero if they don't already exist if not hasattr(self, 'traces'): self.traces = zeros(output_activity.shape, activity_type) for cf, i in iterator(): unit_activity = output_activity.flat[i] # print "unit activity is",unit_activity # print "self trace is",self.traces[r,c] new_trace = (self.trace_strength * unit_activity) + ( (1 - self.trace_strength) * self.traces.flat[i]) # print "and is now",new_trace self.traces.flat[i] = new_trace cf.weights += single_connection_learning_rate * new_trace * \ (cf.get_input_matrix(input_activity) - cf.weights) #CEBHACKALERT: see ConnectionField.__init__() cf.weights *= cf.mask
class CFPLF_PluginScaled(CFPLearningFn): """ CFPLearningFunction applying the specified single_cf_fn to each CF. Scales the single-connection learning rate by a scaling factor that is different for each individual unit. Thus each individual connection field uses a different learning rate. """ single_cf_fn = param.ClassSelector( LearningFn, default=Hebbian(), doc="Accepts a LearningFn that will be applied to each CF individually." ) learning_rate_scaling_factor = param.Parameter( default=None, doc= "Matrix of scaling factors for scaling the learning rate of each CF individually." ) def __call__(self, iterator, input_activity, output_activity, learning_rate, **params): """Apply the specified single_cf_fn to every CF.""" if self.learning_rate_scaling_factor is None: self.learning_rate_scaling_factor = ones(output_activity.shape) single_cf_fn = self.single_cf_fn single_connection_learning_rate = self.constant_sum_connection_rate( iterator.proj_n_units, learning_rate) for cf, i in iterator(): sc_learning_rate = self.learning_rate_scaling_factor.flat[ i] * single_connection_learning_rate single_cf_fn(cf.get_input_matrix(input_activity), output_activity.flat[i], cf.weights, sc_learning_rate) # CEBHACKALERT: see ConnectionField.__init__() re. mask & output fn cf.weights *= cf.mask def update_scaling_factor(self, new_scaling_factor): """Update the single-connection learning rate scaling factor.""" self.learning_rate_scaling_factor = new_scaling_factor
class CFPLF_Hebbian_cython(CFPLF_Plugin): """Same as CFPLF_Plugin(single_cf_fn=Hebbian()); just for non-optimized fallback.""" single_cf_fn = param.ClassSelector(LearningFn,default=Hebbian(),readonly=True)
class HomeoSynaptic(CFPLearningFn): """ Learning function using homeostatic synaptic scaling from Sullivan & de Sa, "Homeostatic Synaptic Scaling in Self-Organizing Maps", Neural Networks (2006), 19(6-7):734-43. Does not necessarily require output_fn normalization for stability. """ single_cf_fn = param.ClassSelector( LearningFn, default=Hebbian(), doc="LearningFn that will be applied to each CF individually") beta_n = param.Number(default=0.01, bounds=(0, None), doc="homeostatic learning rate") beta_c = param.Number( default=0.005, bounds=(0, None), doc="time window over which the neuron's firing rate is averaged") activity_target = param.Number(default=0.1, bounds=(0, None), doc="Target average activity") #debug = param.Boolean(default=False,doc="Print average activity values") #beta_n = param.Number(default=0.00033,bounds=(0,None),doc="Homeostatic learning rate") #Too small? #beta_c = param.Number(default=0.000033,bounds=(0,None),doc="Time window over which the neuron's firing rate is averaged") def __init__(self, **params): super(HomeoSynaptic, self).__init__(**params) self.temp_hist = [] self.ave_hist = [] def __call__(self, iterator, input_activity, output_activity, learning_rate, **params): """ Update the value of the given weights matrix based on the input_activity matrix (of the same size as the weights matrix) and the response of this unit (the unit_activity), governed by a per-connection learning rate. """ if not hasattr(self, 'averages'): self.averages = ones(output_activity.shape, Float) * 0.1 # normalize initial weights to 1.0 for cf, i in iterator(): current_norm_value = 1.0 * Numeric.sum(abs(cf.weights.ravel())) if current_norm_value != 0: factor = (1.0 / current_norm_value) cf.weights *= factor # compute recent average of output activity self.averages = self.beta_c * output_activity + ( 1.0 - self.beta_c) * self.averages activity_norm = 1.0 + self.beta_n * \ ((self.averages - self.activity_target)/self.activity_target) single_connection_learning_rate = self.constant_sum_connection_rate( iterator.proj_n_units, learning_rate) # avoid evaluating these references each time in the loop single_cf_fn = self.single_cf_fn for cf, i in iterator(): single_cf_fn(cf.get_input_matrix(input_activity), output_activity.flat[i], cf.weights, single_connection_learning_rate) # homeostatic normalization cf.weights /= activity_norm.flat[i] # CEBHACKALERT: see ConnectionField.__init__() cf.weights *= cf.mask # For analysis only; can be removed (in which case also remove the initializations above) # CEBALERT: I changed [0][7] to [0]! self.ave_hist.append(self.averages.flat[0]) self.temp_hist.append( Numeric.sum(abs(iterator.flatcfs[0].weights.ravel())))
class CFPLF_Trace_opt(CFPLearningFn): """ Optimized version of CFPLF_Trace; see projfn.py for more info """ trace_strength = param.Number(default=0.5, bounds=(0.0, 1.0), doc=""" How much the learning is dominated by the activity trace, relative to the current value.""" ) single_cf_fn = param.ClassSelector( LearningFn, default=Hebbian(), readonly=True, doc="LearningFn that will be applied to each CF individually.") def __call__(self, iterator, input_activity, output_activity, learning_rate, **params): cfs = iterator.flatcfs # pyflakes:ignore (passed to weave C code) single_connection_learning_rate = self.constant_sum_connection_rate( iterator.proj_n_units, learning_rate) irows, icols = input_activity.shape if single_connection_learning_rate == 0: return cfs = iterator.flatcfs num_cfs = len(cfs) # pyflakes:ignore (passed to weave C code) ##Initialise traces to zero if they don't already exist if not hasattr(self, 'traces'): self.traces = zeros(output_activity.shape, activity_type) self.traces = (self.trace_strength * output_activity) + ( (1 - self.trace_strength) * self.traces) traces = self.traces # pyflakes:ignore (passed to weave C code) cf_type = iterator.cf_type # pyflakes:ignore (passed to weave C code) code = c_header + """ DECLARE_SLOT_OFFSET(weights,cf_type); DECLARE_SLOT_OFFSET(input_sheet_slice,cf_type); DECLARE_SLOT_OFFSET(mask,cf_type); DECLARE_SLOT_OFFSET(_norm_total,cf_type); DECLARE_SLOT_OFFSET(_has_norm_total,cf_type); %(cfs_loop_pragma)s for (int r=0; r<num_cfs; ++r) { double load = traces[r]; if (load != 0) { load *= single_connection_learning_rate; PyObject *cf = PyList_GetItem(cfs,r); LOOKUP_FROM_SLOT_OFFSET(float,weights,cf); LOOKUP_FROM_SLOT_OFFSET(int,input_sheet_slice,cf); LOOKUP_FROM_SLOT_OFFSET(float,mask,cf); UNPACK_FOUR_TUPLE(int,rr1,rr2,cc1,cc2,input_sheet_slice); double total = 0.0; // modify non-masked weights npfloat *inpj = input_activity+icols*rr1+cc1; for (int i=rr1; i<rr2; ++i) { npfloat *inpi = inpj; for (int j=cc1; j<cc2; ++j) { // The mask is floating point, so we have to // use a robust comparison instead of testing // against exactly 0.0. if (*(mask++) >= MASK_THRESHOLD) { *weights += load * *inpi; total += fabs(*weight); } ++weights; ++inpi; } inpj += icols; } // store the sum of the cf's weights LOOKUP_FROM_SLOT_OFFSET(double,_norm_total,cf); _norm_total[0]=total; LOOKUP_FROM_SLOT_OFFSET(int,_has_norm_total,cf); _has_norm_total[0]=1; } } """ % c_decorators inline(code, [ 'input_activity', 'traces', 'num_cfs', 'icols', 'cfs', 'single_connection_learning_rate', 'cf_type' ], local_dict=locals(), headers=['<structmember.h>'])
class CFPLF_Scaled_opt(CFPLF_PluginScaled): """ CF-aware Scaled Hebbian learning rule. Implemented in C for speed. Should be equivalent to CFPLF_PluginScaled(single_cf_fn=Hebbian), except faster. As a side effect, sets the norm_total attribute on any cf whose weights are updated during learning, to speed up later operations that might depend on it. """ single_cf_fn = param.ClassSelector(LearningFn, default=Hebbian(), readonly=True) def __call__(self, iterator, input_activity, output_activity, learning_rate, **params): if self.learning_rate_scaling_factor is None: self.learning_rate_scaling_factor = ones( output_activity.shape) * 1.0 learning_rate_scaling_factor = self.learning_rate_scaling_factor # pyflakes:ignore (passed to weave C code) single_connection_learning_rate = self.constant_sum_connection_rate( iterator.proj_n_units, learning_rate) if single_connection_learning_rate == 0: return cfs = iterator.flatcfs num_cfs = len(cfs) # pyflakes:ignore (passed to weave C code) irows, icols = input_activity.shape cf_type = iterator.cf_type # pyflakes:ignore (passed to weave C code) sheet_mask = iterator.get_sheet_mask( ) # pyflakes:ignore (passed to weave C code) code = c_header + """ DECLARE_SLOT_OFFSET(weights,cf_type); DECLARE_SLOT_OFFSET(input_sheet_slice,cf_type); DECLARE_SLOT_OFFSET(mask,cf_type); DECLARE_SLOT_OFFSET(_norm_total,cf_type); DECLARE_SLOT_OFFSET(_has_norm_total,cf_type); %(cfs_loop_pragma)s for (int r=0; r<num_cfs; ++r) { double load = output_activity[r]; double a = learning_rate_scaling_factor[r]; load = load * a; if (load != 0 && sheet_mask[r] != 0) { load *= single_connection_learning_rate; PyObject *cf = PyList_GetItem(cfs,r); LOOKUP_FROM_SLOT_OFFSET(float,weights,cf); LOOKUP_FROM_SLOT_OFFSET(int,input_sheet_slice,cf); LOOKUP_FROM_SLOT_OFFSET(float,mask,cf); UNPACK_FOUR_TUPLE(int,rr1,rr2,cc1,cc2,input_sheet_slice); double total = 0.0; // modify non-masked weights npfloat *inpj = input_activity+icols*rr1+cc1; for (int i=rr1; i<rr2; ++i) { npfloat *inpi = inpj; for (int j=cc1; j<cc2; ++j) { // The mask is floating point, so we have to // use a robust comparison instead of testing // against exactly 0.0. if (*(mask++) >= MASK_THRESHOLD) { *weights += load * *inpi; total += fabs(*weights); } ++weights; ++inpi; } inpj += icols; } // store the sum of the cf's weights LOOKUP_FROM_SLOT_OFFSET(double,_norm_total,cf); _norm_total[0]=total; LOOKUP_FROM_SLOT_OFFSET(int,_has_norm_total,cf); _has_norm_total[0]=1; } } """ % c_decorators inline(code, [ 'input_activity', 'learning_rate_scaling_factor', 'output_activity', 'sheet_mask', 'num_cfs', 'icols', 'cfs', 'single_connection_learning_rate', 'cf_type' ], local_dict=locals(), headers=['<structmember.h>'])
class CFPLF_Hebbian_opt(CFPLearningFn): """ CF-aware Hebbian learning rule. Implemented in C for speed. Should be equivalent to CFPLF_Plugin(single_cf_fn=Hebbian), except faster. As a side effect, sets the norm_total attribute on any cf whose weights are updated during learning, to speed up later operations that might depend on it. May return without modifying anything if the learning rate turns out to be zero. """ single_cf_fn = param.ClassSelector(LearningFn, default=Hebbian(), readonly=True) def __call__(self, iterator, input_activity, output_activity, learning_rate, **params): single_connection_learning_rate = self.constant_sum_connection_rate( iterator.proj_n_units, learning_rate) if single_connection_learning_rate == 0: return cfs = iterator.flatcfs num_cfs = len(cfs) # pyflakes:ignore (passed to weave C code) irows, icols = input_activity.shape cf_type = iterator.cf_type # pyflakes:ignore (passed to weave C code) # CEBALERT: this function *always* skips inactive units, # because it uses the output_activity directly rather than # going through the iterator. That's ok since we know this # function can always skip inactive units. But the unoptimized # equivalent should be made to do the same, because right now # it respects the iterator. (Just a case of setting the # iterator's active_units_mask to be True before calling the # iterator in the unoptimized version.) sheet_mask = iterator.get_sheet_mask( ) # pyflakes:ignore (passed to weave C code) code = c_header + """ DECLARE_SLOT_OFFSET(weights,cf_type); DECLARE_SLOT_OFFSET(input_sheet_slice,cf_type); DECLARE_SLOT_OFFSET(mask,cf_type); DECLARE_SLOT_OFFSET(_norm_total,cf_type); DECLARE_SLOT_OFFSET(_has_norm_total,cf_type); %(cfs_loop_pragma)s for (int r=0; r<num_cfs; ++r) { double load = output_activity[r]; if (load != 0 && sheet_mask[r] != 0) { load *= single_connection_learning_rate; PyObject *cf = PyList_GetItem(cfs,r); LOOKUP_FROM_SLOT_OFFSET(float,weights,cf); LOOKUP_FROM_SLOT_OFFSET(int,input_sheet_slice,cf); LOOKUP_FROM_SLOT_OFFSET(float,mask,cf); UNPACK_FOUR_TUPLE(int,rr1,rr2,cc1,cc2,input_sheet_slice); double total = 0.0; // modify non-masked weights npfloat *inpj = input_activity+icols*rr1+cc1; for (int i=rr1; i<rr2; ++i) { npfloat *inpi = inpj; for (int j=cc1; j<cc2; ++j) { // The mask is floating point, so we have to // use a robust comparison instead of testing // against exactly 0.0. if (*(mask++) >= MASK_THRESHOLD) { *weights += load * *inpi; total += fabs(*weights); } ++weights; ++inpi; } inpj += icols; } // store the sum of the cf's weights LOOKUP_FROM_SLOT_OFFSET(double,_norm_total,cf); _norm_total[0]=total; LOOKUP_FROM_SLOT_OFFSET(int,_has_norm_total,cf); _has_norm_total[0]=1; } } """ % c_decorators inline(code, [ 'input_activity', 'output_activity', 'sheet_mask', 'num_cfs', 'icols', 'cfs', 'single_connection_learning_rate', 'cf_type' ], local_dict=locals(), headers=['<structmember.h>'])