def noisy_identity_kernel_initializer(base_num_channels, stddev=1e-8):
  """Build an initializer for constructing near-identity convolution kernels.

  Construct a convolution kernel where in_channels and out_channels are
  multiples of base_num_channels, but need not be equal. This initializer is
  essentially the same as identity_kernel_initializer, except that magnitude
  is "spread out" across multiple copies of the input.

  Args:
    base_num_channels: int. Number that divides both in_channels and
      out_channels.
    stddev: float. Standard deviation of truncated normal noise added to
      off-entries to break ties.

  Returns:
    Initializer function for building a noisy identity kernel.
  """

  # pylint: disable=unused-argument
  def _noisy_identity_kernel_initializer(shape,
                                         dtype=tf.float32,
                                         partition_info=None):
    """Constructs a noisy identity kernel.

    Args:
      shape: List of integers. Represents shape of result.
      dtype: data type for values in result.
      partition_info: Partition information for initializer functions. Ignored.

    Returns:
      Tensor of desired shape and dtype such that applying it as a convolution
        kernel results in a noisy near-identity operation.

    Raises:
      ValueError: If shape does not define a valid kernel.
                  If filter width and height differ.
                  If filter width and height are not odd numbers.
                  If number of input and output channels are not multiples of
                    base_num_channels.
    """
    if len(shape) != 4:
      raise ValueError("Convolution kernels must be rank 4.")

    filter_height, filter_width, in_channels, out_channels = shape

    if filter_width != filter_height:
      raise ValueError(
          "Noisy identity initializer only works for square filters.")
    if filter_width % 2 != 1:
      raise ValueError(
          "Noisy identity initializer requires filters have odd height and "
          "width.")
    if (in_channels % base_num_channels != 0 or
        out_channels % base_num_channels != 0):
      raise ValueError("in_channels and out_channels must both be multiples of "
                       "base_num_channels.")

    middle_pixel = filter_height // 2
    is_middle_pixel = tf.logical_and(
        tf.equal(_range_along_dimension(0, shape), middle_pixel),
        tf.equal(_range_along_dimension(1, shape), middle_pixel))
    is_same_channel_multiple = tf.equal(
        tf.floordiv(
            _range_along_dimension(2, shape) * base_num_channels, in_channels),
        tf.floordiv(
            _range_along_dimension(3, shape) * base_num_channels, out_channels))
    noise = tf.truncated_normal(shape, stddev=stddev, dtype=dtype)
    return tf.where(
        tf.logical_and(is_same_channel_multiple, is_middle_pixel),
        tf.ones(
            shape, dtype=dtype) * (base_num_channels / out_channels),
        noise)

  return _noisy_identity_kernel_initializer
Build an initializer for constructing near-identity convolution kernels.

  Construct a convolution kernel where in_channels and out_channels are
  multiples of base_num_channels, but need not be equal. This initializer is
  essentially the same as identity_kernel_initializer, except that magnitude
  is "spread out" across multiple copies of the input.

  Args:
    base_num_channels: int. Number that divides both in_channels and
      out_channels.
    stddev: float. Standard deviation of truncated normal noise added to
      off-entries to break ties.

  Returns:
    Initializer function for building a noisy identity kernel.