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
GeneratorSheet.print_level = param.parameterized.WARNING
# cf som parameters
CFSheet.nominal_density = 5
###########################################
# build simulation
param.parameterized.min_print_level = param.parameterized.WARNING
s = Simulation()
s.verbose("Creating simulation objects...")
s['retina'] = GeneratorSheet(input_generator=input_pattern)
s['V1'] = CFSheet()
s['V1'].print_level = param.parameterized.WARNING
s.connect('retina',
'V1',
delay=1,
connection_type=CFProjection,
learning_fn=CFPLF_Hebbian_opt())
s.print_level = param.parameterized.WARNING
self.assertTrue(
topo.sim['V1'].projections().get('retinaToV1', None) != None)
self.assertTrue(
topo.sim['V1'].projections().get('retinaToV1', None) != None)
s.run(10)
def SG(K,
X,
Y,
lscsm,
der,
bounds,
learning_rate=0.1,
num_steps=100,
batch_size=100):
num_pres, num_neurons = numpy.shape(X)
r = numbergen.UniformRandom(seed=513)
mins = numpy.array(zip(*bounds)[0])
maxs = numpy.array(zip(*bounds)[1])
for i in xrange(0, num_steps):
K = K - learning_rate * der(K[:])
K = numpy.array(K)
above_bounds = K > maxs
below_bounds = K < mins
if (numpy.sum(above_bounds) + numpy.sum(below_bounds)) > 0:
K[numpy.nonzero(above_bounds)] = maxs[numpy.nonzero(above_bounds)]
K[numpy.nonzero(below_bounds)] = mins[numpy.nonzero(below_bounds)]
index = int(r() * (num_pres - batch_size))
lscsm.X.value = X[index:index + batch_size, :]
lscsm.Y.value = Y[index:index + batch_size, :]
return K
def test_range(self):
lbound = 2.0
ubound = 5.0
gen = numbergen.UniformRandom(seed=_seed, lbound=lbound, ubound=ubound)
for _ in xrange(_iterations):
value = gen()
self.assertTrue(lbound <= value < ubound)
class Jitter(CoordinateMapperFn):
"""
Additively modifies calculated x,y coordinates, e.g. with random noise.
"""
scale = param.Parameter(default=0.0,doc="Amount of jitter.")
gen = param.Parameter(default=numbergen.UniformRandom(),doc=
"Number generator to use, typically a random distribution.")
def __call__(self,x,y):
return x+(self.gen()-0.5)*self.scale,y+(self.gen()-0.5)*self.scale
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
import topo
p=PatternGenerator(x=numbergen.UniformRandom(lbound=-1,ubound=1,seed=1))
x0 = p.x
topo.sim.run(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)
def phase_preference_scatter_plot(sheet_name, diameter=0.39):
r = numbergen.UniformRandom(seed=1023)
preference_map = topo.sim[sheet_name].sheet_views['PhasePreference']
offset_magnitude = 0.03
datax = []
datay = []
(v, bb) = preference_map.view()
for z in zeros(66):
x = (r() - 0.5) * 2 * diameter
y = (r() - 0.5) * 2 * diameter
rand = r()
xoff = sin(rand * 2 * pi) * offset_magnitude
yoff = cos(rand * 2 * pi) * offset_magnitude
xx = max(min(x + xoff, diameter), -diameter)
yy = max(min(y + yoff, diameter), -diameter)
x = max(min(x, diameter), -diameter)
y = max(min(y, diameter), -diameter)
[xc1, yc1] = topo.sim[sheet_name].sheet2matrixidx(xx, yy)
[xc2, yc2] = topo.sim[sheet_name].sheet2matrixidx(x, y)
if ((xc1 == xc2) & (yc1 == yc2)): continue
datax = datax + [v[xc1, yc1]]
datay = datay + [v[xc2, yc2]]
for i in range(0, len(datax)):
datax[i] = datax[i] * 360
datay[i] = datay[i] * 360
if (datay[i] > datax[i] + 180): datay[i] = datay[i] - 360
if ((datax[i] > 180) & (datay[i] > 180)):
datax[i] = datax[i] - 360
datay[i] = datay[i] - 360
if ((datax[i] > 180) & (datay[i] < (datax[i] - 180))):
datax[i] = datax[i] - 360
#datay[i] = datay[i] - 360
f = pylab.figure()
ax = f.add_subplot(111, aspect='equal')
pylab.plot(datax, datay, 'ro')
pylab.plot([0, 360], [-180, 180])
pylab.plot([-180, 180], [0, 360])
pylab.plot([-180, -180], [360, 360])
ax.axis([-180, 360, -180, 360])
pylab.xticks([-180, 0, 180, 360], [-180, 0, 180, 360])
pylab.yticks([-180, 0, 180, 360], [-180, 0, 180, 360])
pylab.grid()
pylab.savefig(
normalize_path(str(topo.sim.timestr()) + sheet_name + "_scatter.png"))
def test_test_pattern():
"""Check that test pattern window is working."""
tp = topo.guimain['Simulation']['Test Pattern']()
act = topo.guimain['Plots']['Activity']()
tp.gui_set_param('edit_sheet', 'GS')
## Test for state_push bug (simulation not run() before Present pressed)
assert len(topo.sim.eps_to_start
) > 0, "test must be run before simulation is run()"
from topo.pattern import Gaussian
from topo import numbergen
topo.sim['GS'].set_input_generator(Gaussian(x=numbergen.UniformRandom()))
tp.Present()
topo.sim.run(1)
act1 = copy.deepcopy(topo.sim['GS'].activity)
topo.sim.run(2)
assert_array_not_equal(topo.sim['GS'].activity, act1,
"GeneratorSheet no longer generating patterns")
##
tp.gui_set_param('pattern_generator', 'TwoRectangles')
from topo.pattern import TwoRectangles
assert isinstance(tp.pattern_generator,
TwoRectangles), "Pattern generator did not change."
preview = _get_named_plot('GS', tp.plotgroup.plots).view_dict.get(
'Strength', {})['Activity'].top.data
two_rectangles = array([[0., 1], [1., 0.]])
assert_array_equal(preview, two_rectangles,
"Incorrect pattern in preview plot.")
tp.Present()
gs_view = _get_named_plot('GS', act.plotgroup.plots).view_dict.get(
'Strength', {})['Activity']
assert gs_view.metadata.src_name == 'GS'
gs_plot_array = gs_view.top.data
assert_array_equal(gs_plot_array, two_rectangles,
"Incorrect pattern in activity plot after Present.")
tp.params_frame.gui_set_param('scale', 0.5)
preview = _get_named_plot('GS', tp.plotgroup.plots).view_dict.get(
'Strength', {})['Activity'].top.data
assert_array_equal(preview, 0.5 * two_rectangles,
"Changing pattern parameters did not update preview.")
### Defaults button
# first change several more parameters
initial_preview = tp.plotgroup.plots[0].view_dict.get(
'Strength', {})['Activity'].top.data
new_param_values = [ #('output_fns','Sigmoid'),
('scale', '2')
]
for name, value in new_param_values:
tp.params_frame.gui_set_param(name, value)
changed_preview = _get_named_plot('GS', tp.plotgroup.plots).view_dict.get(
'Strength', {})['Activity'].top.data
# and check the preview did change
try:
assert_array_equal(changed_preview, initial_preview)
except AssertionError:
pass
else:
raise AssertionError("Test pattern didn't change.")
# test that preview display is correct
tp.params_frame.Defaults()
preview = _get_named_plot('GS', tp.plotgroup.plots).view_dict.get(
'Strength', {})['Activity'].top.data
assert_array_equal(
preview, two_rectangles,
"Defaults button failed to revert params to default values.")
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')