class_docstr: ASR model wrapper to perform alignment building.
  Functionality is limited to the components needed to build an alignment.
docstr: Builds time alignment of an encoded sequence.
  This method assumes that the RNNT model is used.
  
  It produces a list of sample ids and fours: (label, start_frame, length, probability), called FrameCtmUnit.
docstr_tok: ["Builds","time","alignment","of","an","encoded","sequence",".","This","method","assumes","that","the","RNNT","model","is","used",".","It","produces","a","list","of","sample","ids","and","fours",":","(","label",",","start_frame",",","length",",","probability",")",",","called","FrameCtmUnit","."]
code: def _predict_impl_rnnt(
      self,
      encoded: torch.Tensor,
      encoded_len: torch.Tensor,
      transcript: torch.Tensor,
      transcript_len: torch.Tensor,
      sample_id: torch.Tensor,
  ) -> List[Tuple[int, "FrameCtmUnit"]]:
      """Builds time alignment of an encoded sequence.
      This method assumes that the RNNT model is used.
  
      It produces a list of sample ids and fours: (label, start_frame, length, probability), called FrameCtmUnit.
      """
      if self.alignment_type == "argmax":
          return self._predict_impl_rnnt_argmax(
              encoded,
              encoded_len,
              transcript,
              transcript_len,
              sample_id,
          )
      elif self.alignment_type == "forced":
          decoded = self._model.decoder(
              targets=transcript, target_length=transcript_len
          )[0]
          log_probs = (
              self._rnnt_joint_pruned(
                  encoded, encoded_len, decoded, transcript_len
              )
              if self.predictor_window_size > 0
              and self.predictor_window_size < transcript_len.max()
              else self._model.joint(
                  encoder_outputs=encoded, decoder_outputs=decoded
              )
          )
          apply_log_softmax = (
              True
              if self.log_softmax is None and encoded.is_cuda
              else self.log_softmax
          )
          if apply_log_softmax:
              log_probs = log_probs.log_softmax(dim=-1)
          if self.cpu_decoding:
              log_probs, encoded_len, transcript, transcript_len = (
                  log_probs.cpu(),
                  encoded_len.cpu(),
                  transcript.cpu(),
                  transcript_len.cpu(),
              )
          predictions, probs = self.graph_decoder.align(
              log_probs, encoded_len, transcript, transcript_len
          )
          return [
              self._results_to_ctmUnits(s_id, pred, prob)
              for s_id, pred, prob in zip(
                  sample_id.tolist(), predictions, probs
              )
          ]
      else:
          raise NotImplementedError()
  
imports: import copy
  import os
  from typing import Dict, List, Optional, Tuple, Union
  import numpy
  import torch
  from omegaconf import DictConfig, OmegaConf, open_dict
  from tqdm.auto import tqdm
  from nemo.collections.asr.data.audio_to_ctm_dataset import FrameCtmUnit
  from nemo.collections.asr.data.audio_to_text_dali import DALIOutputs
  from nemo.collections.asr.models.asr_model import ASRModel
  from nemo.utils import logging
label_desc: Use image node_id 13 for calling the AlignerWrapperModel obj's underlying member method code with example usage: obj._predict_impl_rnnt(encoded, encoded_len, transcript, transcript_len, sample_id) and returns: self, unknown