def test_upscale_layer_exceptions(self):
with self.assertRaises(LayerConnectionError):
# Input shape should be 4 dimensional
layers.join(layers.Input(10), layers.Upscale((2, 2)))
invalid_scales = [-1, (2, 0), (-4, 1), (3, 3, 3)]
for invalid_scale in invalid_scales:
with self.assertRaises(ValueError):
layers.Upscale(invalid_scale)
def test_upscale_layer_exceptions(self):
upscale_layer = layers.Upscale((2, 2))
with self.assertRaises(LayerConnectionError):
# Input shape should have 3 feature dimensions
# (and +1 for the batch)
layers.Input(10) > upscale_layer
invalid_scales = [-1, (2, 0), (-4, 1), (3, 3, 3)]
for invalid_scale in invalid_scales:
with self.assertRaises(ValueError):
layers.Upscale(invalid_scale)
def test_upscale_layer(self):
input_value = np.array([
[1, 2, 3, 4],
[5, 6, 7, 8],
]).reshape((1, 1, 2, 4))
expected_output = np.array([
[1, 1, 2, 2, 3, 3, 4, 4],
[1, 1, 2, 2, 3, 3, 4, 4],
[1, 1, 2, 2, 3, 3, 4, 4],
[5, 5, 6, 6, 7, 7, 8, 8],
[5, 5, 6, 6, 7, 7, 8, 8],
[5, 5, 6, 6, 7, 7, 8, 8],
]).reshape((1, 1, 6, 8))
upscale_layer = layers.Upscale((3, 2))
self.assertEqual(upscale_layer.output_shape, None)
layers.Input((1, 2, 4)) > upscale_layer
x = T.tensor4('x')
actual_output = upscale_layer.output(x)
actual_output = actual_output.eval({x: asfloat(input_value)})
np.testing.assert_array_almost_equal(
asfloat(expected_output),
actual_output
)
def test_upscale_late_shape_init(self):
network = layers.join(
layers.Upscale((2, 2)),
layers.Softmax(),
)
self.assertShapesEqual(network.output_shape, (None, None, None, None))
network = layers.join(layers.Input((10, 10, 5)), network)
self.assertShapesEqual(network.output_shape, (None, 20, 20, 5))
def test_upscale_layer_shape(self):
Case = namedtuple("Case", "scale expected_shape")
testcases = (
Case(scale=(2, 2), expected_shape=(1, 28, 28)),
Case(scale=(2, 1), expected_shape=(1, 28, 14)),
Case(scale=(1, 2), expected_shape=(1, 14, 28)),
Case(scale=(1, 1), expected_shape=(1, 14, 14)),
Case(scale=(1, 10), expected_shape=(1, 14, 140)),
)
for testcase in testcases:
upscale_layer = layers.Upscale(testcase.scale)
connection = layers.Input((1, 14, 14)) > upscale_layer
self.assertEqual(upscale_layer.output_shape,
testcase.expected_shape,
msg="scale: {}".format(testcase.scale))
def test_upscale_layer_shape(self):
Case = namedtuple("Case", "scale expected_shape")
testcases = (
Case(scale=(2, 2), expected_shape=(None, 28, 28, 1)),
Case(scale=(2, 1), expected_shape=(None, 28, 14, 1)),
Case(scale=(1, 2), expected_shape=(None, 14, 28, 1)),
Case(scale=(1, 1), expected_shape=(None, 14, 14, 1)),
Case(scale=(1, 10), expected_shape=(None, 14, 140, 1)),
)
for testcase in testcases:
network = layers.join(
layers.Input((14, 14, 1)),
layers.Upscale(testcase.scale),
)
self.assertShapesEqual(network.output_shape,
testcase.expected_shape,
msg="scale: {}".format(testcase.scale))
def test_upscale_layer(self):
input_value = np.array([
[1, 2, 3, 4],
[5, 6, 7, 8],
]).reshape((1, 2, 4, 1))
expected_output = np.array([
[1, 1, 2, 2, 3, 3, 4, 4],
[1, 1, 2, 2, 3, 3, 4, 4],
[1, 1, 2, 2, 3, 3, 4, 4],
[5, 5, 6, 6, 7, 7, 8, 8],
[5, 5, 6, 6, 7, 7, 8, 8],
[5, 5, 6, 6, 7, 7, 8, 8],
]).reshape((1, 6, 8, 1))
upscale_layer = layers.Upscale((3, 2))
network = layers.join(layers.Input((2, 4, 1)), upscale_layer)
self.assertShapesEqual(network.output_shape, (None, 6, 8, 1))
actual_output = self.eval(network.output(asfloat(input_value)))
np.testing.assert_array_almost_equal(asfloat(expected_output),
actual_output)
conv_autoencoder = algorithms.Momentum(
[
layers.Input((1, 28, 28)),
layers.Convolution((16, 3, 3)) > layers.Relu(),
layers.Convolution((16, 3, 3)) > layers.Relu(),
layers.MaxPooling((2, 2)),
layers.Convolution((32, 3, 3)) > layers.Relu(),
layers.MaxPooling((2, 2)),
layers.Reshape(),
layers.Relu(128),
layers.Relu(16),
layers.Relu(128),
layers.Relu(800),
layers.Reshape((32, 5, 5)),
layers.Upscale((2, 2)),
layers.Convolution((16, 3, 3), border_mode='full') > layers.Relu(),
layers.Upscale((2, 2)),
layers.Convolution((16, 3, 3), border_mode='full') > layers.Relu(),
layers.Convolution((1, 3, 3), border_mode='full') > layers.Sigmoid(),
layers.Reshape(),
],
verbose=True,
step=0.1,
momentum=0.99,
shuffle_data=True,
batch_size=128,
error='rmse',
)
conv_autoencoder.architecture()
conv_autoencoder.train(x_train_4d, x_train, x_test_4d, x_test, epochs=100)
def test_global_pooling_repr(self):
self.assertEqual("Upscale((2, 3), name='upscale-1')",
str(layers.Upscale((2, 3))))
def test_upscale_layer_with_one_by_one_scale(self):
upscale_layer = layers.Upscale((1, 1))
x = np.ones((2, 3))
self.assertIs(x, upscale_layer.output(x))
