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 as tf  # pylint: disable=g-import-not-at-top,redefined-outer-name
      tfd = tf.contrib.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}):
      with self.test_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_locallyconnected_2d(self):
    with self.cached_session():
      num_samples = 8
      filters = 3
      stack_size = 4
      num_row = 6
      num_col = 10

      for padding in ['valid', 'same']:
        for strides in [(1, 1), (2, 2)]:
          for implementation in [1, 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': 'channels_last',
                '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_cudnn_rnn_basics(self):
   if test.is_gpu_available(cuda_only=True):
     with self.test_session(use_gpu=True):
       input_size = 10
       timesteps = 6
       units = 2
       num_samples = 32
       for layer_class in [keras.layers.CuDNNGRU, keras.layers.CuDNNLSTM]:
         for return_sequences in [True, False]:
           with keras.utils.CustomObjectScope(
               {'keras.layers.CuDNNGRU': keras.layers.CuDNNGRU,
                'keras.layers.CuDNNLSTM': keras.layers.CuDNNLSTM}):
             testing_utils.layer_test(
                 layer_class,
                 kwargs={'units': units,
                         'return_sequences': return_sequences},
                 input_shape=(num_samples, timesteps, input_size))
         for go_backwards in [True, False]:
           with keras.utils.CustomObjectScope(
               {'keras.layers.CuDNNGRU': keras.layers.CuDNNGRU,
                'keras.layers.CuDNNLSTM': keras.layers.CuDNNLSTM}):
             testing_utils.layer_test(
                 layer_class,
                 kwargs={'units': units,
                         'go_backwards': go_backwards},
                 input_shape=(num_samples, timesteps, input_size))

  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
    })

    # test with lambda
    ld = keras.layers.Lambda(
        lambda x: keras.backend.concatenate([math_ops.square(x), x]))
    config = ld.get_config()
    ld = keras.layers.Lambda.from_config(config)

  def test_locallyconnected_1d(self):
    with self.cached_session():
      num_samples = 2
      num_steps = 8
      input_dim = 5
      filter_length = 3
      filters = 4

      for padding in ['valid', 'same']:
        for strides in [1]:
          if padding == 'same' and strides != 1:
            continue
          for data_format in ['channels_first', 'channels_last']:
            for implementation in [1, 2]:
              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_spatial_dropout(self):
    testing_utils.layer_test(
        keras.layers.SpatialDropout1D,
        kwargs={'rate': 0.5},
        input_shape=(2, 3, 4))

    testing_utils.layer_test(
        keras.layers.SpatialDropout2D,
        kwargs={'rate': 0.5},
        input_shape=(2, 3, 4, 5))

    testing_utils.layer_test(
        keras.layers.SpatialDropout2D,
        kwargs={'rate': 0.5, 'data_format': 'channels_first'},
        input_shape=(2, 3, 4, 5))

    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_basic_batchnorm(self):
   testing_utils.layer_test(
       keras.layers.BatchNormalization,
       kwargs={
           'momentum': 0.9,
           'epsilon': 0.1,
           '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.BatchNormalization,
       kwargs={
           'gamma_initializer': 'ones',
           'beta_initializer': 'ones',
           'moving_mean_initializer': 'zeros',
           'moving_variance_initializer': 'ones'
       },
       input_shape=(3, 4, 2))
   testing_utils.layer_test(
       keras.layers.BatchNormalization,
       kwargs={'scale': False,
               'center': False},
       input_shape=(3, 3))
   testing_utils.layer_test(
       normalization.BatchNormalizationV2,
       kwargs={'fused': True},
       input_shape=(3, 3, 3, 3))
   testing_utils.layer_test(
       normalization.BatchNormalizationV2,
       kwargs={'fused': None},
       input_shape=(3, 3, 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 context.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_relu_with_invalid_arg(self):
   with self.assertRaisesRegexp(
       ValueError, 'max_value of Relu layer cannot be negative value: -10'):
     with self.test_session():
       testing_utils.layer_test(keras.layers.ReLU,
                                kwargs={'max_value': -10},
                                input_shape=(2, 3, 4))

  def test_locallyconnected_2d_channels_first(self):
    with self.cached_session():
      num_samples = 8
      filters = 3
      stack_size = 4
      num_row = 6
      num_col = 10

      for implementation in [1, 2]:
        for padding in ['valid', 'same']:
          kwargs = {
              'filters': filters,
              'kernel_size': 3,
              'data_format': 'channels_first',
              'implementation': implementation,
              'padding': padding
          }

          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_averagepooling_1d(self):
   for padding in ['valid', 'same']:
     for stride in [1, 2]:
       testing_utils.layer_test(
           keras.layers.AveragePooling1D,
           kwargs={'strides': stride,
                   'padding': padding},
           input_shape=(3, 5, 4))

 def test_basic_batchnorm_v2(self):
   testing_utils.layer_test(
       normalization.BatchNormalizationV2,
       kwargs={'fused': True},
       input_shape=(3, 3, 3, 3))
   testing_utils.layer_test(
       normalization.BatchNormalizationV2,
       kwargs={'fused': None},
       input_shape=(3, 3, 3))

  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 _run_test(self, kwargs):
    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))

 def test_implementation_mode_GRU(self, implementation_mode):
   num_samples = 2
   timesteps = 3
   embedding_dim = 4
   units = 2
   testing_utils.layer_test(
       keras.layers.UnifiedGRU,
       kwargs={'units': units,
               'implementation': implementation_mode},
       input_shape=(num_samples, timesteps, embedding_dim))

 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_return_sequences_GRU(self):
   num_samples = 2
   timesteps = 3
   embedding_dim = 4
   units = 2
   testing_utils.layer_test(
       keras.layers.GRU,
       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.test_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 context.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 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))