def testRect2dRouting4():
sboard = mh.Rectangular2dSwitchboard(in_channels_xy=4,
in_channel_dim=1,
field_channels_xy=(3, 2),
field_spacing_xy=(1, 2))
assert (sboard.connections == numx.array([
0, 1, 2, 4, 5, 6, 1, 2, 3, 5, 6, 7, 8, 9, 10, 12, 13, 14, 9, 10, 11,
13, 14, 15
])).all()
def test_SFA_net(noisenode):
sfa_node = mdp.nodes.SFANode(input_dim=20 * 20, output_dim=10, dtype='f')
switchboard = mh.Rectangular2dSwitchboard(in_channels_xy=100,
field_channels_xy=20,
field_spacing_xy=10)
flownode = mh.FlowNode(mdp.Flow([noisenode, sfa_node]))
sfa_layer = mh.CloneLayer(flownode, switchboard.output_channels)
flow = mdp.Flow([switchboard, sfa_layer])
train_gen = numx.cast['f'](numx_rand.random((3, 10, 100 * 100)))
flow.train([None, train_gen])
def test_Rect2d_exception_3():
bad_args = dict(
in_channels_xy=(12, 8),
# 9 is the problematic value:
field_channels_xy=(4, 9),
field_spacing_xy=2,
in_channel_dim=3,
ignore_cover=True)
with py.test.raises(mh.Rectangular2dSwitchboardException):
mh.Rectangular2dSwitchboard(**bad_args)
def testRect2dRouting2():
sboard = mh.Rectangular2dSwitchboard(in_channels_xy=(2, 4),
in_channel_dim=1,
field_channels_xy=(1, 2),
field_spacing_xy=(1, 2))
assert numx.all(sboard.connections == numx.array([0, 2, 1, 3, 4, 6, 5, 7]))
x = numx.array(
[range(0, sboard.input_dim),
range(101, 101 + sboard.input_dim)])
sboard.execute(x)
# test generated switchboard
channel_sboard = sboard.get_out_channel_node(0)
channel_sboard.execute(x)
def testHiNetHTML(noisenode):
# create some flow for testing
sfa_node = mdp.nodes.SFANode(input_dim=20 * 20, output_dim=10)
switchboard = mh.Rectangular2dSwitchboard(in_channels_xy=100,
field_channels_xy=20,
field_spacing_xy=10)
flownode = mh.FlowNode(mdp.Flow([noisenode, sfa_node]))
sfa_layer = mh.CloneLayer(flownode, switchboard.output_channels)
flow = mdp.Flow([switchboard, sfa_layer])
# create dummy file to write the HTML representation
html_file = io.StringIO()
hinet_html = mdp.hinet.HiNetHTMLVisitor(html_file)
hinet_html.convert_flow(flow)
html_file.close()
def test_hinet_simple_net():
switchboard = mh.Rectangular2dSwitchboard(in_channels_xy=(12, 8),
field_channels_xy=4,
field_spacing_xy=2,
in_channel_dim=3)
node = mdp.nodes.PCANode(input_dim=4 * 4 * 3, output_dim=5)
flownode = mh.FlowNode(mdp.Flow([
node,
]))
layer = mh.CloneLayer(flownode, switchboard.output_channels)
flow = mdp.Flow([switchboard, layer])
x = numx_rand.random([5, switchboard.input_dim])
flow.train(x)
def testRect2dRouting1():
sboard = mh.Rectangular2dSwitchboard(in_channels_xy=(3, 2),
in_channel_dim=2,
field_channels_xy=(2, 1),
field_spacing_xy=1)
assert numx.all(sboard.connections == numx.array(
[0, 1, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 10, 11]))
x = numx.array([
list(range(0, sboard.input_dim)),
list(range(101, 101 + sboard.input_dim))
])
sboard.execute(x)
# test generated switchboard
channel_sboard = sboard.get_out_channel_node(0)
channel_sboard.execute(x)
def testRect2d_get_out_channel_node():
sboard = mh.Rectangular2dSwitchboard(in_channels_xy=(5, 4),
in_channel_dim=2,
field_channels_xy=(3, 2),
field_spacing_xy=(1, 2))
x = numx.array(
[range(0, sboard.input_dim),
range(101, 101 + sboard.input_dim)])
y = sboard.execute(x)
# routing layer
nodes = [
sboard.get_out_channel_node(index)
for index in xrange(sboard.output_channels)
]
layer = mh.SameInputLayer(nodes)
layer_y = layer.execute(x)
assert (y == layer_y).all()
def test_rand_rect_sb_equivalence():
sboard = mh.RandomChannelSwitchboard(in_channels_xy=(3, 3),
field_channels_xy=(2, 2),
in_channel_dim=1,
out_channels=5)
rect_board = mh.Rectangular2dSwitchboard(in_channels_xy=(3, 3),
field_channels_xy=(2, 2),
in_channel_dim=1,
field_spacing_xy=1)
assert numx.all(sboard._lut_conn.ravel() == rect_board.connections)
in_trans = CoordinateTranslator(*rect_board.out_channels_xy)
for i in xrange(sboard.out_channel_dim):
x, y = in_trans.index_to_array(i)
assert numx.all(
rect_board.get_out_channel_input(i) == sboard._lut_conn[x, y])
def test_parallelnet(self):
"""Test a simple parallel net with big data.
Includes ParallelFlowNode, ParallelCloneLayer, ParallelSFANode
and training via a ParallelFlow.
"""
noisenode = mdp.nodes.NormalNoiseNode(input_dim=20 * 20,
noise_args=(0, 0.0001))
sfa_node = mdp.nodes.SFANode(input_dim=20 * 20, output_dim=10)
switchboard = hinet.Rectangular2dSwitchboard(in_channels_xy=100,
field_channels_xy=20,
field_spacing_xy=10)
flownode = mdp.hinet.FlowNode(mdp.Flow([noisenode, sfa_node]))
sfa_layer = mdp.hinet.CloneLayer(flownode, switchboard.output_channels)
flow = parallel.ParallelFlow([switchboard, sfa_layer])
data_iterables = [
None, [n.random.random((10, 100 * 100)) for _ in xrange(3)]
]
scheduler = parallel.Scheduler()
flow.train(data_iterables, scheduler=scheduler)
def testRect2dRouting3():
sboard = mh.Rectangular2dSwitchboard(in_channels_xy=(2, 4),
in_channel_dim=1,
field_channels_xy=2,
field_spacing_xy=(1, 2))
assert (sboard.connections == numx.array([0, 1, 2, 3, 4, 5, 6, 7])).all()
