code: def crf_decode(
      potentials: TensorLike,
      transition_params: TensorLike,
      sequence_length: TensorLike,
  ) -> Tuple[tf.Tensor, tf.Tensor, tf.Tensor]:
      """Decode the highest scoring sequence of tags.
  
      Args:
        potentials: A [batch_size, max_seq_len, num_tags] tensor of
                  unary potentials.
        transition_params: A [num_tags, num_tags] matrix of
                  binary potentials.
        sequence_length: A [batch_size] vector of true sequence lengths.
  
      Returns:
        decode_tags: A [batch_size, max_seq_len] matrix, with dtype `tf.int32`.
                    Contains the highest scoring tag indices.
        decode_scores: A [batch_size, max_seq_len] matrix, containing the score of
                      `decode_tags`.
        best_score: A [batch_size] vector, containing the best score of `decode_tags`.
      """
      sequence_length = tf.cast(sequence_length, dtype=tf.int32)
  
      # If max_seq_len is 1, we skip the algorithm and simply return the
      # argmax tag and the max activation.
      def _single_seq_fn() -> Tuple[tf.Tensor, tf.Tensor, tf.Tensor]:
          decode_tags = tf.cast(
              tf.argmax(potentials, axis=2), dtype=tf.int32
          )
          decode_scores = tf.reduce_max(
              tf.nn.softmax(potentials, axis=2), axis=2
          )
          best_score = tf.reshape(
              tf.reduce_max(potentials, axis=2), shape=[-1]
          )
          return decode_tags, decode_scores, best_score
  
      def _multi_seq_fn() -> Tuple[tf.Tensor, tf.Tensor, tf.Tensor]:
          # Computes forward decoding. Get last score and backpointers.
          initial_state = tf.slice(potentials, [0, 0, 0], [-1, 1, -1])
          initial_state = tf.squeeze(initial_state, axis=[1])
          inputs = tf.slice(potentials, [0, 1, 0], [-1, -1, -1])
  
          sequence_length_less_one = tf.maximum(
              tf.constant(0, dtype=tf.int32), sequence_length - 1
          )
  
          output, last_score = crf_decode_forward(
              inputs,
              initial_state,
              transition_params,
              sequence_length_less_one,
          )
  
          # output is a matrix of size [batch-size, max-seq-length, num-tags * 2]
          # split the matrix on axis 2 to get the backpointers and scores, which are
          # both of size [batch-size, max-seq-length, num-tags]
          backpointers, scores = tf.split(output, 2, axis=2)
  
          backpointers = tf.cast(backpointers, dtype=tf.int32)
          backpointers = tf.reverse_sequence(
              backpointers, sequence_length_less_one, seq_axis=1
          )
  
          scores = tf.reverse_sequence(
              scores, sequence_length_less_one, seq_axis=1
          )
  
          initial_state = tf.cast(
              tf.argmax(last_score, axis=1), dtype=tf.int32
          )
          initial_state = tf.expand_dims(initial_state, axis=-1)
  
          initial_score = tf.reduce_max(
              tf.nn.softmax(last_score, axis=1), axis=[1]
          )
          initial_score = tf.expand_dims(initial_score, axis=-1)
  
          decode_tags, decode_scores = crf_decode_backward(
              backpointers, scores, initial_state
          )
  
          decode_tags = tf.squeeze(decode_tags, axis=[2])
          decode_tags = tf.concat([initial_state, decode_tags], axis=1)
          decode_tags = tf.reverse_sequence(
              decode_tags, sequence_length, seq_axis=1
          )
  
          decode_scores = tf.squeeze(decode_scores, axis=[2])
          decode_scores = tf.concat(
              [initial_score, decode_scores], axis=1
          )
          decode_scores = tf.reverse_sequence(
              decode_scores, sequence_length, seq_axis=1
          )
  
          best_score = tf.reduce_max(last_score, axis=1)
  
          return decode_tags, decode_scores, best_score
  
      if potentials.shape[1] is not None:
          # shape is statically know, so we just execute
          # the appropriate code path
          if potentials.shape[1] == 1:
              return _single_seq_fn()
  
          return _multi_seq_fn()
  
      return tf.cond(
          tf.equal(tf.shape(potentials)[1], 1),
          _single_seq_fn,
          _multi_seq_fn,
      )
  
imports: import tensorflow
  from tensorflow import TensorShape
  from tensorflow.types.experimental import TensorLike
  from typing import Tuple, Any, List, Union, Optional
label_desc: Use image node_id 3 for calling a global function with example usage: crf_decode(potentials, transition_params, sequence_length) and returns: tf, decode_tags,  decode_scores,  best_score, decode_tags,  decode_scores,  best_score, _multi_seq_fn, _single_seq_fn