code: def deduplicate_tensor_per_row(input_tensor, name=None):
      """Deduplicates each row (0-th dimension) of the provided tensor.
  
      Args:
        input_tensor: A two-dimensional `Tensor` or `SparseTensor`. The first
          dimension is assumed to be the batch or "row" dimension, and deduplication
          is done on the 2nd dimension. If the Tensor is 1D it is returned as the
          equivalent `SparseTensor` since the "row" is a scalar can't be further
          deduplicated.
        name: Optional name for the operation.
  
      Returns:
        A  `SparseTensor` containing the unique set of values from each
          row of the input. Note: the original order of the input may not be
          preserved.
      """
      with tf.compat.v1.name_scope(name, "deduplicate_per_row"):
          if isinstance(input_tensor, tf.SparseTensor):
              batch_dim = tf.cast(input_tensor.dense_shape[0], tf.int32)
              rank = input_tensor.dense_shape.shape[0]
          else:
              batch_dim = tf.cast(tf.shape(input_tensor)[0], tf.int32)
              rank = input_tensor.shape.rank
  
          def _univalent_dense_to_sparse(batch_dim, input_tensor):
              """Helper to convert a 1D dense `Tensor` to a `SparseTensor`."""
              indices = tf.cast(
                  tf.stack(
                      [
                          tf.range(batch_dim, dtype=tf.int32),
                          tf.zeros(batch_dim, dtype=tf.int32),
                      ],
                      axis=1,
                  ),
                  dtype=tf.int64,
              )
  
              return tf.SparseTensor(
                  indices=indices,
                  values=input_tensor,
                  dense_shape=(batch_dim, 1),
              )
  
          if rank is not None:
              # If the rank is known at graph construction time, and it's rank 1, there
              # is no deduplication to be done so we can return early.
              if rank <= 1:
                  if isinstance(input_tensor, tf.SparseTensor):
                      return input_tensor
                  # Even though we are just returning as is, we convert to a SparseTensor
                  # to ensure consistent output type.
                  return _univalent_dense_to_sparse(
                      batch_dim, input_tensor
                  )
              if rank > 2:
                  raise ValueError(
                      "Deduplication assumes a rank 2 tensor, got {}.".format(
                          rank
                      )
                  )
              return _deduplicate_tensor_per_row(
                  input_tensor, batch_dim
              )
  
          if isinstance(input_tensor, tf.SparseTensor):
              return _deduplicate_tensor_per_row(
                  input_tensor, batch_dim
              )
          else:
              # Again check for rank 1 tensor (that doesn't need deduplication), this
              # time handling inputs where rank isn't known until execution time.
              dynamic_rank = tf.rank(input_tensor)
              return tf.cond(
                  tf.equal(dynamic_rank, 1),
                  lambda: _univalent_dense_to_sparse(
                      batch_dim, input_tensor
                  ),
                  lambda: _deduplicate_tensor_per_row(
                      input_tensor, batch_dim
                  ),
              )
  
imports: import os
  from typing import Any, Callable, Iterable, Optional, Tuple, Union
  import tensorflow
  from tensorflow_transform import analyzers
  from tensorflow_transform import common
  from tensorflow_transform import common_types
  from tensorflow_transform import gaussianization
  from tensorflow_transform import schema_inference
  from tensorflow_transform import tf_utils
  from tfx_bsl.types import tfx_namedtuple
label_desc: Use image node_id 24 for calling a global function with example usage: deduplicate_tensor_per_row(input_tensor, name) and returns: tf, _deduplicate_tensor_per_row, _deduplicate_tensor_per_row, tf, _univalent_dense_to_sparse, input_tensor