def _testKerasLayer(self, layer_class):
def kernel_posterior_fn(dtype, shape, name, trainable, add_variable_fn):
"""Set trivially. The function is required to instantiate layer."""
del name, trainable, add_variable_fn # unused
# Deserialized Keras objects do not perform lexical scoping. Any modules
# that the function requires must be imported within the function.
import tensorflow.compat.v2 as tf # pylint: disable=g-import-not-at-top,redefined-outer-name,reimported
import tensorflow_probability as tfp # pylint: disable=g-import-not-at-top,redefined-outer-name,reimported
tfd = tfp.distributions # pylint: disable=redefined-outer-name
dist = tfd.Normal(loc=tf.zeros(shape, dtype), scale=tf.ones(shape, dtype))
batch_ndims = tf.size(dist.batch_shape_tensor())
return tfd.Independent(dist, reinterpreted_batch_ndims=batch_ndims)
kwargs = {'units': 3,
'kernel_posterior_fn': kernel_posterior_fn,
'kernel_prior_fn': None,
'bias_posterior_fn': None,
'bias_prior_fn': None}
with tf.keras.utils.CustomObjectScope({layer_class.__name__: layer_class}):
# TODO(scottzhu): reenable the test when the repo switch change reach
# the TF PIP package.
self.skipTest('Skip the test until the TF and Keras has a new PIP.')
with self.cached_session():
testing_utils.layer_test(
layer_class,
kwargs=kwargs,
input_shape=(3, 2))
testing_utils.layer_test(
layer_class,
kwargs=kwargs,
input_shape=(None, None, 2))
def test_basic_layernorm(self):
testing_utils.layer_test(keras.layers.LayerNormalization,
kwargs={
'gamma_regularizer':
keras.regularizers.l2(0.01),
'beta_regularizer':
keras.regularizers.l2(0.01)
},
input_shape=(3, 4, 2))
testing_utils.layer_test(keras.layers.LayerNormalization,
kwargs={
'gamma_initializer': 'ones',
'beta_initializer': 'ones',
},
input_shape=(3, 4, 2))
testing_utils.layer_test(keras.layers.LayerNormalization,
kwargs={
'scale': False,
'center': False
},
input_shape=(3, 3))
testing_utils.layer_test(keras.layers.LayerNormalization,
kwargs={'axis': (-3, -2, -1)},
input_shape=(2, 8, 8, 3))
testing_utils.layer_test(keras.layers.LayerNormalization,
input_shape=(1, 0, 10))
def test_basics(self):
testing_utils.layer_test(keras.layers.UnitNormalization,
kwargs={'axis': -1},
input_shape=(2, 3))
testing_utils.layer_test(keras.layers.UnitNormalization,
kwargs={'axis': (1, 2)},
input_shape=(1, 3, 3))
def test_locallyconnected_1d(self, data_format, padding, implementation):
with self.cached_session():
num_samples = 2
num_steps = 8
input_dim = 5
filter_length = 3
filters = 4
for strides in [1]:
if padding == 'same' and strides != 1:
continue
kwargs = {
'filters': filters,
'kernel_size': filter_length,
'padding': padding,
'strides': strides,
'data_format': data_format,
'implementation': implementation
}
if padding == 'same' and implementation == 1:
self.assertRaises(ValueError,
keras.layers.LocallyConnected1D,
**kwargs)
else:
testing_utils.layer_test(keras.layers.LocallyConnected1D,
kwargs=kwargs,
input_shape=(num_samples,
num_steps,
input_dim))
def test_lambda(self):
testing_utils.layer_test(
keras.layers.Lambda,
kwargs={'function': lambda x: x + 1},
input_shape=(3, 2))
testing_utils.layer_test(
keras.layers.Lambda,
kwargs={
'function': lambda x, a, b: x * a + b,
'arguments': {
'a': 0.6,
'b': 0.4
}
},
input_shape=(3, 2))
# test serialization with function
def f(x):
return x + 1
ld = keras.layers.Lambda(f)
config = ld.get_config()
ld = keras.layers.deserialize({'class_name': 'Lambda', 'config': config})
self.assertEqual(ld.function(3), 4)
# test with lambda
ld = keras.layers.Lambda(
lambda x: keras.backend.concatenate([tf.square(x), x]))
config = ld.get_config()
ld = keras.layers.Lambda.from_config(config)
self.assertAllEqual(self.evaluate(ld.function([3])), [9, 3])
def test_upsampling_2d_bilinear(self):
num_samples = 2
stack_size = 2
input_num_row = 11
input_num_col = 12
for data_format in ['channels_first', 'channels_last']:
if data_format == 'channels_first':
inputs = np.random.rand(num_samples, stack_size, input_num_row,
input_num_col)
else:
inputs = np.random.rand(num_samples, input_num_row, input_num_col,
stack_size)
testing_utils.layer_test(keras.layers.UpSampling2D,
kwargs={'size': (2, 2),
'data_format': data_format,
'interpolation': 'bilinear'},
input_shape=inputs.shape)
if not tf.executing_eagerly():
for length_row in [2]:
for length_col in [2, 3]:
layer = keras.layers.UpSampling2D(
size=(length_row, length_col),
data_format=data_format)
layer.build(inputs.shape)
outputs = layer(keras.backend.variable(inputs))
np_output = keras.backend.eval(outputs)
if data_format == 'channels_first':
self.assertEqual(np_output.shape[2], length_row * input_num_row)
self.assertEqual(np_output.shape[3], length_col * input_num_col)
else:
self.assertEqual(np_output.shape[1], length_row * input_num_row)
self.assertEqual(np_output.shape[2], length_col * input_num_col)
def test_conv2d_transpose_dilation(self):
testing_utils.layer_test(keras.layers.Conv2DTranspose,
kwargs={'filters': 2,
'kernel_size': 3,
'padding': 'same',
'data_format': 'channels_last',
'dilation_rate': (2, 2)},
input_shape=(2, 5, 6, 3))
input_data = np.arange(48).reshape((1, 4, 4, 3)).astype(np.float32)
# pylint: disable=too-many-function-args
expected_output = np.float32([
[192, 228, 192, 228],
[336, 372, 336, 372],
[192, 228, 192, 228],
[336, 372, 336, 372]
]).reshape((1, 4, 4, 1))
testing_utils.layer_test(keras.layers.Conv2DTranspose,
input_data=input_data,
kwargs={'filters': 1,
'kernel_size': 3,
'padding': 'same',
'data_format': 'channels_last',
'dilation_rate': (2, 2),
'kernel_initializer': 'ones'},
expected_output=expected_output)
def test_basic_batchnorm_v2(self):
testing_utils.layer_test(batch_normalization.BatchNormalization,
kwargs={'fused': True},
input_shape=(3, 3, 3, 3))
testing_utils.layer_test(batch_normalization.BatchNormalization,
kwargs={'fused': None},
input_shape=(3, 3, 3))
def test_locallyconnected_2d(self, data_format, padding, implementation):
with self.cached_session():
num_samples = 8
filters = 3
stack_size = 4
num_row = 6
num_col = 10
for strides in [(1, 1), (2, 2)]:
if padding == 'same' and strides != (1, 1):
continue
kwargs = {
'filters': filters,
'kernel_size': 3,
'padding': padding,
'kernel_regularizer': 'l2',
'bias_regularizer': 'l2',
'strides': strides,
'data_format': data_format,
'implementation': implementation
}
if padding == 'same' and implementation == 1:
self.assertRaises(ValueError,
keras.layers.LocallyConnected2D,
**kwargs)
else:
testing_utils.layer_test(keras.layers.LocallyConnected2D,
kwargs=kwargs,
input_shape=(num_samples, num_row,
num_col, stack_size))
def test_relu_with_invalid_max_value(self):
with self.assertRaisesRegex(
ValueError, 'max_value of a ReLU layer cannot be a negative '
'value. Received: -10'):
testing_utils.layer_test(keras.layers.ReLU,
kwargs={'max_value': -10},
input_shape=(2, 3, 4),
supports_masking=True)
def test_leaky_elu_with_invalid_alpha(self):
# Test case for GitHub issue 46993.
with self.assertRaisesRegex(ValueError,
'alpha of ELU layer cannot be None'):
testing_utils.layer_test(keras.layers.ELU,
kwargs={'alpha': None},
input_shape=(2, 3, 4),
supports_masking=True)
def test_conv_lstm(self, data_format, return_sequences):
num_height = 3
num_width = 3
num_depth = 3
filters = 3
num_samples = 1
input_channel = 2
input_height = 5
input_width = 5
input_depth = 5
sequence_len = 2
if data_format == 'channels_first':
inputs = np.random.rand(num_samples, sequence_len, input_channel,
input_height, input_width, input_depth)
else:
inputs = np.random.rand(num_samples, sequence_len, input_height,
input_width, input_depth, input_channel)
# test for return state:
x = keras.Input(batch_shape=inputs.shape)
kwargs = {
'data_format': data_format,
'return_sequences': return_sequences,
'return_state': True,
'stateful': True,
'filters': filters,
'kernel_size': (num_height, num_width, num_depth),
'padding': 'same'
}
layer = keras.layers.ConvLSTM3D(**kwargs)
layer.build(inputs.shape)
outputs = layer(x)
_, states = outputs[0], outputs[1:]
self.assertEqual(len(states), 2)
model = keras.models.Model(x, states[0])
state = model.predict(inputs)
self.assertAllClose(keras.backend.eval(layer.states[0]),
state,
atol=1e-4)
# test for output shape:
testing_utils.layer_test(keras.layers.ConvLSTM3D,
kwargs={
'data_format':
data_format,
'return_sequences':
return_sequences,
'filters':
filters,
'kernel_size':
(num_height, num_width, num_depth),
'padding':
'valid'
},
input_shape=inputs.shape)
def test_leaky_relu_with_invalid_alpha(self):
# Test case for GitHub issue 46993.
with self.assertRaisesRegex(
ValueError, 'The alpha value of a Leaky ReLU layer '
'cannot be None, needs a float. Got None'):
testing_utils.layer_test(keras.layers.LeakyReLU,
kwargs={'alpha': None},
input_shape=(2, 3, 4),
supports_masking=True)
def test_dropout(self):
testing_utils.layer_test(
keras.layers.Dropout, kwargs={'rate': 0.5}, input_shape=(3, 2))
testing_utils.layer_test(
keras.layers.Dropout,
kwargs={'rate': 0.5,
'noise_shape': [3, 1]},
input_shape=(3, 2))
def test_cudnn_rnn_return_sequence(self, layer_class, return_sequences):
input_size = 10
timesteps = 6
units = 2
num_samples = 32
testing_utils.layer_test(
layer_class,
kwargs={'units': units,
'return_sequences': return_sequences},
input_shape=(num_samples, timesteps, input_size))
def test_activation(self):
# with string argument
testing_utils.layer_test(keras.layers.Activation,
kwargs={'activation': 'relu'},
input_shape=(3, 2))
# with function argument
testing_utils.layer_test(keras.layers.Activation,
kwargs={'activation': keras.backend.relu},
input_shape=(3, 2))
def test_maxpooling_2d(self):
pool_size = (3, 3)
for strides in [(1, 1), (2, 2)]:
testing_utils.layer_test(keras.layers.MaxPooling2D,
kwargs={
'strides': strides,
'padding': 'valid',
'pool_size': pool_size
},
input_shape=(3, 5, 6, 4))
def _run_test(self, kwargs):
num_samples = 2
stack_size = 3
length = 7
with self.cached_session():
testing_utils.layer_test(keras.layers.SeparableConv1D,
kwargs=kwargs,
input_shape=(num_samples, length,
stack_size))
def test_spatial_dropout_3d(self):
testing_utils.layer_test(
keras.layers.SpatialDropout3D,
kwargs={'rate': 0.5},
input_shape=(2, 3, 4, 4, 5))
testing_utils.layer_test(
keras.layers.SpatialDropout3D,
kwargs={'rate': 0.5, 'data_format': 'channels_first'},
input_shape=(2, 3, 4, 4, 5))
def test_cudnn_rnn_go_backward(self, layer_class, go_backwards):
input_size = 10
timesteps = 6
units = 2
num_samples = 32
testing_utils.layer_test(
layer_class,
kwargs={'units': units,
'go_backwards': go_backwards},
input_shape=(num_samples, timesteps, input_size))
def test_implementation_mode_LSTM(self, implementation_mode):
num_samples = 2
timesteps = 3
embedding_dim = 4
units = 2
testing_utils.layer_test(
keras.layers.LSTM,
kwargs={'units': units,
'implementation': implementation_mode},
input_shape=(num_samples, timesteps, embedding_dim))
def test_return_sequences_LSTM(self):
num_samples = 2
timesteps = 3
embedding_dim = 4
units = 2
testing_utils.layer_test(
keras.layers.LSTM,
kwargs={'units': units,
'return_sequences': True},
input_shape=(num_samples, timesteps, embedding_dim))
def test_upsampling_3d(self):
num_samples = 2
stack_size = 2
input_len_dim1 = 10
input_len_dim2 = 11
input_len_dim3 = 12
for data_format in ['channels_first', 'channels_last']:
if data_format == 'channels_first':
inputs = np.random.rand(num_samples, stack_size, input_len_dim1,
input_len_dim2, input_len_dim3)
else:
inputs = np.random.rand(num_samples, input_len_dim1, input_len_dim2,
input_len_dim3, stack_size)
# basic test
with self.cached_session(use_gpu=True):
testing_utils.layer_test(
keras.layers.UpSampling3D,
kwargs={'size': (2, 2, 2),
'data_format': data_format},
input_shape=inputs.shape)
for length_dim1 in [2, 3]:
for length_dim2 in [2]:
for length_dim3 in [3]:
layer = keras.layers.UpSampling3D(
size=(length_dim1, length_dim2, length_dim3),
data_format=data_format)
layer.build(inputs.shape)
output = layer(keras.backend.variable(inputs))
if tf.executing_eagerly():
np_output = output.numpy()
else:
np_output = keras.backend.eval(output)
if data_format == 'channels_first':
assert np_output.shape[2] == length_dim1 * input_len_dim1
assert np_output.shape[3] == length_dim2 * input_len_dim2
assert np_output.shape[4] == length_dim3 * input_len_dim3
else: # tf
assert np_output.shape[1] == length_dim1 * input_len_dim1
assert np_output.shape[2] == length_dim2 * input_len_dim2
assert np_output.shape[3] == length_dim3 * input_len_dim3
# compare with numpy
if data_format == 'channels_first':
expected_out = np.repeat(inputs, length_dim1, axis=2)
expected_out = np.repeat(expected_out, length_dim2, axis=3)
expected_out = np.repeat(expected_out, length_dim3, axis=4)
else: # tf
expected_out = np.repeat(inputs, length_dim1, axis=1)
expected_out = np.repeat(expected_out, length_dim2, axis=2)
expected_out = np.repeat(expected_out, length_dim3, axis=3)
np.testing.assert_allclose(np_output, expected_out)
def _run_test(self, kwargs, expected_output_shape=None):
num_samples = 2
stack_size = 3
num_row = 7
with self.cached_session():
testing_utils.layer_test(
keras.layers.DepthwiseConv1D,
kwargs=kwargs,
input_shape=(num_samples, num_row, stack_size),
expected_output_shape=expected_output_shape)
def _run_test(self, kwargs, expected_output_shape):
num_samples = 2
stack_size = 3
num_col = 6
with testing_utils.use_gpu():
testing_utils.layer_test(
keras.layers.Conv1DTranspose,
kwargs=kwargs,
input_shape=(num_samples, num_col, stack_size),
expected_output_shape=expected_output_shape)
def _run_test(self, kwargs, expected_output_shape):
num_samples = 2
stack_size = 3
length = 7
with self.cached_session(use_gpu=True):
testing_utils.layer_test(
keras.layers.Conv1D,
kwargs=kwargs,
input_shape=(num_samples, length, stack_size),
expected_output_shape=expected_output_shape)
def test_dropout_LSTM(self):
num_samples = 2
timesteps = 3
embedding_dim = 4
units = 2
testing_utils.layer_test(
keras.layers.LSTM,
kwargs={'units': units,
'dropout': 0.1,
'recurrent_dropout': 0.1},
input_shape=(num_samples, timesteps, embedding_dim))
def test_flatten_scalar_channels(self):
testing_utils.layer_test(keras.layers.Flatten, kwargs={}, input_shape=(3,))
# Test channels_first
inputs = np.random.random((10,)).astype('float32')
outputs = testing_utils.layer_test(
keras.layers.Flatten,
kwargs={'data_format': 'channels_first'},
input_data=inputs)
target_outputs = np.expand_dims(inputs, -1)
self.assertAllClose(outputs, target_outputs)
def _run_test(self, kwargs):
num_samples = 2
stack_size = 3
num_row = 7
num_col = 6
with self.cached_session():
testing_utils.layer_test(
keras.layers.Conv2DTranspose,
kwargs=kwargs,
input_shape=(num_samples, num_row, num_col, stack_size))
def _run_test(self, kwargs):
num_samples = 2
stack_size = 3
num_row = 7
num_col = 6
with self.cached_session(use_gpu=True):
testing_utils.layer_test(keras.layers.SeparableConv2D,
kwargs=kwargs,
input_shape=(num_samples, num_row,
num_col, stack_size))
