class_docstr: A greedy CTC decoder.
  
  Provides a common abstraction for sample level and batch level greedy decoding.
  
  Args:
      blank_index: int index of the blank token. Can be 0 or len(vocabulary).
      preserve_alignments: Bool flag which preserves the history of logprobs generated during
          decoding (sample / batched). When set to true, the Hypothesis will contain
          the non-null value for `logprobs` in it. Here, `logprobs` is a torch.Tensors.
      compute_timestamps: A bool flag, which determines whether to compute the character/subword, or
              word based timestamp mapping the output log-probabilities to discrite intervals of timestamps.
              The timestamps will be available in the returned Hypothesis.timestep as a dictionary.
      preserve_frame_confidence: Bool flag which preserves the history of per-frame confidence scores
          generated during decoding. When set to true, the Hypothesis will contain
          the non-null value for `frame_confidence` in it. Here, `frame_confidence` is a List of floats.
      confidence_method_cfg: A dict-like object which contains the method name and settings to compute per-frame
          confidence scores.
  
          name: The method name (str).
              Supported values:
                  - 'max_prob' for using the maximum token probability as a confidence.
                  - 'entropy' for using a normalized entropy of a log-likelihood vector.
  
          entropy_type: Which type of entropy to use (str). Used if confidence_method_cfg.name is set to `entropy`.
              Supported values:
                  - 'gibbs' for the (standard) Gibbs entropy. If the alpha (α) is provided,
                      the formula is the following: H_α = -sum_i((p^α_i)*log(p^α_i)).
                      Note that for this entropy, the alpha should comply the following inequality:
                      (log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)
                      where V is the model vocabulary size.
                  - 'tsallis' for the Tsallis entropy with the Boltzmann constant one.
                      Tsallis entropy formula is the following: H_α = 1/(α-1)*(1-sum_i(p^α_i)),
                      where α is a parameter. When α == 1, it works like the Gibbs entropy.
                      More: https://en.wikipedia.org/wiki/Tsallis_entropy
                  - 'renyi' for the Rényi entropy.
                      Rényi entropy formula is the following: H_α = 1/(1-α)*log_2(sum_i(p^α_i)),
                      where α is a parameter. When α == 1, it works like the Gibbs entropy.
                      More: https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy
  
          alpha: Power scale for logsoftmax (α for entropies). Here we restrict it to be > 0.
              When the alpha equals one, scaling is not applied to 'max_prob',
              and any entropy type behaves like the Shannon entropy: H = -sum_i(p_i*log(p_i))
  
          entropy_norm: A mapping of the entropy value to the interval [0,1].
              Supported values:
                  - 'lin' for using the linear mapping.
                  - 'exp' for using exponential mapping with linear shift.
code: def __call__(self, *args, **kwargs):
      return self.forward(*args, **kwargs)
  
imports: from dataclasses import dataclass, field
  from typing import List, Optional
  import torch
  from omegaconf import DictConfig, OmegaConf
  from nemo.collections.asr.parts.utils import rnnt_utils
  from nemo.collections.asr.parts.utils.asr_confidence_utils import ConfidenceMethodConfig, ConfidenceMethodMixin
  from nemo.core.classes import Typing, typecheck
  from nemo.core.neural_types import HypothesisType, LengthsType, LogprobsType, NeuralType
  from nemo.utils import logging
label_desc: Use image node_id 7 for calling the GreedyCTCInfer obj's underlying member method code with example usage: obj.__call__() and returns: self