From ff0f78d114a7cb74bb961baddce1ba351b5a51fe Mon Sep 17 00:00:00 2001 From: hertschuh <1091026+hertschuh@users.noreply.github.com> Date: Thu, 18 May 2023 16:15:01 -0700 Subject: [PATCH] Add `kears_core.layers.ZeroPadding2D`. (#187) Minor tweaks to documentation and tests of Cropping and ZeroPadding3D layers. --- keras_core/layers/__init__.py | 1 + .../layers/reshaping/cropping1d_test.py | 10 +- keras_core/layers/reshaping/cropping2d.py | 2 +- .../layers/reshaping/cropping2d_test.py | 10 +- keras_core/layers/reshaping/cropping3d.py | 2 +- .../layers/reshaping/cropping3d_test.py | 10 +- keras_core/layers/reshaping/zero_padding2d.py | 118 ++++++++++++++++++ .../layers/reshaping/zero_padding2d_test.py | 76 +++++++++++ keras_core/layers/reshaping/zero_padding3d.py | 2 +- .../layers/reshaping/zero_padding3d_test.py | 10 +- 10 files changed, 218 insertions(+), 23 deletions(-) create mode 100644 keras_core/layers/reshaping/zero_padding2d.py create mode 100644 keras_core/layers/reshaping/zero_padding2d_test.py diff --git a/keras_core/layers/__init__.py b/keras_core/layers/__init__.py index e6c50ee40..259680d2b 100644 --- a/keras_core/layers/__init__.py +++ b/keras_core/layers/__init__.py @@ -105,6 +105,7 @@ from keras_core.layers.reshaping.repeat_vector import RepeatVector from keras_core.layers.reshaping.reshape import Reshape from keras_core.layers.reshaping.up_sampling1d import UpSampling1D from keras_core.layers.reshaping.up_sampling3d import UpSampling3D +from keras_core.layers.reshaping.zero_padding2d import ZeroPadding2D from keras_core.layers.reshaping.zero_padding3d import ZeroPadding3D from keras_core.layers.rnn.bidirectional import Bidirectional from keras_core.layers.rnn.conv_lstm1d import ConvLSTM1D diff --git a/keras_core/layers/reshaping/cropping1d_test.py b/keras_core/layers/reshaping/cropping1d_test.py index 56c0cd5fd..faa46e48b 100644 --- a/keras_core/layers/reshaping/cropping1d_test.py +++ b/keras_core/layers/reshaping/cropping1d_test.py @@ -7,7 +7,7 @@ from keras_core import operations as ops from keras_core import testing -class CroppingTest(testing.TestCase): +class Cropping1DTest(testing.TestCase): def test_cropping_1d(self): inputs = np.random.rand(3, 5, 7) @@ -51,10 +51,10 @@ class CroppingTest(testing.TestCase): not backend.DYNAMIC_SHAPES_OK, reason="Backend does not support dynamic shapes", ) - def test_cropping_1d_with_dynamic_batch_size(self): - input_layer = layers.Input(batch_shape=(None, 5, 7)) - permuted = layers.Cropping1D((1, 2))(input_layer) - self.assertEqual(permuted.shape, (None, 2, 7)) + def test_cropping_1d_with_dynamic_spatial_dim(self): + input_layer = layers.Input(batch_shape=(1, None, 7)) + cropped = layers.Cropping1D((1, 2))(input_layer) + self.assertEqual(cropped.shape, (1, None, 7)) def test_cropping_1d_errors_if_cropping_more_than_available(self): with self.assertRaises(ValueError): diff --git a/keras_core/layers/reshaping/cropping2d.py b/keras_core/layers/reshaping/cropping2d.py index 46181957f..d1fa0f77a 100644 --- a/keras_core/layers/reshaping/cropping2d.py +++ b/keras_core/layers/reshaping/cropping2d.py @@ -26,7 +26,7 @@ class Cropping2D(Layer): cropping values for height and width: `(symmetric_height_crop, symmetric_width_crop)`. - If tuple of 2 tuples of 2 ints: interpreted as - `((top_crop, bottom_crop), (left_crop, right_crop))` + `((top_crop, bottom_crop), (left_crop, right_crop))`. data_format: A string, one of `"channels_last"` (default) or `"channels_first"`. The ordering of the dimensions in the inputs. `"channels_last"` corresponds to inputs with shape diff --git a/keras_core/layers/reshaping/cropping2d_test.py b/keras_core/layers/reshaping/cropping2d_test.py index 587c62587..29431d769 100644 --- a/keras_core/layers/reshaping/cropping2d_test.py +++ b/keras_core/layers/reshaping/cropping2d_test.py @@ -8,7 +8,7 @@ from keras_core import operations as ops from keras_core import testing -class CroppingTest(testing.TestCase, parameterized.TestCase): +class Cropping2DTest(testing.TestCase, parameterized.TestCase): @parameterized.product( ( # different cropping values @@ -66,10 +66,10 @@ class CroppingTest(testing.TestCase, parameterized.TestCase): not backend.DYNAMIC_SHAPES_OK, reason="Backend does not support dynamic shapes", ) - def test_cropping_2d_with_dynamic_batch_size(self): - input_layer = layers.Input(batch_shape=(None, 7, 9, 5)) - permuted = layers.Cropping2D(((1, 2), (3, 4)))(input_layer) - self.assertEqual(permuted.shape, (None, 4, 2, 5)) + def test_cropping_2d_with_dynamic_spatial_dim(self): + input_layer = layers.Input(batch_shape=(1, 7, None, 5)) + cropped = layers.Cropping2D(((1, 2), (3, 4)))(input_layer) + self.assertEqual(cropped.shape, (1, 4, None, 5)) @parameterized.product( ( diff --git a/keras_core/layers/reshaping/cropping3d.py b/keras_core/layers/reshaping/cropping3d.py index ff5272356..542f55886 100644 --- a/keras_core/layers/reshaping/cropping3d.py +++ b/keras_core/layers/reshaping/cropping3d.py @@ -25,7 +25,7 @@ class Cropping3D(Layer): `(symmetric_dim1_crop, symmetric_dim2_crop, symmetric_dim3_crop)`. - If tuple of 3 tuples of 2 ints: interpreted as `((left_dim1_crop, right_dim1_crop), (left_dim2_crop, - right_dim2_crop), (left_dim3_crop, right_dim3_crop))` + right_dim2_crop), (left_dim3_crop, right_dim3_crop))`. data_format: A string, one of `"channels_last"` (default) or `"channels_first"`. The ordering of the dimensions in the inputs. `"channels_last"` corresponds to inputs with shape diff --git a/keras_core/layers/reshaping/cropping3d_test.py b/keras_core/layers/reshaping/cropping3d_test.py index a7a1d534e..67c780706 100644 --- a/keras_core/layers/reshaping/cropping3d_test.py +++ b/keras_core/layers/reshaping/cropping3d_test.py @@ -8,7 +8,7 @@ from keras_core import operations as ops from keras_core import testing -class CroppingTest(testing.TestCase, parameterized.TestCase): +class Cropping3DTest(testing.TestCase, parameterized.TestCase): @parameterized.product( ( {"dim1_cropping": (1, 2), "dim1_expected": (1, 5)}, # both @@ -125,10 +125,10 @@ class CroppingTest(testing.TestCase, parameterized.TestCase): not backend.DYNAMIC_SHAPES_OK, reason="Backend does not support dynamic shapes", ) - def test_cropping_3d_with_dynamic_batch_size(self): - input_layer = layers.Input(batch_shape=(None, 7, 9, 13, 5)) - permuted = layers.Cropping3D(((1, 2), (3, 4), (5, 6)))(input_layer) - self.assertEqual(permuted.shape, (None, 4, 2, 2, 5)) + def test_cropping_3d_with_dynamic_spatial_dim(self): + input_layer = layers.Input(batch_shape=(1, 7, None, 13, 5)) + cropped = layers.Cropping3D(((1, 2), (3, 4), (5, 6)))(input_layer) + self.assertEqual(cropped.shape, (1, 4, None, 2, 5)) @parameterized.product( ( diff --git a/keras_core/layers/reshaping/zero_padding2d.py b/keras_core/layers/reshaping/zero_padding2d.py new file mode 100644 index 000000000..53e8fd8b1 --- /dev/null +++ b/keras_core/layers/reshaping/zero_padding2d.py @@ -0,0 +1,118 @@ +from keras_core import backend +from keras_core import operations as ops +from keras_core.api_export import keras_core_export +from keras_core.layers.input_spec import InputSpec +from keras_core.layers.layer import Layer + + +@keras_core_export("keras_core.layers.ZeroPadding2D") +class ZeroPadding2D(Layer): + """Zero-padding layer for 2D input (e.g. picture). + + This layer can add rows and columns of zeros at the top, bottom, left and + right side of an image tensor. + + Examples: + + >>> input_shape = (1, 1, 2, 2) + >>> x = np.arange(np.prod(input_shape)).reshape(input_shape) + >>> x + [[[[0 1] + [2 3]]]] + >>> y = keras_core.layers.ZeroPadding2D(padding=1)(x) + >>> y + [[[[0 0] + [0 0] + [0 0] + [0 0]] + [[0 0] + [0 1] + [2 3] + [0 0]] + [[0 0] + [0 0] + [0 0] + [0 0]]]] + + Args: + padding: Int, or tuple of 2 ints, or tuple of 2 tuples of 2 ints. + - If int: the same symmetric padding is applied to height and width. + - If tuple of 2 ints: interpreted as two different symmetric padding + values for height and width: + `(symmetric_height_pad, symmetric_width_pad)`. + - If tuple of 2 tuples of 2 ints: interpreted as + `((top_pad, bottom_pad), (left_pad, right_pad))`. + data_format: A string, one of `"channels_last"` (default) or + `"channels_first"`. The ordering of the dimensions in the inputs. + `"channels_last"` corresponds to inputs with shape + `(batch_size, height, width, channels)` while `"channels_first"` + corresponds to inputs with shape + `(batch_size, channels, height, width)`. + When unspecified, uses `image_data_format` value found in your Keras + config file at `~/.keras/keras.json` (if exists). Defaults to + `"channels_last"`. + + Input shape: + 4D tensor with shape: + - If `data_format` is `"channels_last"`: + `(batch_size, height, width, channels)` + - If `data_format` is `"channels_first"`: + `(batch_size, channels, height, width)` + + Output shape: + 4D tensor with shape: + - If `data_format` is `"channels_last"`: + `(batch_size, padded_height, padded_width, channels)` + - If `data_format` is `"channels_first"`: + `(batch_size, channels, padded_height, padded_width)` + """ + + def __init__(self, padding=(1, 1), data_format=None, **kwargs): + super().__init__(**kwargs) + self.data_format = backend.standardize_data_format(data_format) + if isinstance(padding, int): + self.padding = ((padding, padding), (padding, padding)) + elif hasattr(padding, "__len__"): + if len(padding) != 2: + raise ValueError( + "`padding` should have two elements. " + f"Received: padding={padding}." + ) + height_padding = padding[0] + if isinstance(height_padding, int): + height_padding = (height_padding, height_padding) + width_padding = padding[1] + if isinstance(width_padding, int): + width_padding = (width_padding, width_padding) + self.padding = (height_padding, width_padding) + else: + raise ValueError( + "`padding` should be either an int, a tuple of 2 ints " + "(symmetric_height_crop, symmetric_width_crop), " + "or a tuple of 2 tuples of 2 ints " + "((top_crop, bottom_crop), (left_crop, right_crop)). " + f"Received: padding={padding}." + ) + self.input_spec = InputSpec(ndim=4) + + def compute_output_shape(self, input_shape): + output_shape = list(input_shape) + spatial_dims_offset = 2 if self.data_format == "channels_first" else 1 + for index in range(0, 2): + if output_shape[index + spatial_dims_offset] is not None: + output_shape[index + spatial_dims_offset] += ( + self.padding[index][0] + self.padding[index][1] + ) + return tuple(output_shape) + + def call(self, inputs): + if self.data_format == "channels_first": + all_dims_padding = ((0, 0), (0, 0), *self.padding) + else: + all_dims_padding = ((0, 0), *self.padding, (0, 0)) + return ops.pad(inputs, all_dims_padding) + + def get_config(self): + config = {"padding": self.padding, "data_format": self.data_format} + base_config = super().get_config() + return {**base_config, **config} diff --git a/keras_core/layers/reshaping/zero_padding2d_test.py b/keras_core/layers/reshaping/zero_padding2d_test.py new file mode 100644 index 000000000..a31893cf0 --- /dev/null +++ b/keras_core/layers/reshaping/zero_padding2d_test.py @@ -0,0 +1,76 @@ +import numpy as np +import pytest +from absl.testing import parameterized + +from keras_core import backend +from keras_core import layers +from keras_core import testing + + +class ZeroPadding2DTest(testing.TestCase, parameterized.TestCase): + @parameterized.named_parameters( + ("channels_first", "channels_first"), ("channels_last", "channels_last") + ) + def test_zero_padding_2d(self, data_format): + inputs = np.random.rand(1, 2, 3, 4) + outputs = layers.ZeroPadding2D( + padding=((1, 2), (3, 4)), data_format=data_format + )(inputs) + + if data_format == "channels_first": + for index in [0, -1, -2]: + self.assertAllClose(outputs[:, :, index, :], 0.0) + for index in [0, 1, 2, -1, -2, -3, -4]: + self.assertAllClose(outputs[:, :, :, index], 0.0) + self.assertAllClose(outputs[:, :, 1:-2, 3:-4], inputs) + else: + for index in [0, -1, -2]: + self.assertAllClose(outputs[:, index, :, :], 0.0) + for index in [0, 1, 2, -1, -2, -3, -4]: + self.assertAllClose(outputs[:, :, index, :], 0.0) + self.assertAllClose(outputs[:, 1:-2, 3:-4, :], inputs) + + @parameterized.product( + ( + {"padding": ((2, 2), (2, 2))}, # 2 tuples + {"padding": (2, 2)}, # 1 tuple + {"padding": 2}, # 1 int + ), + ( + {"data_format": "channels_first"}, + {"data_format": "channels_last"}, + ), + ) + def test_zero_padding_2d_with_same_padding(self, padding, data_format): + inputs = np.random.rand(1, 2, 3, 4) + outputs = layers.ZeroPadding2D( + padding=padding, data_format=data_format + )(inputs) + + if data_format == "channels_first": + for index in [0, 1, -1, -2]: + self.assertAllClose(outputs[:, :, index, :], 0.0) + self.assertAllClose(outputs[:, :, :, index], 0.0) + self.assertAllClose(outputs[:, :, 2:-2, 2:-2], inputs) + else: + for index in [0, 1, -1, -2]: + self.assertAllClose(outputs[:, index, :, :], 0.0) + self.assertAllClose(outputs[:, :, index, :], 0.0) + self.assertAllClose(outputs[:, 2:-2, 2:-2, :], inputs) + + @pytest.mark.skipif( + not backend.DYNAMIC_SHAPES_OK, + reason="Backend does not support dynamic shapes", + ) + def test_zero_padding_2d_with_dynamic_spatial_dim(self): + input_layer = layers.Input(batch_shape=(1, 2, None, 4)) + padded = layers.ZeroPadding2D(((1, 2), (3, 4)))(input_layer) + self.assertEqual(padded.shape, (1, 5, None, 4)) + + def test_zero_padding_2d_errors_if_padding_argument_invalid(self): + with self.assertRaises(ValueError): + layers.ZeroPadding2D(padding=(1,)) + with self.assertRaises(ValueError): + layers.ZeroPadding2D(padding=(1, 2, 3)) + with self.assertRaises(ValueError): + layers.ZeroPadding2D(padding="1") diff --git a/keras_core/layers/reshaping/zero_padding3d.py b/keras_core/layers/reshaping/zero_padding3d.py index d005a8bf6..021c381a8 100644 --- a/keras_core/layers/reshaping/zero_padding3d.py +++ b/keras_core/layers/reshaping/zero_padding3d.py @@ -26,7 +26,7 @@ class ZeroPadding3D(Layer): `(symmetric_dim1_pad, symmetric_dim2_pad, symmetric_dim3_pad)`. - If tuple of 3 tuples of 2 ints: interpreted as `((left_dim1_pad, right_dim1_pad), (left_dim2_pad, - right_dim2_pad), (left_dim3_pad, right_dim3_pad))` + right_dim2_pad), (left_dim3_pad, right_dim3_pad))`. data_format: A string, one of `"channels_last"` (default) or `"channels_first"`. The ordering of the dimensions in the inputs. `"channels_last"` corresponds to inputs with shape diff --git a/keras_core/layers/reshaping/zero_padding3d_test.py b/keras_core/layers/reshaping/zero_padding3d_test.py index 1c10d44a8..7b0833522 100644 --- a/keras_core/layers/reshaping/zero_padding3d_test.py +++ b/keras_core/layers/reshaping/zero_padding3d_test.py @@ -7,7 +7,7 @@ from keras_core import layers from keras_core import testing -class ZeroPaddingTest(testing.TestCase, parameterized.TestCase): +class ZeroPadding3DTest(testing.TestCase, parameterized.TestCase): @parameterized.named_parameters( ("channels_first", "channels_first"), ("channels_last", "channels_last") ) @@ -68,10 +68,10 @@ class ZeroPaddingTest(testing.TestCase, parameterized.TestCase): not backend.DYNAMIC_BATCH_SIZE_OK, reason="Backend does not support dynamic batch sizes", ) - def test_zero_padding_3d_with_dynamic_batch_size(self): - input_layer = layers.Input(batch_shape=(None, 2, 3, 4, 5)) - permuted = layers.ZeroPadding3D(((1, 2), (3, 4), (5, 6)))(input_layer) - self.assertEqual(permuted.shape, (None, 5, 10, 15, 5)) + def test_zero_padding_3d_with_dynamic_spatial_dim(self): + input_layer = layers.Input(batch_shape=(1, 2, None, 4, 5)) + padded = layers.ZeroPadding3D(((1, 2), (3, 4), (5, 6)))(input_layer) + self.assertEqual(padded.shape, (1, 5, None, 15, 5)) def test_zero_padding_3d_errors_if_padding_argument_invalid(self): with self.assertRaises(ValueError):