headers=['<structmember.h>'])
class CFPRF_DotProduct(CFPRF_Plugin):
"""
Wrapper written to allow transparent non-optimized fallback;
equivalent to CFPRF_Plugin(single_cf_fn=DotProduct()).
"""
# CB: should probably have single_cf_fn here & readonly
def __init__(self, **params):
super(CFPRF_DotProduct, self).__init__(single_cf_fn=DotProduct(),
**params)
provide_unoptimized_equivalent("CFPRF_DotProduct_opt", "CFPRF_DotProduct",
locals())
try:
from optimized_cy import CFPRF_DotProduct_cyopt # pyflakes:ignore (optimized version)
except:
pass
provide_unoptimized_equivalent_cy("CFPRF_DotProduct_cyopt", "CFPRF_DotProduct",
locals())
# CEBERRORALERT: ignores the sheet mask!
class CFPRF_EuclideanDistance_opt(CFPResponseFn):
"""
Euclidean-distance response function.
}
}
"""%c_decorators
inline(code, ['mask','X', 'strength', 'icols', 'temp_act','cfs','num_cfs','cf_type'],
local_dict=locals(), headers=['<structmember.h>'])
class CFPRF_DotProduct(CFPRF_Plugin):
"""
Wrapper written to allow transparent non-optimized fallback;
equivalent to CFPRF_Plugin(single_cf_fn=DotProduct()).
"""
# CB: should probably have single_cf_fn here & readonly
def __init__(self,**params):
super(CFPRF_DotProduct,self).__init__(single_cf_fn=DotProduct(),**params)
provide_unoptimized_equivalent("CFPRF_DotProduct_opt","CFPRF_DotProduct",locals())
try:
from optimized_cy import CFPRF_DotProduct_cyopt # pyflakes:ignore (optimized version)
except:
pass
provide_unoptimized_equivalent_cy("CFPRF_DotProduct_cyopt","CFPRF_DotProduct",locals())
# CEBERRORALERT: ignores the sheet mask!
class CFPRF_EuclideanDistance_opt(CFPResponseFn):
"""
Euclidean-distance response function.
Py_DECREF(cfs);
}
}
}
"""
inline(code, [
'projlist', 'active_units_mask', 'sheet_mask', 'num_cfs', 'length',
'cf_type'
],
local_dict=locals(),
headers=['<structmember.h>'])
provide_unoptimized_equivalent("compute_joint_norm_totals_opt",
"compute_joint_norm_totals", locals())
# CEBALERT: not tested
class LISSOM_Opt(LISSOM):
"""
Faster but potentially unsafe optimized version of LISSOM.
Adds a NeighborhoodMask that skips computation for neurons
sufficiently distant from all those activated in the first few
steps of settling. This is safe only if activity bubbles reliably
shrink after the first few steps; otherwise the results will
differ from LISSOM.
Typically useful only for standard LISSOM simulations with
localized (e.g. Gaussian) inputs and that shrink the lateral
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>'])
class CFPLF_Hebbian(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)
provide_unoptimized_equivalent("CFPLF_Hebbian_opt","CFPLF_Hebbian",locals())
# CBERRORALERT: classes from here on probably ignore the sheet mask
# JABALERT: Is this really a fixed-threshold BCM rule? If so, is that really useful?
class CFPLF_BCMFixed_opt(CFPLearningFn):
"""
CF-aware BCM learning rule.
Implemented in C for speed. Should be equivalent to
BCMFixed for CF sheets, 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.
LOOKUP_FROM_SLOT_OFFSET(double,_norm_total,cf);
_norm_total[0] = nt;
LOOKUP_FROM_SLOT_OFFSET(int,_has_norm_total,cf);
_has_norm_total[0] = 1;
Py_DECREF(cfs);
}
}
}
"""
inline(code, ['projlist','active_units_mask','sheet_mask','num_cfs','length','cf_type'],
local_dict=locals(),
headers=['<structmember.h>'])
provide_unoptimized_equivalent("compute_joint_norm_totals_opt",
"compute_joint_norm_totals",locals())
# CEBALERT: not tested
class SettlingCFSheet_Opt(SettlingCFSheet):
"""
Faster but potentially unsafe optimized version of SettlingCFSheet.
Adds a NeighborhoodMask that skips computation for neurons
sufficiently distant from all those activated in the first few
steps of settling. This is safe only if activity bubbles reliably
shrink after the first few steps; otherwise the results will
differ from SettlingCFSheet.
Typically useful only for standard SettlingCFSheet simulations with
localized (e.g. Gaussian) inputs and that shrink the lateral
excitatory radius, which results in small patches of activity in
LOOKUP_FROM_SLOT_OFFSET(double,_norm_total,cf);
_norm_total[0] = nt;
LOOKUP_FROM_SLOT_OFFSET(int,_has_norm_total,cf);
_has_norm_total[0] = 1;
Py_DECREF(cfs);
}
}
}
"""
inline(code, ['projlist','active_units_mask','sheet_mask','num_cfs','length','cf_type'],
local_dict=locals(),
headers=['<structmember.h>'])
provide_unoptimized_equivalent("compute_joint_norm_totals_opt",
"compute_joint_norm_totals",locals())
# CEBALERT: not tested
class LISSOM_Opt(LISSOM):
"""
Faster but potentially unsafe optimized version of LISSOM.
Adds a NeighborhoodMask that skips computation for neurons
sufficiently distant from all those activated in the first few
steps of settling. This is safe only if activity bubbles reliably
shrink after the first few steps; otherwise the results will
differ from LISSOM.
Typically useful only for standard LISSOM simulations with
localized (e.g. Gaussian) inputs and that shrink the lateral
excitatory radius, which results in small patches of activity in
single_cf_fn = param.ClassSelector(
TransferFn,default=DivisiveNormalizeL1(norm_value=1.0),constant=True)
def __call__(self, iterator, **params):
"""
Uses the cf.norm_total attribute to allow optimization
by computing the sum separately, and to allow joint
normalization. After use, cf.norm_total is deleted because
the value it would have has been changed.
"""
# CEBALERT: fix this here and elsewhere
if type(self.single_cf_fn) is not IdentityTF:
norm_value = self.single_cf_fn.norm_value
for cf,i in iterator():
current_sum=cf.norm_total
if current_sum > 0.0000000000001:
factor = norm_value/current_sum
cf.weights *= factor
del cf.norm_total
provide_unoptimized_equivalent("CFPOF_DivisiveNormalizeL1_opt","CFPOF_DivisiveNormalizeL1",locals())
__all__ = list(set([k for k,v in locals().items() if isinstance(v,type) and
(issubclass(v,TransferFn) or issubclass(v,CFPOutputFn))]))
__all__.remove("CFPOutputFn")
__all__.remove("TransferFn")
__all__.remove("IdentityTF")
__all__.remove("DivisiveNormalizeL1")
if(HUE2(i,j)<0)
HUE2(i,j)+=1;
//else if(HUE2(i,j)>1)
// HUE2(i,j)-=1;
}
}
}
"""
inline(code, ['red','grn','blu','hue','sat','val'], local_dict=locals())
return numpy.dstack((hue,sat,val))
provide_unoptimized_equivalent("_rgb_to_hsv_array_opt","_rgb_to_hsv_array",locals())
def _hsv_to_rgb_array_opt(HSV):
"""Equivalent to hsv_to_rgb_array()."""
hue = HSV[:,:,0]
sat = HSV[:,:,1]
val = HSV[:,:,2]
shape = hue.shape
dtype = hue.dtype
red = numpy.zeros(shape,dtype=dtype)
grn = numpy.zeros(shape,dtype=dtype)
inline(code, [
'input_activity', 'output_activity', 'sheet_mask', 'num_cfs',
'icols', 'cfs', 'single_connection_learning_rate', 'cf_type'
],
local_dict=locals(),
headers=['<structmember.h>'])
class CFPLF_Hebbian(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)
provide_unoptimized_equivalent("CFPLF_Hebbian_opt", "CFPLF_Hebbian", locals())
# CBERRORALERT: classes from here on probably ignore the sheet mask
# JABALERT: Is this really a fixed-threshold BCM rule? If so, is that really useful?
class CFPLF_BCMFixed_opt(CFPLearningFn):
"""
CF-aware BCM learning rule.
Implemented in C for speed. Should be equivalent to
BCMFixed for CF sheets, 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.
