class_docstr: E2E module.
  
  Args:
      idim (int): Input dimmensions.
      odim (int): Output dimmensions.
      args (Namespace): Training config.
      ignore_id (int, optional): Id for ignoring a character.
      flag_return (bool, optional): If true, return a list with (loss,
      loss_ctc, loss_att, acc) in forward. Otherwise, return loss.
class_docstr_tok: ["E2E","module",".","Args",":","idim","(","int",")",":","Input","dimmensions",".","odim","(","int",")",":","Output","dimmensions",".","args","(","Namespace",")",":","Training","config",".","ignore_id","(","int",",","optional",")",":","Id","for","ignoring","a","character",".","flag_return","(","bool",",","optional",")",":","If","true",",","return","a","list","with","(","loss",",","loss_ctc",",","loss_att",",","acc",")","in","forward",".","Otherwise",",","return","loss","."]
docstr: E2E beam search.
  
  Args:
      h (ndarray): Encoder output features (B, T, D) or (T, D).
      lpz (ndarray): Log probabilities from CTC.
      recog_args (Namespace): Argment namespace contraining options.
      char_list (List[str]): List of characters.
      rnnlm (chainer.Chain): Language model module defined at
      `espnet.lm.chainer_backend.lm`.
  
  Returns:
      List: N-best decoding results.
docstr_tok: ["E2E","beam","search",".","Args",":","h","(","ndarray",")",":","Encoder","output","features","(","B",",","T",",","D",")","or","(","T",",","D",")",".","lpz","(","ndarray",")",":","Log","probabilities","from","CTC",".","recog_args","(","Namespace",")",":","Argment","namespace","contraining","options",".","char_list","(","List","[","str","]",")",":","List","of","characters",".","rnnlm","(","chainer.Chain",")",":","Language","model","module","defined","at","`","espnet.lm.chainer_backend.lm","`",".","Returns",":","List",":","N-best","decoding","results","."]
code: def recognize_beam(
      self, h, lpz, recog_args, char_list=None, rnnlm=None
  ):
      """E2E beam search.
  
      Args:
          h (ndarray): Encoder output features (B, T, D) or (T, D).
          lpz (ndarray): Log probabilities from CTC.
          recog_args (Namespace): Argment namespace contraining options.
          char_list (List[str]): List of characters.
          rnnlm (chainer.Chain): Language model module defined at
          `espnet.lm.chainer_backend.lm`.
  
      Returns:
          List: N-best decoding results.
  
      """
      logging.info("input lengths: " + str(h.shape[1]))
  
      # initialization
      n_len = h.shape[1]
      xp = self.xp
      h_mask = xp.ones((1, n_len))
  
      # search parms
      beam = recog_args.beam_size
      penalty = recog_args.penalty
      ctc_weight = recog_args.ctc_weight
  
      # prepare sos
      y = self.sos
      if recog_args.maxlenratio == 0:
          maxlen = n_len
      else:
          maxlen = max(1, int(recog_args.maxlenratio * n_len))
      minlen = int(recog_args.minlenratio * n_len)
      logging.info("max output length: " + str(maxlen))
      logging.info("min output length: " + str(minlen))
  
      # initialize hypothesis
      if rnnlm:
          hyp = {"score": 0.0, "yseq": [y], "rnnlm_prev": None}
      else:
          hyp = {"score": 0.0, "yseq": [y]}
  
      if lpz is not None:
          ctc_prefix_score = CTCPrefixScore(lpz, 0, self.eos, self.xp)
          hyp["ctc_state_prev"] = ctc_prefix_score.initial_state()
          hyp["ctc_score_prev"] = 0.0
          if ctc_weight != 1.0:
              # pre-pruning based on attention scores
              ctc_beam = min(
                  lpz.shape[-1], int(beam * CTC_SCORING_RATIO)
              )
          else:
              ctc_beam = lpz.shape[-1]
  
      hyps = [hyp]
      ended_hyps = []
  
      for i in range(maxlen):
          logging.debug("position " + str(i))
  
          hyps_best_kept = []
          for hyp in hyps:
              ys = F.expand_dims(xp.array(hyp["yseq"]), axis=0).data
              out = self.decoder(ys, h, h_mask)
  
              # get nbest local scores and their ids
              local_att_scores = F.log_softmax(out[:, -1], axis=-1).data
              if rnnlm:
                  rnnlm_state, local_lm_scores = rnnlm.predict(
                      hyp["rnnlm_prev"], hyp["yseq"][i]
                  )
                  local_scores = (
                      local_att_scores
                      + recog_args.lm_weight * local_lm_scores
                  )
              else:
                  local_scores = local_att_scores
  
              if lpz is not None:
                  local_best_ids = xp.argsort(local_scores, axis=1)[
                      0, ::-1
                  ][:ctc_beam]
                  ctc_scores, ctc_states = ctc_prefix_score(
                      hyp["yseq"], local_best_ids, hyp["ctc_state_prev"]
                  )
                  local_scores = (1.0 - ctc_weight) * local_att_scores[
                      :, local_best_ids
                  ] + ctc_weight * (ctc_scores - hyp["ctc_score_prev"])
                  if rnnlm:
                      local_scores += (
                          recog_args.lm_weight
                          * local_lm_scores[:, local_best_ids]
                      )
                  joint_best_ids = xp.argsort(local_scores, axis=1)[
                      0, ::-1
                  ][:beam]
                  local_best_scores = local_scores[:, joint_best_ids]
                  local_best_ids = local_best_ids[joint_best_ids]
              else:
                  local_best_ids = self.xp.argsort(
                      local_scores, axis=1
                  )[0, ::-1][:beam]
                  local_best_scores = local_scores[:, local_best_ids]
  
              for j in range(beam):
                  new_hyp = {}
                  new_hyp["score"] = hyp["score"] + float(
                      local_best_scores[0, j]
                  )
                  new_hyp["yseq"] = [0] * (1 + len(hyp["yseq"]))
                  new_hyp["yseq"][: len(hyp["yseq"])] = hyp["yseq"]
                  new_hyp["yseq"][len(hyp["yseq"])] = int(
                      local_best_ids[j]
                  )
                  if rnnlm:
                      new_hyp["rnnlm_prev"] = rnnlm_state
                  if lpz is not None:
                      new_hyp["ctc_state_prev"] = ctc_states[
                          joint_best_ids[j]
                      ]
                      new_hyp["ctc_score_prev"] = ctc_scores[
                          joint_best_ids[j]
                      ]
                  hyps_best_kept.append(new_hyp)
  
              hyps_best_kept = sorted(
                  hyps_best_kept, key=lambda x: x["score"], reverse=True
              )[:beam]
  
          # sort and get nbest
          hyps = hyps_best_kept
          logging.debug(
              "number of pruned hypothesis: " + str(len(hyps))
          )
          if char_list is not None:
              logging.debug(
                  "best hypo: "
                  + "".join(
                      [char_list[int(x)] for x in hyps[0]["yseq"][1:]]
                  )
                  + " score: "
                  + str(hyps[0]["score"])
              )
  
          # add eos in the final loop to avoid that there are no ended hyps
          if i == maxlen - 1:
              logging.info(
                  "adding <eos> in the last position in the loop"
              )
              for hyp in hyps:
                  hyp["yseq"].append(self.eos)
  
          # add ended hypothes to a final list, and removed them from current hypothes
          # (this will be a probmlem, number of hyps < beam)
          remained_hyps = []
          for hyp in hyps:
              if hyp["yseq"][-1] == self.eos:
                  # only store the sequence that has more than minlen outputs
                  # also add penalty
                  if len(hyp["yseq"]) > minlen:
                      hyp["score"] += (i + 1) * penalty
                      if (
                          rnnlm
                      ):  # Word LM needs to add final <eos> score
                          hyp[
                              "score"
                          ] += recog_args.lm_weight * rnnlm.final(
                              hyp["rnnlm_prev"]
                          )
                      ended_hyps.append(hyp)
              else:
                  remained_hyps.append(hyp)
  
          # end detection
          if (
              end_detect(ended_hyps, i)
              and recog_args.maxlenratio == 0.0
          ):
              logging.info("end detected at %d", i)
              break
  
          hyps = remained_hyps
          if len(hyps) > 0:
              logging.debug("remained hypothes: " + str(len(hyps)))
          else:
              logging.info("no hypothesis. Finish decoding.")
              break
          if char_list is not None:
              for hyp in hyps:
                  logging.debug(
                      "hypo: "
                      + "".join(
                          [char_list[int(x)] for x in hyp["yseq"][1:]]
                      )
                  )
  
          logging.debug(
              "number of ended hypothes: " + str(len(ended_hyps))
          )
  
      nbest_hyps = sorted(
          ended_hyps, key=lambda x: x["score"], reverse=True
      )  # [:min(len(ended_hyps), recog_args.nbest)]
  
      logging.debug(nbest_hyps)
      # check number of hypotheis
      if len(nbest_hyps) == 0:
          logging.warn(
              "there is no N-best results, perform recognition "
              "again with smaller minlenratio."
          )
          # should copy becasuse Namespace will be overwritten globally
          recog_args = Namespace(**vars(recog_args))
          recog_args.minlenratio = max(
              0.0, recog_args.minlenratio - 0.1
          )
          return self.recognize_beam(
              h, lpz, recog_args, char_list, rnnlm
          )
  
      logging.info(
          "total log probability: " + str(nbest_hyps[0]["score"])
      )
      logging.info(
          "normalized log probability: "
          + str(nbest_hyps[0]["score"] / len(nbest_hyps[0]["yseq"]))
      )
      # remove sos
      return nbest_hyps
  
imports: import logging
  import math
  from argparse import Namespace
  from distutils.util import strtobool
  import chainer
  import chainer.functions
  import numpy
  from chainer import reporter
  from espnet.nets.chainer_backend.asr_interface import ChainerASRInterface
  from espnet.nets.chainer_backend.transformer import ctc
  from espnet.nets.chainer_backend.transformer.attention import MultiHeadAttention
  from espnet.nets.chainer_backend.transformer.decoder import Decoder
  from espnet.nets.chainer_backend.transformer.encoder import Encoder
  from espnet.nets.chainer_backend.transformer.label_smoothing_loss import LabelSmoothingLoss
  from espnet.nets.chainer_backend.transformer.training import CustomConverter, CustomParallelUpdater, CustomUpdater
  from espnet.nets.ctc_prefix_score import CTCPrefixScore
  from espnet.nets.e2e_asr_common import ErrorCalculator, end_detect
  from espnet.nets.pytorch_backend.nets_utils import get_subsample
  from espnet.nets.pytorch_backend.transformer.plot import PlotAttentionReport
label_desc: Use image node_id 8 for calling the E2E obj's underlying member method code with example usage: obj.recognize_beam(h, lpz, recog_args, char_list, rnnlm) and returns: nbest_hyps, self