def get_pattern(self, w, h, num=50, scale=3.0, size=0.1, energy=3500, mitsuba=False, seed=None, dataset=False):
if seed is None:
seed = random.randint(0,19920208)
else:
seed = seed + int(time.time())
if num == 0:
ibl = np.zeros((256,512))
else:
# factor = 80/256
factor = 1.0
gs = ig.Composite(operator=np.add,
generators=[ig.Gaussian(
size=size*ng.UniformRandom(seed=seed+i+4),
scale=scale*(ng.UniformRandom(seed=seed+i+5)+1e-3),
x=ng.UniformRandom(seed=seed+i+1)-0.5,
y=(ng.UniformRandom(seed=seed+i+2)-0.5)*factor,
aspect_ratio=0.7,
orientation=np.pi*ng.UniformRandom(seed=seed+i+3),
) for i in range(num)],
position=(0, 0),
xdensity=512)
ibl = self.normalize(gs(), energy)
# prepare to fix energy inconsistent
if dataset:
ibl = self.to_dataset(ibl, w, h)
if mitsuba:
return ibl, self.to_mts_ibl(np.copy(ibl))
else:
return ibl
def setUp(self):
param.Dynamic.time_dependent = False
class TestPO1(param.Parameterized):
x = param.Dynamic(default=numbergen.UniformRandom(lbound=-1,
ubound=1,
seed=1),
doc="nothing")
y = param.Dynamic(default=1)
class TestPO2(param.Parameterized):
x = param.Dynamic(
default=numbergen.UniformRandom(lbound=-1, ubound=1, seed=30))
y = param.Dynamic(default=1.0)
self.TestPO2 = TestPO2
self.TestPO1 = TestPO1
self.t1 = self.TestPO1()
self.t2 = self.TestPO1(
x=numbergen.UniformRandom(lbound=-1, ubound=1, seed=10))
self.t3 = self.TestPO1(
x=numbergen.UniformRandom(lbound=-1, ubound=1, seed=10))
self.t2.set_dynamic_time_fn(None)
self.t3.set_dynamic_time_fn(None)
self.t6 = self.TestPO2()
self.t7 = self.TestPO2()
def test_range(self):
lbound = 2.0
ubound = 5.0
gen = numbergen.UniformRandom(seed=_seed, lbound=lbound, ubound=ubound)
for _ in range(_iterations):
value = gen()
self.assertTrue(lbound <= value < ubound)
def Retina(self, properties):
input_generator=self['training_patterns'][properties['eye']+'Retina'
if 'eye' in properties
else 'Retina']
if 'cr' in self.dims and self.dataset!='Gaussian':
for pattern_number, individual_generator in enumerate(input_generator.generators):
brightness_difference=numbergen.UniformRandom(lbound=(-1.0+self.dim_fraction)/2.0,
ubound=(1.0-self.dim_fraction)/2.0,
seed=456+pattern_number,
name="Dim"+str(pattern_number))
if 'eye' in properties and properties['eye']=='Left':
hsv = colorsys.rgb_to_hsv(*self.cone_scale)
hsv_dimmed=(hsv[0],hsv[1],hsv[2]+brightness_difference)
channel_factors = list(colorsys.hsv_to_rgb(*hsv_dimmed))
elif 'eye' in properties and properties['eye']=='Right':
hsv = colorsys.rgb_to_hsv(*self.cone_scale)
hsv_dimmed=(hsv[0],hsv[1],hsv[2]-brightness_difference)
channel_factors = list(colorsys.hsv_to_rgb(*hsv_dimmed))
else:
channel_factors = self.cone_scale
individual_generator.channel_transforms.append(
ScaleChannels(channel_factors = channel_factors))
return Model.ChannelGeneratorSheet.params(
period=self['period'],
phase=0.05,
nominal_density=self.retina_density,
nominal_bounds=sheet.BoundingBox(radius=self.area/2.0
+ self.v1aff_radius*self.sf_spacing**(max(self['SF'])-1)
+ self.lgnaff_radius*self.sf_spacing**(max(self['SF'])-1)
+ self.lgnlateral_radius),
input_generator=input_generator)
def test_cfsom(self):
"""
"""
gaussian_width = 0.02
gaussian_height = 0.9
input_pattern = Gaussian(
bounds=BoundingBox(points=((-0.8, -0.8), (0.8, 0.8))),
scale=gaussian_height,
aspect_ratio=gaussian_width / gaussian_height,
x=numbergen.UniformRandom(lbound=-0.5, ubound=0.5, seed=100),
y=numbergen.UniformRandom(lbound=-0.5, ubound=0.5, seed=200),
orientation=numbergen.UniformRandom(lbound=-pi,
ubound=pi,
seed=300))
# input generation params
GeneratorSheet.period = 1.0
GeneratorSheet.nominal_density = 5
# cf som parameters
CFSheet.nominal_density = 5
###########################################
# build simulation
s = Simulation()
s.verbose("Creating simulation objects...")
s['retina'] = GeneratorSheet(input_generator=input_pattern)
s['V1'] = CFSheet()
s.connect('retina',
'V1',
delay=1,
connection_type=CFProjection,
learning_fn=CFPLF_Hebbian_opt())
self.assertTrue(
topo.sim['V1'].projections().get('retinaToV1', None) != None)
self.assertTrue(
topo.sim['V1'].projections().get('retinaToV1', None) != None)
s.run(10)
def __call__(self, pattern, pattern_label, pattern_number, master_seed,
**params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
new_pattern = copy.copy(pattern)
new_pattern.y = pattern.get_value_generator('y')+\
numbergen.UniformRandom(lbound=-p.position_bound_y,
ubound=p.position_bound_y,
seed=master_seed+35+pattern_number,
name="YCoordinator"+str(pattern_number))
return new_pattern
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params):
p = ParamOverrides(self,params,allow_extra_keywords=True)
new_pattern=copy.copy(pattern)
new_pattern.size=pattern.get_value_generator('size')*\
numbergen.UniformRandom(lbound=1,
ubound=p.sf_spacing**(p.sf_max_channel-1),
seed=master_seed+77+pattern_number,
name="SpatialFrequencyCoordinator"+str(pattern_number))
return new_pattern
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params):
p = ParamOverrides(self,params,allow_extra_keywords=True)
new_pattern=copy.copy(pattern)
if(pattern_label.count('Left')):
new_pattern.scale = (1-p.dim_fraction) + p.dim_fraction * \
(2.0-numbergen.UniformRandom(lbound=0,
ubound=2,
seed=master_seed+55+pattern_number,
name="OcularityCoordinator"+str(pattern_number)))
elif(pattern_label.count('Right')):
new_pattern.scale = (1-p.dim_fraction) + p.dim_fraction * \
numbergen.UniformRandom(lbound=0,
ubound=2,
seed=master_seed+55+pattern_number,
name="OcularityCoordinator"+str(pattern_number))
else:
self.warning('Skipping region %s; Ocularity is defined only for Left and Right retinas.' % pattern)
return new_pattern
def test_outside_bounds_numbergen(self):
t1 = TestPO1()
# Test bounds (dynamic number)
t1.x = numbergen.UniformRandom(lbound=2,ubound=3) # bounds not checked on set
try:
t1.x
except ValueError:
pass
else:
assert False, "Should raise ValueError."
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params):
p = ParamOverrides(self,params,allow_extra_keywords=True)
new_pattern=copy.copy(pattern)
if(pattern_label.count('Left')):
new_pattern.x = pattern.get_value_generator('x')-\
numbergen.UniformRandom(lbound=-p.disparity_bound,
ubound=p.disparity_bound,
seed=master_seed+45+pattern_number,
name="DisparityCoordinator"+str(pattern_number))
elif(pattern_label.count('Right')):
new_pattern.x = pattern.get_value_generator('x')+\
numbergen.UniformRandom(lbound=-p.disparity_bound,
ubound=p.disparity_bound,
seed=master_seed+45+pattern_number,
name="DisparityCoordinator"+str(pattern_number))
else:
self.warning('Skipping region %s; Disparity is defined only for Left and Right retinas.' % pattern)
return new_pattern
def __call__(self, pattern, pattern_label, pattern_number, master_seed,
**params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
new_pattern = copy.copy(pattern)
new_pattern.orientation = pattern.get_value_generator('orientation')+\
numbergen.UniformRandom(lbound=-p.orientation_bound,
ubound=p.orientation_bound,
seed=master_seed+21+(0 if p.align_orientations else pattern_number),
name=("OrientationCoordinator"
+ ('' if p.align_orientations else str(pattern_number)))
)
return new_pattern
def test_shared_numbergen(self):
"""
Instances of TestPO2 that don't have their own value for the
parameter share one UniformRandom object
"""
self.TestPO2.y = numbergen.UniformRandom(
) # now the Parameter instantiate should be true
self.assertEqual(
self.t7.get_value_generator('y') is
self.TestPO2().params()['y'].default, True)
self.assertEqual(
self.TestPO2().params()['y'].default.__class__.__name__,
'UniformRandom')
class RotateHue(ChannelTransform):
"""
Rotate the hue of an Image PatternGenerator.
Requires a three-channel (e.g. RGB) or a 4-channel (e.g. RGBA)
color image. Also allows the saturation of the image to be
scaled.
Requires the color space of the image to be declared using the
colorspaces.color_conversion object, and uses the analysis color
space from that object to do the rotation.
"""
saturation = param.Number(default=1.0,
doc="""
Scale the saturation by the specified value.""")
rotation = param.Number(default=numbergen.UniformRandom(name='hue_jitter',
lbound=0,
ubound=1,
seed=1048921),
softbounds=(0.0, 1.0),
doc="""
Amount by which to rotate the hue. The default setting
chooses a random value of hue rotation between zero and 100%.
If set to 0, no rotation will be performed.""")
def __call__(self, channel_data):
assert (len(channel_data) == 3 or len(channel_data) == 4)
from .colorspaces import color_conversion as cc
channs_in = np.dstack(channel_data[0:3])
channs_out = cc.image2working(channs_in)
analysis_space = cc.working2analysis(channs_out)
if self.rotation != 0:
cc.jitter_hue(analysis_space, self.rotation)
cc.multiply_sat(analysis_space, self.saturation)
channs_out = cc.analysis2working(analysis_space)
# Takes only the first three channels (e.g. RGB)
channel_data[0:3] = np.dsplit(channs_out, 3)
for a in channel_data:
a.shape = a.shape[0:2]
return channel_data
def test_bug__dynamic_param_advanced_by_repr(self):
"""Check for bug where repr of a PatternGenerator causes a DynamicNumber to change."""
# CEB: can probably remove this test now we have time-controlled dynamic parameters
p = PatternGenerator(
x=numbergen.UniformRandom(lbound=-1, ubound=1, seed=1))
with param.Dynamic.time_fn as t:
t(0)
x0 = p.x
t(1)
x1 = p.x
self.assertNotEqual(
x0, x1) # check we have setup something that actually changes
x2 = p.inspect_value('x')
repr(p)
x3 = p.inspect_value('x')
self.assertEqual(
x2, x3) # value of x should not have been changed by repr(p)
class TestPO1(param.Parameterized):
x = param.Dynamic(default=numbergen.UniformRandom(lbound=-1,
ubound=1,
seed=1),
doc="nothing")
y = param.Dynamic(default=1)
lgn_off_to_V1 = FastConnetcionFieldProjection("LGNOffToV1",lgn_off,V1,0.5,0.001,0.27083,imagen.random.GaussianCloud(gaussian_size=2*0.27083))
center_lat = imagen.Gaussian(size=0.05,aspect_ratio=1.0,output_fns=[DivisiveNormalizeL1()],xdensity=V1.density+1,ydensity=V1.density+1,bounds = BoundingBox(radius=V1.size/2.0))()[14:-14,14:-14]
surround_lat = imagen.Gaussian(size=0.15,aspect_ratio=1.0,output_fns=[DivisiveNormalizeL1()],xdensity=V1.density+1,ydensity=V1.density+1,bounds = BoundingBox(radius=V1.size/2.0))()[14:-14,14:-14]
center_lat = center_lat / numpy.sum(center_lat)
surround_lat = surround_lat / numpy.sum(surround_lat)
V1_lat_exc = ConvolutionalProjection("LateralExc",V1,V1,0.5*float(sys.argv[1]),0.001,center_lat)
V1_lat_inh = ConvolutionalProjection("LateralInh",V1,V1,-0.5*float(sys.argv[1])*float(sys.argv[2]),0.001,surround_lat)
#V1_lat_exc = FastConnetcionFieldProjection("LateralExc",V1,V1,0.5*float(sys.argv[1]),0.001,0.104,imagen.Gaussian(aspect_ratio=1.0, size=0.05))
#V1_lat_inh = FastConnetcionFieldProjection("LateralInh",V1,V1,-0.5*float(sys.argv[1])*float(sys.argv[2]),0.001,0.22917,imagen.Gaussian(aspect_ratio=1.0, size=0.15))
#Model initialization and execution
lissom = Model([retina,lgn_on,lgn_off,V1],0.001)
g1 = imagen.Gaussian(xdensity=retina.unit_diameter,ydensity=retina.unit_diameter,x=numbergen.UniformRandom(lbound=-0.3,ubound=0.3,seed=342),
y=numbergen.UniformRandom(lbound=-0.3,ubound=0.3,seed=343),
orientation=numbergen.UniformRandom(lbound=-numpy.pi,ubound=numpy.pi,seed=333),
size=0.7*0.048388, aspect_ratio=1.2*4.66667, scale=1.0)
g2 = imagen.Gaussian(xdensity=retina.unit_diameter,ydensity=retina.unit_diameter,x=numbergen.UniformRandom(lbound=-0.3,ubound=0.3,seed=312),
y=numbergen.UniformRandom(lbound=-0.3,ubound=0.3,seed=313),
orientation=numbergen.UniformRandom(lbound=-numpy.pi,ubound=numpy.pi,seed=322),
size=0.7*0.048388, aspect_ratio=1.2*4.66667, scale=1.0)
#pylab.figure();plot_projection(lgn_on_to_V1,filename="onProjection.png");pylab.show()
run_for = 10000
t = time.time()
class DynamicClass(param.Parameterized):
c = param.Number(default=numbergen.UniformRandom(name='test1'))
d = param.Number(default=numbergen.UniformRandom(name='test2'))
e = param.Number(default=numbergen.UniformRandom(name='test1'))
def setUp(self):
self.g1 = Gaussian(x=numbergen.UniformRandom())
self.g2 = Gaussian(x=numbergen.UniformRandom())
self.s = Selector(generators=[self.g1, self.g2])
self.s.set_dynamic_time_fn(None, 'generators')
class TestPO1(param.Parameterized):
x = param.Number(default=numbergen.UniformRandom(lbound=-1,ubound=1,seed=1),bounds=(-1,1))
y = param.Number(default=1,bounds=(-1,1))
def test_dynamic_value_setting(self):
self.t6.y = numbergen.UniformRandom()
t8 = self.TestPO2()
self.TestPO2.y = 10
# t6 got a dynamic value, but shouldn't have changed Parameter's instantiate
self.assertEqual(t8.y, 10)
class TestPO2(param.Parameterized):
x = param.Dynamic(
default=numbergen.UniformRandom(lbound=-1, ubound=1, seed=30))
y = param.Dynamic(default=1.0)
def setUp(self):
super(TestDynamicSharedNumbergen, self).setUp()
self.shared = numbergen.UniformRandom(lbound=-1, ubound=1, seed=20)
def test_dynamic_value_change_enabled(self):
" time_fn set on the UniformRandom() when t13.y was set"
t14 = self.TestPO1()
t14.y = numbergen.UniformRandom()
self.assertEqual(t14.y, t14.y)
def test_dynamic_value_change_disabled(self):
" time_fn set on the UniformRandom() when t13.y was set"
t13 = self.TestPO1()
t13.set_dynamic_time_fn(None)
t13.y = numbergen.UniformRandom()
self.assertNotEqual(t13.y, t13.y)
def test_setting_y_param_numbergen(self):
self.TestPO2.y = numbergen.UniformRandom(
) # now the Parameter instantiate should be true
t9 = self.TestPO2()
self.assertEqual('_y_param_value' in t9.__dict__, True)
class TestPO3(param.Parameterized):
x = param.Dynamic(default=numbergen.UniformRandom(
name='xgen', time_dependent=True))
