code: def conv2d_fixed_padding(
      inputs,
      filters,
      kernel_size,
      strides,
      data_format="channels_first",
      use_td=False,
      targeting_rate=None,
      keep_prob=None,
      is_training=None,
  ):
      """Strided 2-D convolution with explicit padding.
  
      The padding is consistent and is based only on `kernel_size`, not on the
      dimensions of `inputs` (as opposed to using `tf.layers.conv2d` alone).
  
      Args:
        inputs: `Tensor` of size `[batch, channels, height_in, width_in]`.
        filters: `int` number of filters in the convolution.
        kernel_size: `int` size of the kernel to be used in the convolution.
        strides: `int` strides of the convolution.
        data_format: `str` either "channels_first" for `[batch, channels, height,
            width]` or "channels_last for `[batch, height, width, channels]`.
        use_td: `str` one of "weight" or "unit". Set to False or "" to disable
          targeted dropout.
        targeting_rate: `float` proportion of weights to target with targeted
          dropout.
        keep_prob: `float` keep probability for targeted dropout.
        is_training: `bool` for whether the model is in training.
  
      Returns:
        A `Tensor` of shape `[batch, filters, height_out, width_out]`.
  
      Raises:
        Exception: if use_td is not valid.
      """
      if strides > 1:
          inputs = fixed_padding(
              inputs, kernel_size, data_format=data_format
          )
  
      if use_td:
          inputs_shape = common_layers.shape_list(inputs)
          if use_td == "weight":
              if data_format == "channels_last":
                  size = kernel_size * kernel_size * inputs_shape[-1]
              else:
                  size = kernel_size * kernel_size * inputs_shape[1]
              targeting_count = targeting_rate * tf.to_float(size)
              targeting_fn = common_layers.weight_targeting
          elif use_td == "unit":
              targeting_count = targeting_rate * filters
              targeting_fn = common_layers.unit_targeting
          else:
              raise Exception(
                  "Unrecognized targeted dropout type: %s" % use_td
              )
  
          y = common_layers.td_conv(
              inputs,
              filters,
              kernel_size,
              targeting_count,
              targeting_fn,
              keep_prob,
              is_training,
              do_prune=True,
              strides=strides,
              padding=("SAME" if strides == 1 else "VALID"),
              data_format=data_format,
              use_bias=False,
              kernel_initializer=tf.variance_scaling_initializer(),
          )
      else:
          y = layers().Conv2D(
              filters=filters,
              kernel_size=kernel_size,
              strides=strides,
              padding=("SAME" if strides == 1 else "VALID"),
              use_bias=False,
              kernel_initializer=tf.variance_scaling_initializer(),
              data_format=data_format,
          )(inputs)
  
      return y
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from tensor2tensor.layers import common_hparams
  from tensor2tensor.layers import common_layers
  from tensor2tensor.utils import hparam
  from tensor2tensor.utils import registry
  from tensor2tensor.utils import t2t_model
  import tensorflow.compat.v1
  from tensorflow.compat.v1 import estimator
label_desc: Use image node_id 4 for calling a global function with example usage: conv2d_fixed_padding(inputs, filters, kernel_size, strides, data_format, use_td, targeting_rate, keep_prob, is_training) and returns: y