code: def _to_term_frequency(
      x: tf.SparseTensor, vocab_size: Union[int, tf.Tensor]
  ) -> tf.SparseTensor:
      """Creates a SparseTensor of term frequency for every doc/term pair.
  
      Args:
        x : a SparseTensor of int64 representing string indices in vocab.
        vocab_size: A scalar int64 Tensor - the count of vocab used to turn the
            string into int64s including any OOV buckets.
  
      Returns:
        a SparseTensor with the count of times a term appears in a document at
            indices <doc_index_in_batch>, <term_index_in_vocab>,
            with size (num_docs_in_batch, vocab_size).
      """
      # Construct intermediary sparse tensor with indices
      # [<doc>, <term_index_in_doc>, <vocab_id>] and tf.ones values.
      vocab_size = tf.convert_to_tensor(
          value=vocab_size, dtype=tf.int64
      )
      split_indices = tf.cast(
          tf.split(x.indices, axis=1, num_or_size_splits=2),
          dtype=tf.int64,
      )
      expanded_values = tf.cast(
          tf.expand_dims(x.values, 1), dtype=tf.int64
      )
      next_index = tf.concat(
          [split_indices[0], split_indices[1], expanded_values], axis=1
      )
  
      next_values = tf.ones_like(x.values)
      expanded_vocab_size = tf.expand_dims(vocab_size, 0)
      next_shape = tf.concat([x.dense_shape, expanded_vocab_size], 0)
  
      next_tensor = tf.SparseTensor(
          indices=tf.cast(next_index, dtype=tf.int64),
          values=next_values,
          dense_shape=next_shape,
      )
  
      # Take the intermediary tensor and reduce over the term_index_in_doc
      # dimension. This produces a tensor with indices [<doc_id>, <term_id>]
      # and values [count_of_term_in_doc] and shape batch x vocab_size
      term_count_per_doc = tf.compat.v1.sparse_reduce_sum_sparse(
          next_tensor, 1
      )
  
      dense_doc_sizes = tf.cast(
          tf.sparse.reduce_sum(
              tf.SparseTensor(
                  indices=x.indices,
                  values=tf.ones_like(x.values),
                  dense_shape=x.dense_shape,
              ),
              1,
          ),
          dtype=tf.float64,
      )
  
      gather_indices = term_count_per_doc.indices[:, 0]
      gathered_doc_sizes = tf.gather(dense_doc_sizes, gather_indices)
  
      term_frequency = tf.cast(
          term_count_per_doc.values, dtype=tf.float64
      ) / tf.cast(gathered_doc_sizes, dtype=tf.float64)
      return tf.SparseTensor(
          indices=term_count_per_doc.indices,
          values=term_frequency,
          dense_shape=term_count_per_doc.dense_shape,
      )
  
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 15 for calling a global function with example usage: _to_term_frequency(x, vocab_size) and returns: tf