def test_zero_padding_1d(): num_samples = 2 input_dim = 2 num_steps = 5 shape = (num_samples, num_steps, input_dim) input = np.ones(shape) # basic test layer_test(convolutional.ZeroPadding1D, kwargs={'padding': 2}, input_shape=input.shape) layer_test(convolutional.ZeroPadding1D, kwargs={'padding': (1, 2)}, input_shape=input.shape) # correctness test layer = convolutional.ZeroPadding1D(padding=2) layer.build(shape) output = layer(K.variable(input)) np_output = K.eval(output) for offset in [0, 1, -1, -2]: assert_allclose(np_output[:, offset, :], 0.) assert_allclose(np_output[:, 2:-2, :], 1.) layer = convolutional.ZeroPadding1D(padding=(1, 2)) layer.build(shape) output = layer(K.variable(input)) np_output = K.eval(output) for left_offset in [0]: assert_allclose(np_output[:, left_offset, :], 0.) for right_offset in [-1, -2]: assert_allclose(np_output[:, right_offset, :], 0.) assert_allclose(np_output[:, 1:-2, :], 1.) layer.get_config()
def basic_batchnorm_test(): layer_test(normalization.BatchNormalization, kwargs={'mode': 1}, input_shape=(3, 4, 2)) layer_test(normalization.BatchNormalization, kwargs={'mode': 0}, input_shape=(3, 4, 2))
def test_convolution_3d_additional_args(): num_samples = 2 filters = 2 stack_size = 3 padding = 'valid' strides = (2, 2, 2) input_len_dim1 = 9 input_len_dim2 = 8 input_len_dim3 = 8 layer_test(convolutional.Convolution3D, kwargs={'filters': filters, 'kernel_size': (1, 2, 3), 'padding': padding, 'activation': None, 'kernel_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2', 'kernel_constraint': 'max_norm', 'bias_constraint': 'max_norm', 'strides': strides}, input_shape=(num_samples, input_len_dim1, input_len_dim2, input_len_dim3, stack_size))
def test_upsampling_2d_bilinear(data_format): num_samples = 2 stack_size = 2 input_num_row = 11 input_num_col = 12 if data_format == 'channels_first': inputs = np.random.rand(num_samples, stack_size, input_num_row, input_num_col) else: # tf inputs = np.random.rand(num_samples, input_num_row, input_num_col, stack_size) # basic test layer_test(convolutional.UpSampling2D, kwargs={'size': (2, 2), 'data_format': data_format, 'interpolation': 'bilinear'}, input_shape=inputs.shape) for length_row in [2]: for length_col in [2, 3]: layer = convolutional.UpSampling2D( size=(length_row, length_col), data_format=data_format) layer.build(inputs.shape) outputs = layer(K.variable(inputs)) np_output = K.eval(outputs) if data_format == 'channels_first': assert np_output.shape[2] == length_row * input_num_row assert np_output.shape[3] == length_col * input_num_col else: # tf assert np_output.shape[1] == length_row * input_num_row assert np_output.shape[2] == length_col * input_num_col
def test_separable_conv_2d_additional_args(): num_samples = 2 filters = 6 stack_size = 3 num_row = 7 num_col = 6 padding = 'valid' strides = (2, 2) multiplier = 2 layer_test(convolutional.SeparableConv2D, kwargs={'filters': filters, 'kernel_size': 3, 'padding': padding, 'data_format': 'channels_first', 'activation': None, 'depthwise_regularizer': 'l2', 'pointwise_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2', 'pointwise_constraint': 'unit_norm', 'depthwise_constraint': 'unit_norm', 'strides': strides, 'depth_multiplier': multiplier}, input_shape=(num_samples, stack_size, num_row, num_col))
def test_conv_1d(padding, strides): batch_size = 2 steps = 8 input_dim = 2 kernel_size = 3 filters = 3 layer_test(convolutional.Conv1D, kwargs={'filters': filters, 'kernel_size': kernel_size, 'padding': padding, 'strides': strides}, input_shape=(batch_size, steps, input_dim)) layer_test(convolutional.Conv1D, kwargs={'filters': filters, 'kernel_size': kernel_size, 'padding': padding, 'kernel_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2', 'kernel_constraint': 'max_norm', 'bias_constraint': 'max_norm', 'strides': strides}, input_shape=(batch_size, steps, input_dim))
def test_atrous_conv_2d(): nb_samples = 2 nb_filter = 2 stack_size = 3 nb_row = 10 nb_col = 6 for border_mode in _convolution_border_modes: for subsample in [(1, 1), (2, 2)]: for atrous_rate in [(1, 1), (2, 2)]: if border_mode == 'same' and subsample != (1, 1): continue if subsample != (1, 1) and atrous_rate != (1, 1): continue layer_test(convolutional.AtrousConv2D, kwargs={'nb_filter': nb_filter, 'nb_row': 3, 'nb_col': 3, 'border_mode': border_mode, 'subsample': subsample, 'atrous_rate': atrous_rate}, input_shape=(nb_samples, nb_row, nb_col, stack_size)) layer_test(convolutional.AtrousConv2D, kwargs={'nb_filter': nb_filter, 'nb_row': 3, 'nb_col': 3, 'border_mode': border_mode, 'W_regularizer': 'l2', 'b_regularizer': 'l2', 'activity_regularizer': 'activity_l2', 'subsample': subsample, 'atrous_rate': atrous_rate}, input_shape=(nb_samples, nb_row, nb_col, stack_size))
def test_convolution_1d(): nb_samples = 2 nb_steps = 8 input_dim = 2 filter_length = 3 nb_filter = 3 for border_mode in ['valid', 'same']: for subsample_length in [1]: if border_mode == 'same' and subsample_length != 1: continue layer_test(convolutional.Convolution1D, kwargs={'nb_filter': nb_filter, 'filter_length': filter_length, 'border_mode': border_mode, 'subsample_length': subsample_length}, input_shape=(nb_samples, nb_steps, input_dim)) layer_test(convolutional.Convolution1D, kwargs={'nb_filter': nb_filter, 'filter_length': filter_length, 'border_mode': border_mode, 'W_regularizer': 'l2', 'b_regularizer': 'l2', 'activity_regularizer': 'activity_l2', 'subsample_length': subsample_length}, input_shape=(nb_samples, nb_steps, input_dim))
def test_zero_padding_3d(): nb_samples = 2 stack_size = 2 input_len_dim1 = 4 input_len_dim2 = 5 input_len_dim3 = 3 input = np.ones((nb_samples, input_len_dim1, input_len_dim2, input_len_dim3, stack_size)) # basic test layer_test(convolutional.ZeroPadding3D, kwargs={'padding': (2, 2, 2)}, input_shape=input.shape) # correctness test layer = convolutional.ZeroPadding3D(padding=(2, 2, 2)) layer.build(input.shape) output = layer(K.variable(input)) np_output = K.eval(output) for offset in [0, 1, -1, -2]: assert_allclose(np_output[:, offset, :, :, :], 0.) assert_allclose(np_output[:, :, offset, :, :], 0.) assert_allclose(np_output[:, :, :, offset, :], 0.) assert_allclose(np_output[:, 2:-2, 2:-2, 2:-2, :], 1.) layer.get_config()
def test_zero_padding_3d(): nb_samples = 9 stack_size = 7 input_len_dim1 = 10 input_len_dim2 = 11 input_len_dim3 = 12 input = np.ones((nb_samples, stack_size, input_len_dim1, input_len_dim2, input_len_dim3)) # basic test layer_test(convolutional.ZeroPadding3D, kwargs={'padding': (2, 2, 2)}, input_shape=input.shape) # correctness test layer = convolutional.ZeroPadding3D(padding=(2, 2, 2)) layer.set_input(K.variable(input), shape=input.shape) out = K.eval(layer.output) for offset in [0, 1, -1, -2]: assert_allclose(out[:, :, offset, :, :], 0.) assert_allclose(out[:, :, :, offset, :], 0.) assert_allclose(out[:, :, :, :, offset], 0.) assert_allclose(out[:, :, 2:-2, 2:-2, 2:-2], 1.) layer.get_config()
def test_maxpooling_2d(strides): pool_size = (3, 3) layer_test(convolutional.MaxPooling2D, kwargs={'strides': strides, 'padding': 'valid', 'pool_size': pool_size}, input_shape=(3, 5, 6, 4))
def test_averagepooling_2d(strides, padding, data_format, input_shape): layer_test(convolutional.AveragePooling2D, kwargs={'strides': strides, 'padding': padding, 'pool_size': (2, 2), 'data_format': data_format}, input_shape=input_shape)
def test_locallyconnected_1d(): nb_samples = 2 nb_steps = 8 input_dim = 5 filter_length = 3 nb_filter = 4 for border_mode in ['valid']: for subsample_length in [1]: if border_mode == 'same' and subsample_length != 1: continue layer_test(local.LocallyConnected1D, kwargs={'nb_filter': nb_filter, 'filter_length': filter_length, 'border_mode': border_mode, 'subsample_length': subsample_length}, input_shape=(nb_samples, nb_steps, input_dim)) layer_test(local.LocallyConnected1D, kwargs={'nb_filter': nb_filter, 'filter_length': filter_length, 'border_mode': border_mode, 'W_regularizer': 'l2', 'b_regularizer': 'l2', 'activity_regularizer': 'activity_l2', 'subsample_length': subsample_length}, input_shape=(nb_samples, nb_steps, input_dim))
def test_locallyconnected_2d(): nb_samples = 8 nb_filter = 3 stack_size = 4 nb_row = 6 nb_col = 10 for border_mode in ['valid']: for subsample in [(1, 1), (2, 2)]: if border_mode == 'same' and subsample != (1, 1): continue layer_test(local.LocallyConnected2D, kwargs={'nb_filter': nb_filter, 'nb_row': 3, 'nb_col': 3, 'border_mode': border_mode, 'W_regularizer': 'l2', 'b_regularizer': 'l2', 'activity_regularizer': 'activity_l2', 'subsample': subsample, 'dim_ordering': 'tf'}, input_shape=(nb_samples, nb_row, nb_col, stack_size)) layer_test(local.LocallyConnected2D, kwargs={'nb_filter': nb_filter, 'nb_row': 3, 'nb_col': 3, 'border_mode': border_mode, 'W_regularizer': 'l2', 'b_regularizer': 'l2', 'activity_regularizer': 'activity_l2', 'subsample': subsample, 'dim_ordering': 'th'}, input_shape=(nb_samples, stack_size, nb_row, nb_col))
def test_maxpooling_1d(): for border_mode in ['valid', 'same']: for stride in [1, 2]: layer_test(convolutional.MaxPooling1D, kwargs={'stride': stride, 'border_mode': border_mode}, input_shape=(3, 5, 4))
def test_lambda(): layer_test(layers.Lambda, kwargs={'function': lambda x: x + 1}, input_shape=(3, 2)) layer_test(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 = layers.Lambda(f) config = ld.get_config() ld = deserialize_layer({'class_name': 'Lambda', 'config': config}) # test with lambda ld = layers.Lambda( lambda x: K.concatenate([K.square(x), x]), output_shape=lambda s: tuple(list(s)[:-1] + [2 * s[-1]])) config = ld.get_config() ld = layers.Lambda.from_config(config) # test serialization with output_shape function def f(x): return K.concatenate([K.square(x), x]) def f_shape(s): return tuple(list(s)[:-1] + [2 * s[-1]]) ld = layers.Lambda(f, output_shape=f_shape) config = ld.get_config() ld = deserialize_layer({'class_name': 'Lambda', 'config': config})
def test_cropping_2d(): nb_samples = 2 stack_size = 2 input_len_dim1 = 8 input_len_dim2 = 8 cropping = ((2, 2), (3, 3)) dim_ordering = K.image_dim_ordering() if dim_ordering == 'th': input = np.random.rand(nb_samples, stack_size, input_len_dim1, input_len_dim2) else: input = np.random.rand(nb_samples, input_len_dim1, input_len_dim2, stack_size) # basic test layer_test(convolutional.Cropping2D, kwargs={'cropping': cropping, 'dim_ordering': dim_ordering}, input_shape=input.shape) # correctness test layer = convolutional.Cropping2D(cropping=cropping, dim_ordering=dim_ordering) layer.set_input(K.variable(input), shape=input.shape) out = K.eval(layer.output) # compare with numpy if dim_ordering == 'th': expected_out = input[:, :, cropping[0][0]:-cropping[0][1], cropping[1][0]:-cropping[1][1]] else: expected_out = input[:, cropping[0][0]:-cropping[0][1], cropping[1][0]:-cropping[1][1], :] assert_allclose(out, expected_out)
def test_zero_padding_3d(): num_samples = 2 stack_size = 2 input_len_dim1 = 4 input_len_dim2 = 5 input_len_dim3 = 3 inputs = np.ones((num_samples, input_len_dim1, input_len_dim2, input_len_dim3, stack_size)) # basic test for data_format in ['channels_first', 'channels_last']: layer_test(convolutional.ZeroPadding3D, kwargs={'padding': (2, 2, 2), 'data_format': data_format}, input_shape=inputs.shape) layer_test(convolutional.ZeroPadding3D, kwargs={'padding': ((1, 2), (3, 4), (0, 2)), 'data_format': data_format}, input_shape=inputs.shape) # correctness test layer = convolutional.ZeroPadding3D(padding=(2, 2, 2), data_format=data_format) layer.build(inputs.shape) outputs = layer(K.variable(inputs)) np_output = K.eval(outputs) if data_format == 'channels_last': for offset in [0, 1, -1, -2]: assert_allclose(np_output[:, offset, :, :, :], 0.) assert_allclose(np_output[:, :, offset, :, :], 0.) assert_allclose(np_output[:, :, :, offset, :], 0.) assert_allclose(np_output[:, 2:-2, 2:-2, 2:-2, :], 1.) elif data_format == 'channels_first': for offset in [0, 1, -1, -2]: assert_allclose(np_output[:, :, offset, :, :], 0.) assert_allclose(np_output[:, :, :, offset, :], 0.) assert_allclose(np_output[:, :, :, :, offset], 0.) assert_allclose(np_output[:, :, 2:-2, 2:-2, 2:-2], 1.) layer = convolutional.ZeroPadding3D(padding=((1, 2), (3, 4), (0, 2)), data_format=data_format) layer.build(inputs.shape) outputs = layer(K.variable(inputs)) np_output = K.eval(outputs) if data_format == 'channels_last': for dim1_offset in [0, -1, -2]: assert_allclose(np_output[:, dim1_offset, :, :, :], 0.) for dim2_offset in [0, 1, 2, -1, -2, -3, -4]: assert_allclose(np_output[:, :, dim2_offset, :, :], 0.) for dim3_offset in [-1, -2]: assert_allclose(np_output[:, :, :, dim3_offset, :], 0.) assert_allclose(np_output[:, 1:-2, 3:-4, 0:-2, :], 1.) elif data_format == 'channels_first': for dim1_offset in [0, -1, -2]: assert_allclose(np_output[:, :, dim1_offset, :, :], 0.) for dim2_offset in [0, 1, 2, -1, -2, -3, -4]: assert_allclose(np_output[:, :, :, dim2_offset, :], 0.) for dim3_offset in [-1, -2]: assert_allclose(np_output[:, :, :, :, dim3_offset], 0.) assert_allclose(np_output[:, :, 1:-2, 3:-4, 0:-2], 1.)
def test_dense(): from keras import regularizers from keras import constraints layer_test(core.Dense, kwargs={'output_dim': 3}, input_shape=(3, 2)) layer_test(core.Dense, kwargs={'output_dim': 3}, input_shape=(3, 4, 2)) layer_test(core.Dense, kwargs={'output_dim': 3}, input_shape=(None, None, 2)) layer_test(core.Dense, kwargs={'output_dim': 3}, input_shape=(3, 4, 5, 2)) layer_test(core.Dense, kwargs={'output_dim': 3, 'W_regularizer': regularizers.l2(0.01), 'b_regularizer': regularizers.l1(0.01), 'activity_regularizer': regularizers.activity_l2(0.01), 'W_constraint': constraints.MaxNorm(1), 'b_constraint': constraints.MaxNorm(1)}, input_shape=(3, 2))
def test_atrous_conv_1d(): nb_samples = 2 nb_steps = 8 input_dim = 2 filter_length = 3 nb_filter = 3 for border_mode in _convolution_border_modes: for subsample_length in [1, 2]: for atrous_rate in [1, 2]: if border_mode == 'same' and subsample_length != 1: continue if subsample_length != 1 and atrous_rate != 1: continue layer_test(convolutional.AtrousConv1D, kwargs={'nb_filter': nb_filter, 'filter_length': filter_length, 'border_mode': border_mode, 'subsample_length': subsample_length, 'atrous_rate': atrous_rate}, input_shape=(nb_samples, nb_steps, input_dim)) layer_test(convolutional.AtrousConv1D, kwargs={'nb_filter': nb_filter, 'filter_length': filter_length, 'border_mode': border_mode, 'W_regularizer': 'l2', 'b_regularizer': 'l2', 'activity_regularizer': 'activity_l2', 'subsample_length': subsample_length, 'atrous_rate': atrous_rate}, input_shape=(nb_samples, nb_steps, input_dim))
def test_conv2d_transpose_dilation(): layer_test(convolutional.Conv2DTranspose, kwargs={'filters': 2, 'kernel_size': 3, 'padding': 'same', 'data_format': 'channels_last', 'dilation_rate': (2, 2)}, input_shape=(2, 5, 6, 3)) # Check dilated conv transpose returns expected output input_data = np.arange(48).reshape((1, 4, 4, 3)).astype(np.float32) 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)) layer_test(convolutional.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_convolution_2d(): nb_samples = 2 nb_filter = 2 stack_size = 3 nb_row = 10 nb_col = 6 for border_mode in ['valid', 'same']: for subsample in [(1, 1), (2, 2)]: if border_mode == 'same' and subsample != (1, 1): continue layer_test(convolutional.Convolution2D, kwargs={'nb_filter': nb_filter, 'nb_row': 3, 'nb_col': 3, 'border_mode': border_mode, 'subsample': subsample}, input_shape=(nb_samples, stack_size, nb_row, nb_col)) layer_test(convolutional.Convolution2D, kwargs={'nb_filter': nb_filter, 'nb_row': 3, 'nb_col': 3, 'border_mode': border_mode, 'W_regularizer': 'l2', 'b_regularizer': 'l2', 'activity_regularizer': 'activity_l2', 'subsample': subsample}, input_shape=(nb_samples, stack_size, nb_row, nb_col))
def test_dense(): layer_test(layers.Dense, kwargs={'units': 3}, input_shape=(3, 2)) layer_test(layers.Dense, kwargs={'units': 3}, input_shape=(3, 4, 2)) layer_test(layers.Dense, kwargs={'units': 3}, input_shape=(None, None, 2)) layer_test(layers.Dense, kwargs={'units': 3}, input_shape=(3, 4, 5, 2)) layer_test(layers.Dense, kwargs={'units': 3, 'kernel_regularizer': regularizers.l2(0.01), 'bias_regularizer': regularizers.l1(0.01), 'activity_regularizer': regularizers.L1L2(l1=0.01, l2=0.01), 'kernel_constraint': constraints.MaxNorm(1), 'bias_constraint': constraints.max_norm(1)}, input_shape=(3, 2)) layer = layers.Dense(3, kernel_regularizer=regularizers.l1(0.01), bias_regularizer='l1') layer.build((None, 4)) assert len(layer.losses) == 2
def test_dropout(layer_class): for unroll in [True, False]: layer_test(layer_class, kwargs={'units': units, 'dropout': 0.1, 'recurrent_dropout': 0.1, 'unroll': unroll}, input_shape=(num_samples, timesteps, embedding_dim)) # Test that dropout is applied during training x = K.ones((num_samples, timesteps, embedding_dim)) layer = layer_class(units, dropout=0.5, recurrent_dropout=0.5, input_shape=(timesteps, embedding_dim)) y = layer(x) assert y._uses_learning_phase y = layer(x, training=True) assert not getattr(y, '_uses_learning_phase') # Test that dropout is not applied during testing x = np.random.random((num_samples, timesteps, embedding_dim)) layer = layer_class(units, dropout=0.5, recurrent_dropout=0.5, unroll=unroll, input_shape=(timesteps, embedding_dim)) model = Sequential([layer]) assert model.uses_learning_phase y1 = model.predict(x) y2 = model.predict(x) assert_allclose(y1, y2)
def test_parametric_softplus(): from keras.layers.advanced_activations import ParametricSoftplus for alpha in [0., .5, -1.]: layer_test(ParametricSoftplus, kwargs={'alpha_init': 1., 'beta_init': -1}, input_shape=(2, 3, 4))
def test_separable_conv_2d(): num_samples = 2 filters = 6 stack_size = 3 num_row = 7 num_col = 6 for padding in _convolution_paddings: for strides in [(1, 1), (2, 2)]: for multiplier in [1, 2]: if padding == 'same' and strides != (1, 1): continue layer_test(convolutional.SeparableConv2D, kwargs={'filters': filters, 'kernel_size': (3, 3), 'padding': padding, 'strides': strides, 'depth_multiplier': multiplier}, input_shape=(num_samples, num_row, num_col, stack_size)) layer_test(convolutional.SeparableConv2D, kwargs={'filters': filters, 'kernel_size': 3, 'padding': padding, 'depthwise_regularizer': 'l2', 'pointwise_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2', 'pointwise_constraint': 'unit_norm', 'depthwise_constraint': 'unit_norm', 'strides': strides, 'depth_multiplier': multiplier}, input_shape=(num_samples, num_row, num_col, stack_size))
def test_conv2d_transpose(): num_samples = 2 filters = 2 stack_size = 3 num_row = 5 num_col = 6 for padding in _convolution_paddings: for strides in [(1, 1), (2, 2)]: if padding == 'same' and strides != (1, 1): continue layer_test(convolutional.Deconvolution2D, kwargs={'filters': filters, 'kernel_size': 3, 'padding': padding, 'strides': strides, 'data_format': 'channels_last'}, input_shape=(num_samples, num_row, num_col, stack_size), fixed_batch_size=True) layer_test(convolutional.Deconvolution2D, kwargs={'filters': filters, 'kernel_size': 3, 'padding': padding, 'data_format': 'channels_first', 'kernel_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2', 'kernel_constraint': 'max_norm', 'bias_constraint': 'max_norm', 'strides': strides}, input_shape=(num_samples, stack_size, num_row, num_col), fixed_batch_size=True)
def test_averagepooling_1d(): for padding in ['valid', 'same']: for stride in [1, 2]: layer_test(convolutional.AveragePooling1D, kwargs={'strides': stride, 'padding': padding}, input_shape=(3, 5, 4))
def test_dropout(): layer_test(layers.Dropout, kwargs={'rate': 0.5}, input_shape=(3, 2)) layer_test(layers.Dropout, kwargs={'rate': 0.5, 'noise_shape': [3, 1]}, input_shape=(3, 2)) layer_test(layers.SpatialDropout1D, kwargs={'rate': 0.5}, input_shape=(2, 3, 4)) for data_format in ['channels_last', 'channels_first']: for shape in [(4, 5), (4, 5, 6)]: if data_format == 'channels_last': input_shape = (2,) + shape + (3,) else: input_shape = (2, 3) + shape layer_test(layers.SpatialDropout2D if len(shape) == 2 else layers.SpatialDropout3D, kwargs={'rate': 0.5, 'data_format': data_format}, input_shape=input_shape) # Test invalid use cases with pytest.raises(ValueError): layer_test(layers.SpatialDropout2D if len(shape) == 2 else layers.SpatialDropout3D, kwargs={'rate': 0.5, 'data_format': 'channels_middle'}, input_shape=input_shape)
def test_lambda(): from keras.utils.layer_utils import layer_from_config Lambda = core.Lambda layer_test(Lambda, kwargs={'function': lambda x: x + 1}, input_shape=(3, 2)) # test serialization with function def f(x): return x + 1 ld = Lambda(f) config = ld.get_config() ld = layer_from_config({'class_name': 'Lambda', 'config': config}) ld = Lambda(lambda x: K.concatenate([K.square(x), x]), output_shape=lambda s: tuple(list(s)[:-1] + [2 * s[-1]])) config = ld.get_config() ld = Lambda.from_config(config) # test serialization with output_shape function def f(x): return K.concatenate([K.square(x), x]) def f_shape(s): return tuple(list(s)[:-1] + [2 * s[-1]]) ld = Lambda(f, output_shape=f_shape) config = ld.get_config() ld = layer_from_config({'class_name': 'Lambda', 'config': config})
def test_reshape(): layer_test(core.Reshape, kwargs={'target_shape': (8, 1)}, input_shape=(3, 2, 4)) layer_test(core.Reshape, kwargs={'target_shape': (-1, 1)}, input_shape=(3, 2, 4)) layer_test(core.Reshape, kwargs={'target_shape': (1, -1)}, input_shape=(3, 2, 4))
def DISABLED_test_convolutional_recurrent(data_format, return_sequences, use_mask): class Masking5D(Masking): """Regular masking layer returns wrong shape of mask for RNN""" def compute_mask(self, inputs, mask=None): return K.any(K.not_equal(inputs, 0.), axis=[2, 3, 4]) 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 = 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 = convolutional_recurrent.ConvLSTM2D(**kwargs) layer.build(inputs.shape) if use_mask: outputs = layer(Masking5D()(x)) else: outputs = layer(x) output, states = outputs[0], outputs[1:] assert len(states) == 2 model = Model(x, states[0]) state = model.predict(inputs) np.testing.assert_allclose(K.eval(layer.states[0]), state, atol=1e-4) # test for output shape: output = layer_test(convolutional_recurrent.ConvLSTM2D, kwargs={'data_format': data_format, 'return_sequences': return_sequences, 'filters': filters, 'kernel_size': (num_row, num_col), 'padding': 'valid'}, input_shape=inputs.shape)
def test_convolutional_recurrent(): for data_format in ['channels_first', 'channels_last']: 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) for return_sequences in [True, False]: # test for return state: x = 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 = convolutional_recurrent.ConvLSTM2D(**kwargs) layer.build(inputs.shape) outputs = layer(x) output, states = outputs[0], outputs[1:] assert len(states) == 2 model = Model(x, states[0]) state = model.predict(inputs) np.testing.assert_allclose(K.eval(layer.states[0]), state, atol=1e-4) # test for output shape: output = layer_test(convolutional_recurrent.ConvLSTM2D, kwargs={ 'data_format': data_format, 'return_sequences': return_sequences, 'filters': filters, 'kernel_size': (num_row, num_col), 'padding': 'valid' }, input_shape=inputs.shape)
def test_dense(): from keras import regularizers from keras import constraints layer_test(core.Dense, kwargs={'output_dim': 3}, input_shape=(3, 2)) layer_test(core.Dense, kwargs={'output_dim': 3}, input_shape=(3, 4, 2)) layer_test(core.Dense, kwargs={'output_dim': 3}, input_shape=(3, 4, 5, 2)) layer_test(core.Dense, kwargs={ 'output_dim': 3, 'W_regularizer': regularizers.l2(0.01), 'b_regularizer': regularizers.l1(0.01), 'activity_regularizer': regularizers.activity_l2(0.01), 'W_constraint': constraints.MaxNorm(1), 'b_constraint': constraints.MaxNorm(1) }, input_shape=(3, 2))
def test_convolution_2d(): num_samples = 2 filters = 2 stack_size = 3 kernel_size = (3, 2) num_row = 7 num_col = 6 for padding in _convolution_paddings: for strides in [(1, 1), (2, 2)]: if padding == 'same' and strides != (1, 1): continue layer_test(convolutional.Conv2D, kwargs={'filters': filters, 'kernel_size': kernel_size, 'padding': padding, 'strides': strides, 'data_format': 'channels_first'}, input_shape=(num_samples, stack_size, num_row, num_col)) layer_test(convolutional.Conv2D, kwargs={'filters': filters, 'kernel_size': 3, 'padding': padding, 'data_format': 'channels_last', 'activation': None, 'kernel_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2', 'kernel_constraint': 'max_norm', 'bias_constraint': 'max_norm', 'strides': strides}, input_shape=(num_samples, num_row, num_col, stack_size)) # Test dilation layer_test(convolutional.Conv2D, kwargs={'filters': filters, 'kernel_size': kernel_size, 'padding': padding, 'dilation_rate': (2, 2)}, input_shape=(num_samples, num_row, num_col, stack_size)) # Test invalid use case with pytest.raises(ValueError): model = Sequential([convolutional.Conv2D(filters=filters, kernel_size=kernel_size, padding=padding, batch_input_shape=(None, None, 5, None))])
def test_conv_1d(): batch_size = 2 steps = 8 input_dim = 2 kernel_size = 3 filters = 3 for padding in _convolution_paddings: for strides in [1, 2]: if padding == 'same' and strides != 1: continue layer_test(convolutional.Conv1D, kwargs={ 'filters': filters, 'kernel_size': kernel_size, 'padding': padding, 'strides': strides }, input_shape=(batch_size, steps, input_dim)) layer_test(convolutional.Conv1D, kwargs={ 'filters': filters, 'kernel_size': kernel_size, 'padding': padding, 'kernel_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2', 'kernel_constraint': 'max_norm', 'bias_constraint': 'max_norm', 'strides': strides }, input_shape=(batch_size, steps, input_dim)) # Test dilation layer_test(convolutional.Conv1D, kwargs={ 'filters': filters, 'kernel_size': kernel_size, 'padding': padding, 'dilation_rate': 2, 'activation': None }, input_shape=(batch_size, steps, input_dim)) convolutional.Conv1D(filters=filters, kernel_size=kernel_size, padding=padding, input_shape=(input_dim, ))
def test_embedding(): layer_test(Embedding, kwargs={ 'output_dim': 4, 'input_dim': 10, 'input_length': 2 }, input_shape=(3, 2), input_dtype='int32', expected_output_dtype=K.floatx()) layer_test(Embedding, kwargs={ 'output_dim': 4, 'input_dim': 10, 'mask_zero': True }, input_shape=(3, 2), input_dtype='int32', expected_output_dtype=K.floatx()) layer_test(Embedding, kwargs={ 'output_dim': 4, 'input_dim': 10, 'mask_zero': True }, input_shape=(3, 2, 5), input_dtype='int32', expected_output_dtype=K.floatx()) layer_test(Embedding, kwargs={ 'output_dim': 4, 'input_dim': 10, 'mask_zero': True, 'input_length': (None, 5) }, input_shape=(3, 2, 5), input_dtype='int32', expected_output_dtype=K.floatx())
def basic_batchnorm_test(): from keras import regularizers layer_test(normalization.BatchNormalization, kwargs={'momentum': 0.9, 'epsilon': 0.1, 'gamma_regularizer': regularizers.l2(0.01), 'beta_regularizer': regularizers.l2(0.01)}, input_shape=(3, 4, 2)) layer_test(normalization.BatchNormalization, kwargs={'gamma_initializer': 'ones', 'beta_initializer': 'ones', 'moving_mean_initializer': 'zeros', 'moving_variance_initializer': 'ones'}, input_shape=(3, 4, 2)) layer_test(normalization.BatchNormalization, kwargs={'scale': False, 'center': False}, input_shape=(3, 3))
def test_causal_dilated_conv(): # Causal: # specify to use channels_last data format, # as default data format for Conv1D is None now layer_test(convolutional.Conv1D, input_data=np.reshape(np.arange(4, dtype='float32'), (1, 4, 1)), kwargs={ 'filters': 1, 'kernel_size': 2, 'dilation_rate': 1, 'padding': 'causal', 'kernel_initializer': 'ones', 'use_bias': False, 'data_format': 'channels_last' }, expected_output=[[[0], [1], [3], [5]]]) # Non-causal: layer_test(convolutional.Conv1D, input_data=np.reshape(np.arange(4, dtype='float32'), (1, 4, 1)), kwargs={ 'filters': 1, 'kernel_size': 2, 'dilation_rate': 1, 'padding': 'valid', 'kernel_initializer': 'ones', 'use_bias': False, 'data_format': 'channels_last' }, expected_output=[[[1], [3], [5]]]) # Causal dilated with larger kernel size: layer_test(convolutional.Conv1D, input_data=np.reshape(np.arange(10, dtype='float32'), (1, 10, 1)), kwargs={ 'filters': 1, 'kernel_size': 3, 'dilation_rate': 2, 'padding': 'causal', 'kernel_initializer': 'ones', 'use_bias': False, 'data_format': 'channels_last' }, expected_output=np.float32([[[0], [1], [2], [4], [6], [9], [12], [15], [18], [21]]]))
def test_averagepooling_2d(): layer_test(convolutional.AveragePooling2D, kwargs={'strides': (2, 2), 'padding': 'same', 'pool_size': (2, 2)}, input_shape=(3, 5, 6, 4)) layer_test(convolutional.AveragePooling2D, kwargs={'strides': (2, 2), 'padding': 'valid', 'pool_size': (3, 3)}, input_shape=(3, 5, 6, 4)) layer_test(convolutional.AveragePooling2D, kwargs={'strides': (1, 1), 'padding': 'valid', 'pool_size': (2, 2), 'data_format': 'channels_first'}, input_shape=(3, 4, 5, 6))
def test_convolution_2d(): num_samples = 2 filters = 2 stack_size = 3 kernel_size = (3, 2) num_row = 7 num_col = 6 for padding in _convolution_paddings: for strides in [(1, 1), (2, 2)]: if padding == 'same' and strides != (1, 1): continue layer_test(convolutional.Conv2D, kwargs={ 'filters': filters, 'kernel_size': kernel_size, 'padding': padding, 'strides': strides, 'data_format': 'channels_first' }, input_shape=(num_samples, stack_size, num_row, num_col)) layer_test(convolutional.Conv2D, kwargs={ 'filters': filters, 'kernel_size': 3, 'padding': padding, 'kernel_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2', 'kernel_constraint': 'max_norm', 'bias_constraint': 'max_norm', 'strides': strides }, input_shape=(num_samples, num_row, num_col, stack_size)) # Test dilation layer_test(convolutional.Conv2D, kwargs={ 'filters': filters, 'kernel_size': kernel_size, 'padding': padding, 'dilation_rate': (2, 2) }, input_shape=(num_samples, num_row, num_col, stack_size))
def test_implementation_mode(layer_class): for mode in [1, 2]: # Without dropout layer_test(layer_class, kwargs={'units': units, 'implementation': mode}, input_shape=(num_samples, timesteps, embedding_dim)) # With dropout layer_test(layer_class, kwargs={'units': units, 'implementation': mode, 'dropout': 0.1, 'recurrent_dropout': 0.1}, input_shape=(num_samples, timesteps, embedding_dim)) # Without bias layer_test(layer_class, kwargs={'units': units, 'implementation': mode, 'use_bias': False}, input_shape=(num_samples, timesteps, embedding_dim))
def basic_instancenorm_test(): from keras import regularizers layer_test(normalization.InstanceNormalization, kwargs={ 'epsilon': 0.1, 'gamma_regularizer': regularizers.l2(0.01), 'beta_regularizer': regularizers.l2(0.01) }, input_shape=(3, 4, 2)) layer_test(normalization.InstanceNormalization, kwargs={ 'gamma_initializer': 'ones', 'beta_initializer': 'ones' }, input_shape=(3, 4, 2)) layer_test(normalization.InstanceNormalization, kwargs={ 'scale': False, 'center': False }, input_shape=(3, 3))
def test_zero_padding_1d(): nb_samples = 2 input_dim = 2 nb_steps = 5 shape = (nb_samples, nb_steps, input_dim) input = np.ones(shape) # basic test layer_test(convolutional.ZeroPadding1D, kwargs={'padding': 2}, input_shape=input.shape) layer_test(convolutional.ZeroPadding1D, kwargs={'padding': (1, 2)}, input_shape=input.shape) layer_test(convolutional.ZeroPadding1D, kwargs={'padding': { 'left_pad': 1, 'right_pad': 2 }}, input_shape=input.shape) # correctness test layer = convolutional.ZeroPadding1D(padding=2) layer.build(shape) output = layer(K.variable(input)) np_output = K.eval(output) for offset in [0, 1, -1, -2]: assert_allclose(np_output[:, offset, :], 0.) assert_allclose(np_output[:, 2:-2, :], 1.) layer = convolutional.ZeroPadding1D(padding=(1, 2)) layer.build(shape) output = layer(K.variable(input)) np_output = K.eval(output) for left_offset in [0]: assert_allclose(np_output[:, left_offset, :], 0.) for right_offset in [-1, -2]: assert_allclose(np_output[:, right_offset, :], 0.) assert_allclose(np_output[:, 1:-2, :], 1.) layer.get_config()
def test_masking(): layer_test(core.Masking, kwargs={}, input_shape=(3, 2, 3))
def test_repeat_vector(): layer_test(core.RepeatVector, kwargs={'n': 3}, input_shape=(3, 2))
def test_cropping_2d(): num_samples = 2 stack_size = 2 input_len_dim1 = 9 input_len_dim2 = 9 cropping = ((2, 2), (3, 3)) 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) else: inputs = np.random.rand(num_samples, input_len_dim1, input_len_dim2, stack_size) # basic test layer_test(convolutional.Cropping2D, kwargs={'cropping': cropping, 'data_format': data_format}, input_shape=inputs.shape) # correctness test layer = convolutional.Cropping2D(cropping=cropping, data_format=data_format) layer.build(inputs.shape) outputs = layer(K.variable(inputs)) np_output = K.eval(outputs) # compare with numpy if data_format == 'channels_first': expected_out = inputs[:, :, cropping[0][0]: -cropping[0][1], cropping[1][0]: -cropping[1][1]] else: expected_out = inputs[:, cropping[0][0]: -cropping[0][1], cropping[1][0]: -cropping[1][1], :] assert_allclose(np_output, expected_out) 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) else: inputs = np.random.rand(num_samples, input_len_dim1, input_len_dim2, stack_size) # another correctness test (no cropping) cropping = ((0, 0), (0, 0)) layer = convolutional.Cropping2D(cropping=cropping, data_format=data_format) layer.build(inputs.shape) outputs = layer(K.variable(inputs)) np_output = K.eval(outputs) # compare with input assert_allclose(np_output, inputs) # Test invalid use cases with pytest.raises(ValueError): layer = convolutional.Cropping2D(cropping=((1, 1),)) with pytest.raises(ValueError): layer = convolutional.Cropping2D(cropping=lambda x: x)
def test_causal_dilated_conv(layer_kwargs, input_length, expected_output): input_data = np.reshape(np.arange(input_length, dtype='float32'), (1, input_length, 1)) layer_test(convolutional.Conv1D, input_data=input_data, kwargs=layer_kwargs, expected_output=expected_output)
def test_GaussianDropout(): layer_test(noise.GaussianDropout, kwargs={'p': 0.5}, input_shape=(3, 2, 3))
def test_dropout(): layer_test(core.Dropout, kwargs={'p': 0.5}, input_shape=(3, 2))
def test_averagepooling_1d(): for stride in [1, 2]: layer_test(convolutional.AveragePooling1D, kwargs={'stride': stride, 'border_mode': 'valid'}, input_shape=(3, 5, 4))
def test_zero_padding_2d(): nb_samples = 2 stack_size = 2 input_nb_row = 4 input_nb_col = 5 dim_ordering = K.image_dim_ordering() assert dim_ordering in {'tf', 'th'}, 'dim_ordering must be in {tf, th}' if dim_ordering == 'tf': input = np.ones((nb_samples, input_nb_row, input_nb_col, stack_size)) elif dim_ordering == 'th': input = np.ones((nb_samples, stack_size, input_nb_row, input_nb_col)) # basic test layer_test(convolutional.ZeroPadding2D, kwargs={'padding': (2, 2)}, input_shape=input.shape) layer_test(convolutional.ZeroPadding2D, kwargs={'padding': (1, 2, 3, 4)}, input_shape=input.shape) layer_test(convolutional.ZeroPadding2D, kwargs={'padding': {'top_pad': 1, 'bottom_pad': 2, 'left_pad': 3, 'right_pad': 4}}, input_shape=input.shape) # correctness test layer = convolutional.ZeroPadding2D(padding=(2, 2)) layer.build(input.shape) output = layer(K.variable(input)) np_output = K.eval(output) if dim_ordering == 'tf': for offset in [0, 1, -1, -2]: assert_allclose(np_output[:, offset, :, :], 0.) assert_allclose(np_output[:, :, offset, :], 0.) assert_allclose(np_output[:, 2:-2, 2:-2, :], 1.) elif dim_ordering == 'th': for offset in [0, 1, -1, -2]: assert_allclose(np_output[:, :, offset, :], 0.) assert_allclose(np_output[:, :, :, offset], 0.) assert_allclose(np_output[:, 2:-2, 2:-2, :], 1.) layer = convolutional.ZeroPadding2D(padding=(1, 2, 3, 4)) layer.build(input.shape) output = layer(K.variable(input)) np_output = K.eval(output) if dim_ordering == 'tf': for top_offset in [0]: assert_allclose(np_output[:, top_offset, :, :], 0.) for bottom_offset in [-1, -2]: assert_allclose(np_output[:, bottom_offset, :, :], 0.) for left_offset in [0, 1, 2]: assert_allclose(np_output[:, :, left_offset, :], 0.) for right_offset in [-1, -2, -3, -4]: assert_allclose(np_output[:, :, right_offset, :], 0.) assert_allclose(np_output[:, 1:-2, 3:-4, :], 1.) elif dim_ordering == 'th': for top_offset in [0]: assert_allclose(np_output[:, :, top_offset, :], 0.) for bottom_offset in [-1, -2]: assert_allclose(np_output[:, :, bottom_offset, :], 0.) for left_offset in [0, 1, 2]: assert_allclose(np_output[:, :, :, left_offset], 0.) for right_offset in [-1, -2, -3, -4]: assert_allclose(np_output[:, :, :, right_offset], 0.) assert_allclose(np_output[:, :, 1:-2, 3:-4], 1.) layer.get_config()
def test_globalpooling_1d(): layer_test(pooling.GlobalMaxPooling1D, input_shape=(3, 4, 5)) layer_test(pooling.GlobalAveragePooling1D, input_shape=(3, 4, 5))
def test_GaussianNoise(): layer_test(noise.GaussianNoise, kwargs={'sigma': 1.}, input_shape=(3, 2, 3))
def test_upsampling_3d(): 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: # tf inputs = np.random.rand(num_samples, input_len_dim1, input_len_dim2, input_len_dim3, stack_size) # basic test layer_test(convolutional.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 = convolutional.UpSampling3D(size=(length_dim1, length_dim2, length_dim3), data_format=data_format) layer.build(inputs.shape) outputs = layer(K.variable(inputs)) np_output = K.eval(outputs) 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) assert_allclose(np_output, expected_out)
def test_permute(): layer_test(core.Permute, kwargs={'dims': (2, 1)}, input_shape=(3, 2, 4))
def test_upsampling_1d(): layer_test(convolutional.UpSampling1D, kwargs={'size': 2}, input_shape=(3, 5, 4))
def test_flatten(): layer_test(core.Flatten, kwargs={}, input_shape=(3, 2, 4))
def test_zero_padding_3d(): num_samples = 2 stack_size = 2 input_len_dim1 = 4 input_len_dim2 = 5 input_len_dim3 = 3 inputs = np.ones((num_samples, input_len_dim1, input_len_dim2, input_len_dim3, stack_size)) # basic test for data_format in ['channels_first', 'channels_last']: layer_test(convolutional.ZeroPadding3D, kwargs={ 'padding': (2, 2, 2), 'data_format': data_format }, input_shape=inputs.shape) layer_test(convolutional.ZeroPadding3D, kwargs={ 'padding': ((1, 2), (3, 4), (0, 2)), 'data_format': data_format }, input_shape=inputs.shape) # correctness test layer = convolutional.ZeroPadding3D(padding=(2, 2, 2), data_format=data_format) layer.build(inputs.shape) outputs = layer(K.variable(inputs)) np_output = K.eval(outputs) if data_format == 'channels_last': for offset in [0, 1, -1, -2]: assert_allclose(np_output[:, offset, :, :, :], 0.) assert_allclose(np_output[:, :, offset, :, :], 0.) assert_allclose(np_output[:, :, :, offset, :], 0.) assert_allclose(np_output[:, 2:-2, 2:-2, 2:-2, :], 1.) elif data_format == 'channels_first': for offset in [0, 1, -1, -2]: assert_allclose(np_output[:, :, offset, :, :], 0.) assert_allclose(np_output[:, :, :, offset, :], 0.) assert_allclose(np_output[:, :, :, :, offset], 0.) assert_allclose(np_output[:, :, 2:-2, 2:-2, 2:-2], 1.) layer = convolutional.ZeroPadding3D(padding=((1, 2), (3, 4), (0, 2)), data_format=data_format) layer.build(inputs.shape) outputs = layer(K.variable(inputs)) np_output = K.eval(outputs) if data_format == 'channels_last': for dim1_offset in [0, -1, -2]: assert_allclose(np_output[:, dim1_offset, :, :, :], 0.) for dim2_offset in [0, 1, 2, -1, -2, -3, -4]: assert_allclose(np_output[:, :, dim2_offset, :, :], 0.) for dim3_offset in [-1, -2]: assert_allclose(np_output[:, :, :, dim3_offset, :], 0.) assert_allclose(np_output[:, 1:-2, 3:-4, 0:-2, :], 1.) elif data_format == 'channels_first': for dim1_offset in [0, -1, -2]: assert_allclose(np_output[:, :, dim1_offset, :, :], 0.) for dim2_offset in [0, 1, 2, -1, -2, -3, -4]: assert_allclose(np_output[:, :, :, dim2_offset, :], 0.) for dim3_offset in [-1, -2]: assert_allclose(np_output[:, :, :, :, dim3_offset], 0.) assert_allclose(np_output[:, :, 1:-2, 3:-4, 0:-2], 1.)
def test_lambda(): layer_test(layers.Lambda, kwargs={'function': lambda x: x + 1}, input_shape=(3, 2)) layer_test(layers.Lambda, kwargs={'function': lambda x, a, b: x * a + b, 'arguments': {'a': 0.6, 'b': 0.4}}, input_shape=(3, 2)) def antirectifier(x): x -= K.mean(x, axis=1, keepdims=True) x = K.l2_normalize(x, axis=1) pos = K.relu(x) neg = K.relu(-x) return K.concatenate([pos, neg], axis=1) def antirectifier_output_shape(input_shape): shape = list(input_shape) assert len(shape) == 2 # only valid for 2D tensors shape[-1] *= 2 return tuple(shape) layer_test(layers.Lambda, kwargs={'function': antirectifier, 'output_shape': antirectifier_output_shape}, input_shape=(3, 2)) # test layer with multiple outputs def test_multiple_outputs(): def func(x): return [x * 0.2, x * 0.3] def output_shape(input_shape): return [input_shape, input_shape] def mask(inputs, mask=None): return [None, None] i = layers.Input(shape=(64, 64, 3)) o = layers.Lambda(function=func, output_shape=output_shape, mask=mask)(i) o1, o2 = o assert o1._keras_shape == (None, 64, 64, 3) assert o2._keras_shape == (None, 64, 64, 3) model = Model(i, o) x = np.random.random((4, 64, 64, 3)) out1, out2 = model.predict(x) assert out1.shape == (4, 64, 64, 3) assert out2.shape == (4, 64, 64, 3) assert_allclose(out1, x * 0.2, atol=1e-4) assert_allclose(out2, x * 0.3, atol=1e-4) test_multiple_outputs() # test serialization with function def f(x): return x + 1 ld = layers.Lambda(f) config = ld.get_config() ld = deserialize_layer({'class_name': 'Lambda', 'config': config}) # test with lambda ld = layers.Lambda( lambda x: K.concatenate([K.square(x), x]), output_shape=lambda s: tuple(list(s)[:-1] + [2 * s[-1]])) config = ld.get_config() ld = layers.Lambda.from_config(config) # test serialization with output_shape function def f(x): return K.concatenate([K.square(x), x]) def f_shape(s): return tuple(list(s)[:-1] + [2 * s[-1]]) ld = layers.Lambda(f, output_shape=f_shape) config = ld.get_config() ld = deserialize_layer({'class_name': 'Lambda', 'config': config})