code: def _create_make_unique(inputs):
      """Replaces the lower bits of each element with iota.
  
      The iota is used to derive the index, and also serves the purpose to
      make each element unique to break ties.
  
      Args:
        inputs: A tensor with rank of 2 and dtype of tf.float32.
          [batch_size, original_size].
  
      Returns:
        A tensor after element wise transformation, with dtype the same as inputs.
        [batch_size, original_size].
  
      Raises:
        ValueError: If the rank of the input tensor does not equal 2.
      """
      if inputs.shape.ndims != 2:
          raise ValueError(
              "Input of top_k_with_unique must be rank-2 "
              "but got: %s" % inputs.shape
          )
  
      height = inputs.shape[0]
      width = inputs.shape[1]
      zeros = tf.zeros([height, width], dtype=tf.int32)
  
      # Count_mask is used to mask away the low order bits to ensure that every
      # element is distinct.
      log2_ceiling = int(math.ceil(math.log(int(width), 2)))
      next_power_of_two = 1 << log2_ceiling
      count_mask = ~(next_power_of_two - 1)
      count_mask_r0 = tf.constant(count_mask)
      count_mask_r2 = tf.fill([height, width], count_mask_r0)
  
      # Smallest_normal is the bit representation of the smallest positive normal
      # floating point number. The sign is zero, exponent is one, and the fraction
      # is zero.
      smallest_normal = 1 << 23
      smallest_normal_r0 = tf.constant(smallest_normal, dtype=tf.int32)
      smallest_normal_r2 = tf.fill([height, width], smallest_normal_r0)
  
      # Low_bit_mask is used to mask away the sign bit when computing the absolute
      # value.
      low_bit_mask = ~(1 << 31)
      low_bit_mask_r0 = tf.constant(low_bit_mask, dtype=tf.int32)
      low_bit_mask_r2 = tf.fill([height, width], low_bit_mask_r0)
  
      iota = tf.tile(
          tf.expand_dims(tf.range(width, dtype=tf.int32), 0),
          [height, 1],
      )
  
      # Compare the absolute value with positive zero to handle negative zero.
      input_r2 = tf.bitcast(inputs, tf.int32)
      abs_r2 = tf.bitwise.bitwise_and(input_r2, low_bit_mask_r2)
      if_zero_r2 = tf.equal(abs_r2, zeros)
      smallest_normal_preserving_sign_r2 = tf.bitwise.bitwise_or(
          input_r2, smallest_normal_r2
      )
      input_no_zeros_r2 = tf.where(
          if_zero_r2, smallest_normal_preserving_sign_r2, input_r2
      )
  
      # Discard the low-order bits and replace with iota.
      and_r2 = tf.bitwise.bitwise_and(input_no_zeros_r2, count_mask_r2)
      or_r2 = tf.bitwise.bitwise_or(and_r2, iota)
      return tf.bitcast(or_r2, tf.float32)
  
file_path: tensor2tensor/tensor2tensor/utils/beam_search.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import math
  import numpy
  from tensor2tensor.layers import common_layers
  import tensorflow.compat.v1
  from tensorflow.python.ops import inplace_ops
  from tensorflow.python.util import nest
label_desc: Use image node_id 7 for calling a global function with example usage: _create_make_unique(inputs) and returns: tf