def test_dilated_max_pool_3d(self): custom_objects = {'DilatedMaxPool3D': layers.DilatedMaxPool3D} pool_size = (3, 3, 3) for strides in [1, 2, None]: for dilation_rate in [1, 2]: with self.test_session(use_gpu=True): testing_utils.layer_test(layers.DilatedMaxPool3D, kwargs={ 'strides': strides, 'dilation_rate': dilation_rate, 'pool_size': pool_size }, custom_objects=custom_objects, input_shape=(3, 11, 12, 10, 4)) testing_utils.layer_test(layers.DilatedMaxPool3D, kwargs={ 'strides': strides, 'dilation_rate': dilation_rate, 'data_format': 'channels_first', 'pool_size': pool_size }, custom_objects=custom_objects, input_shape=(3, 4, 11, 12, 10))
def test_dilated_max_pool_3d(self): custom_objects = {'DilatedMaxPool3D': layers.DilatedMaxPool3D} pool_size = (3, 3, 3) for strides in [1, 2, None]: for dilation_rate in [1, 2, (1, 2, 2)]: for padding in ['valid', 'same']: with self.cached_session(): testing_utils.layer_test(layers.DilatedMaxPool3D, kwargs={ 'strides': strides, 'padding': padding, 'dilation_rate': dilation_rate, 'pool_size': pool_size }, custom_objects=custom_objects, input_shape=(3, 11, 12, 10, 4)) testing_utils.layer_test(layers.DilatedMaxPool3D, kwargs={ 'strides': strides, 'padding': padding, 'dilation_rate': dilation_rate, 'data_format': 'channels_first', 'pool_size': pool_size }, custom_objects=custom_objects, input_shape=(3, 4, 11, 12, 10))
def test_dilated_max_pool_2d(self): pool_size = (3, 3) custom_objects = {'DilatedMaxPool2D': layers.DilatedMaxPool2D} for strides in [(1, 1), (2, 2), None]: for dilation_rate in [1, 2]: with self.test_session(use_gpu=True): testing_utils.layer_test(layers.DilatedMaxPool2D, kwargs={ 'strides': strides, 'pool_size': pool_size, 'dilation_rate': dilation_rate, 'data_format': 'channels_last' }, custom_objects=custom_objects, input_shape=(3, 5, 6, 4)) testing_utils.layer_test(layers.DilatedMaxPool2D, kwargs={ 'strides': strides, 'pool_size': pool_size, 'dilation_rate': dilation_rate, 'data_format': 'channels_first' }, custom_objects=custom_objects, input_shape=(3, 4, 5, 6))
def test_dilated_max_pool_2d(self): pool_size = (3, 3) custom_objects = {'DilatedMaxPool2D': layers.DilatedMaxPool2D} for strides in [(1, 1), (2, 2), None]: for dilation_rate in [1, 2, (1, 2)]: for padding in ['valid', 'same']: testing_utils.layer_test(layers.DilatedMaxPool2D, kwargs={ 'strides': strides, 'pool_size': pool_size, 'padding': padding, 'dilation_rate': dilation_rate, 'data_format': 'channels_last' }, custom_objects=custom_objects, input_shape=(3, 5, 6, 4)) testing_utils.layer_test(layers.DilatedMaxPool2D, kwargs={ 'strides': strides, 'pool_size': pool_size, 'padding': padding, 'dilation_rate': dilation_rate, 'data_format': 'channels_first' }, custom_objects=custom_objects, input_shape=(3, 4, 5, 6))
def test_resize_2d(self): testing_utils.layer_test(layers.Resize2D, kwargs={'scale': 2}, custom_objects={'Resize2D': layers.Resize2D}, input_shape=(3, 5, 6, 4)) testing_utils.layer_test(layers.Resize2D, kwargs={ 'scale': 3, 'data_format': 'channels_first' }, custom_objects={'Resize2D': layers.Resize2D}, input_shape=(3, 5, 6, 4))
def test_simple(self): testing_utils.layer_test(layers.Upsample, kwargs={'target_size': (2, 2)}, custom_objects={'Upsample': layers.Upsample}, input_shape=(3, 5, 6, 4)) testing_utils.layer_test(layers.Upsample, kwargs={ 'target_size': (2, 2), 'data_format': 'channels_first' }, custom_objects={'Upsample': layers.Upsample}, input_shape=(3, 4, 5, 6))
def test_conv_gru_2d(self, data_format, return_sequences): num_row = 3 num_col = 3 filters = 2 num_samples = 1 input_channel = 2 input_num_row = 5 input_num_col = 5 sequence_len = 2 custom_objects = {'ConvGRU2D': layers.ConvGRU2D} if data_format == 'channels_first': inputs = np.random.rand(num_samples, sequence_len, input_channel, input_num_row, input_num_col) else: inputs = np.random.rand(num_samples, sequence_len, input_num_row, input_num_col, input_channel) # test for return state: x = keras.layers.Input(batch_shape=inputs.shape) kwargs = {'data_format': data_format, 'return_sequences': return_sequences, 'return_state': True, 'stateful': True, 'filters': filters, 'kernel_size': (num_row, num_col), 'padding': 'valid'} layer = layers.ConvGRU2D(**kwargs) layer.build(inputs.shape) outputs = layer(x) _, states = outputs[0], outputs[1:] self.assertEqual(len(states), len(layer.cell.state_size)) 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( layers.ConvGRU2D, kwargs={'data_format': data_format, 'return_sequences': return_sequences, 'filters': filters, 'kernel_size': (num_row, num_col), 'padding': 'valid'}, custom_objects=custom_objects, input_shape=inputs.shape)
def test_location_3d(self): with self.test_session(): testing_utils.layer_test( layers.Location3D, kwargs={'in_shape': (11, 12, 10, 4), 'data_format': 'channels_last'}, custom_objects={'Location3D': layers.Location3D}, input_shape=(3, 11, 12, 10, 4)) testing_utils.layer_test( layers.Location3D, kwargs={'in_shape': (4, 11, 12, 10), 'data_format': 'channels_first'}, custom_objects={'Location3D': layers.Location3D}, input_shape=(3, 4, 11, 12, 10))
def test_location_2d(self): with self.test_session(): testing_utils.layer_test( layers.Location2D, kwargs={'in_shape': (5, 6, 4), 'data_format': 'channels_last'}, custom_objects={'Location2D': layers.Location2D}, input_shape=(3, 5, 6, 4)) testing_utils.layer_test( layers.Location2D, kwargs={'in_shape': (4, 5, 6), 'data_format': 'channels_first'}, custom_objects={'Location2D': layers.Location2D}, input_shape=(3, 4, 5, 6))
def test_conv_gru_2d_dropout(self): # check dropout with self.cached_session(): testing_utils.layer_test( layers.ConvGRU2D, kwargs={'data_format': 'channels_last', 'return_sequences': False, 'filters': 2, 'kernel_size': (3, 3), 'padding': 'same', 'dropout': 0.1, 'recurrent_dropout': 0.1}, custom_objects={'ConvGRU2D': layers.ConvGRU2D}, input_shape=(1, 2, 5, 5, 2))
def test_reflection_padding_3d(self): num_samples = 2 stack_size = 2 input_len_dim1 = 4 input_len_dim2 = 5 input_len_dim3 = 3 custom_objects = {'ReflectionPadding3D': layers.ReflectionPadding3D} inputs1 = np.ones((num_samples, input_len_dim1, input_len_dim2, input_len_dim3, stack_size)) inputs2 = np.ones((num_samples, stack_size, input_len_dim1, input_len_dim2, input_len_dim3)) data_formats = ['channels_first', 'channels_last'] for data_format, inputs in zip(data_formats, [inputs2, inputs1]): # basic test with self.test_session(): testing_utils.layer_test(layers.ReflectionPadding3D, kwargs={ 'padding': (2, 2, 2), 'data_format': data_format }, custom_objects=custom_objects, input_shape=inputs.shape) # correctness test # with self.test_session(): # layer = layers.ReflectionPadding3D(padding=(2, 2, 2)) # layer.build(inputs.shape) # output = layer(keras.backend.variable(inputs)) # if context.executing_eagerly(): # np_output = output.numpy() # else: # np_output = keras.backend.eval(output) # for offset in [0, 1, -1, -2]: # np.testing.assert_allclose(np_output[:, offset, :, :, :], 0.) # np.testing.assert_allclose(np_output[:, :, offset, :, :], 0.) # np.testing.assert_allclose(np_output[:, :, :, offset, :], 0.) # np.testing.assert_allclose(np_output[:, 2:-2, 2:-2, 2:-2, :], 1.) # test incorrect use with self.assertRaises(ValueError): layers.ReflectionPadding3D(padding=(1, 1)) with self.assertRaises(ValueError): layers.ReflectionPadding3D(padding=None)
def test_normalize_3d(self): custom_objects = {'ImageNormalization3D': layers.ImageNormalization3D} norm_methods = [None, 'std', 'max', 'whole_image'] with self.test_session(): # test each norm method for norm_method in norm_methods: testing_utils.layer_test(layers.ImageNormalization3D, kwargs={ 'norm_method': norm_method, 'filter_size': 3, 'data_format': 'channels_last' }, custom_objects=custom_objects, input_shape=(3, 11, 12, 10, 4)) testing_utils.layer_test(layers.ImageNormalization3D, kwargs={ 'norm_method': norm_method, 'filter_size': 3, 'data_format': 'channels_first' }, custom_objects=custom_objects, input_shape=(3, 4, 11, 12, 10)) # test constraints and bias k_constraint = keras.constraints.max_norm(0.01) b_constraint = keras.constraints.max_norm(0.01) layer = layers.ImageNormalization3D(use_bias=True, kernel_constraint=k_constraint, bias_constraint=b_constraint) layer(keras.backend.variable(np.ones((3, 4, 11, 12, 10)))) # self.assertEqual(layer.kernel.constraint, k_constraint) # self.assertEqual(layer.bias.constraint, b_constraint) # test bad norm_method with self.assertRaises(ValueError): layer = layers.ImageNormalization3D(norm_method='invalid') # test bad input dimensions with self.assertRaises(ValueError): layer = layers.ImageNormalization3D() layer.build([3, 5, 6, 4]) # test invalid channel with self.assertRaises(ValueError): layer = layers.ImageNormalization3D() layer.build([3, 10, 11, 12, None])
def test_anchors_2d(self): with self.test_session(use_gpu=True): testing_utils.layer_test( layers.Anchors, kwargs={ 'size': 1, 'stride': 1, 'data_format': 'channels_last' }, custom_objects={'Anchors': layers.Anchors}, input_shape=(3, 5, 6, 4)) testing_utils.layer_test( layers.Anchors, kwargs={ 'size': 1, 'stride': 1, 'data_format': 'channels_last' }, custom_objects={'Anchors': layers.Anchors}, input_shape=(3, None, None, None)) testing_utils.layer_test( layers.Anchors, kwargs={ 'size': 1, 'stride': 1, 'data_format': 'channels_first' }, custom_objects={'Anchors': layers.Anchors}, input_shape=(3, 5, 6, 4))
def test_reflection_padding_2d(self): num_samples = 2 stack_size = 2 input_num_row = 4 input_num_col = 5 custom_objects = {'ReflectionPadding2D': layers.ReflectionPadding2D} ins1 = np.ones((num_samples, input_num_row, input_num_col, stack_size)) ins2 = np.ones((num_samples, stack_size, input_num_row, input_num_col)) data_formats = ['channels_first', 'channels_last'] for data_format, inputs in zip(data_formats, [ins2, ins1]): # basic test with self.test_session(): testing_utils.layer_test(layers.ReflectionPadding2D, kwargs={ 'padding': (2, 2), 'data_format': data_format }, custom_objects=custom_objects, input_shape=inputs.shape) testing_utils.layer_test(layers.ReflectionPadding2D, kwargs={ 'padding': ((1, 2), (3, 4)), 'data_format': data_format }, custom_objects=custom_objects, input_shape=inputs.shape) # correctness test # with self.test_session(): # layer = layers.ReflectionPadding2D( # padding=(2, 2), data_format=data_format) # layer.build(inputs.shape) # output = layer(keras.backend.variable(inputs)) # if context.executing_eagerly(): # np_output = output.numpy() # else: # np_output = keras.backend.eval(output) # if data_format == 'channels_last': # for offset in [0, 1, -1, -2]: # np.testing.assert_allclose(np_output[:, offset, :, :], 0.) # np.testing.assert_allclose(np_output[:, :, offset, :], 0.) # np.testing.assert_allclose(np_output[:, 2:-2, 2:-2, :], 1.) # elif data_format == 'channels_first': # for offset in [0, 1, -1, -2]: # np.testing.assert_allclose(np_output[:, :, offset, :], 0.) # np.testing.assert_allclose(np_output[:, :, :, offset], 0.) # np.testing.assert_allclose(np_output[:, 2:-2, 2:-2, :], 1.) # layer = layers.ReflectionPadding2D( # padding=((1, 2), (3, 4)), data_format=data_format) # layer.build(inputs.shape) # output = layer(keras.backend.variable(inputs)) # if context.executing_eagerly(): # np_output = output.numpy() # else: # np_output = keras.backend.eval(output) # if data_format == 'channels_last': # for top_offset in [0]: # np.testing.assert_allclose(np_output[:, top_offset, :, :], 0.) # for bottom_offset in [-1, -2]: # np.testing.assert_allclose(np_output[:, bottom_offset, :, :], 0.) # for left_offset in [0, 1, 2]: # np.testing.assert_allclose(np_output[:, :, left_offset, :], 0.) # for right_offset in [-1, -2, -3, -4]: # np.testing.assert_allclose(np_output[:, :, right_offset, :], 0.) # np.testing.assert_allclose(np_output[:, 1:-2, 3:-4, :], 1.) # elif data_format == 'channels_first': # for top_offset in [0]: # np.testing.assert_allclose(np_output[:, :, top_offset, :], 0.) # for bottom_offset in [-1, -2]: # np.testing.assert_allclose(np_output[:, :, bottom_offset, :], 0.) # for left_offset in [0, 1, 2]: # np.testing.assert_allclose(np_output[:, :, :, left_offset], 0.) # for right_offset in [-1, -2, -3, -4]: # np.testing.assert_allclose(np_output[:, :, :, right_offset], 0.) # np.testing.assert_allclose(np_output[:, :, 1:-2, 3:-4], 1.) # test incorrect use with self.assertRaises(ValueError): layers.ReflectionPadding2D(padding=(1, 1, 1)) with self.assertRaises(ValueError): layers.ReflectionPadding2D(padding=None)
def test_tensorproduct(self): custom_objects = {'TensorProduct': layers.TensorProduct} testing_utils.layer_test( layers.TensorProduct, kwargs={'output_dim': 3}, custom_objects=custom_objects, input_shape=(3, 2)) testing_utils.layer_test( layers.TensorProduct, kwargs={'output_dim': 3}, custom_objects=custom_objects, input_shape=(3, 4, 2)) testing_utils.layer_test( layers.TensorProduct, kwargs={'output_dim': 3}, custom_objects=custom_objects, input_shape=(None, None, 2)) testing_utils.layer_test( layers.TensorProduct, kwargs={'output_dim': 3}, custom_objects=custom_objects, input_shape=(3, 4, 5, 2)) testing_utils.layer_test( layers.TensorProduct, kwargs={'output_dim': 3, 'data_format': 'channels_first'}, custom_objects=custom_objects, input_shape=(3, 2, 4, 5)) # test no bias testing_utils.layer_test( layers.TensorProduct, kwargs={'output_dim': 2, 'use_bias': False}, custom_objects=custom_objects, input_shape=(3, 5, 6, 4)) # test bad input channel with self.assertRaises(ValueError): testing_utils.layer_test( layers.TensorProduct, kwargs={'output_dim': 3}, custom_objects=custom_objects, input_shape=(3, 5, 6, None))