class_docstr: @property
  def input_types(self):
      """Returns definitions of module input ports.
      """
      return {
          "log_probs": NeuralType(('B', 'T', 'D'), LogprobsType()),
      }
  
  @property
  def output_types(self):
      """Returns definitions of module output ports.
      """
      return {"hypos": NeuralType(('B'), PredictionsType())}
code: def __init__(
      self,
      lm_path: str,
      vocabulary: List[str],
      tokenizer: Optional[TokenizerSpec] = None,
      lexicon_path: Optional[str] = None,
      boost_path: Optional[str] = None,
      beam_size: int = 32,
      beam_size_token: int = 32,
      beam_threshold: float = 25.0,
      lm_weight: float = 2.0,
      word_score: float = -1.0,
      unk_weight: float = -math.inf,
      sil_weight: float = 0.0,
  ):
      try:
          from flashlight.lib.text.decoder import (
              LM,
              CriterionType,
              KenLM,
              LexiconDecoder,
              LexiconDecoderOptions,
              SmearingMode,
              Trie,
          )
          from flashlight.lib.text.dictionary import (
              create_word_dict,
              load_words,
          )
      except ModuleNotFoundError:
          raise ModuleNotFoundError(
              "FlashLightKenLMBeamSearchDecoder requires the installation of flashlight python bindings "
              "from https://github.com/flashlight/text. Please follow the build instructions there."
          )
  
      super().__init__()
  
      self.criterion_type = CriterionType.CTC
      self.tokenizer_wrapper = _TokensWrapper(vocabulary, tokenizer)
      self.vocab_size = self.tokenizer_wrapper.vocab_size
      self.blank = self.tokenizer_wrapper.blank
      self.silence = self.tokenizer_wrapper.unk_id
  
      if lexicon_path is not None:
          self.lexicon = load_words(lexicon_path)
          self.word_dict = create_word_dict(self.lexicon)
          self.unk_word = self.word_dict.get_index("<unk>")
  
          # loads in the boosted words if given via a file
          if boost_path is not None:
              with open(boost_path, "r", encoding="utf_8") as fr:
                  boost_words = [
                      line.strip().split("\t") for line in fr
                  ]
                  boost_words = {w[0]: w[1] for w in boost_words}
          else:
              boost_words = {}
  
          # add OOV boosted words to word_dict so it gets picked up in LM obj creation
          for word in boost_words.keys():
              if word not in self.lexicon:
                  self.word_dict.add_entry(word)
  
          # loads in the kenlm binary and combines in with the dictionary object from the lexicon
          # this gives a mapping between each entry in the kenlm binary and its mapping to whatever
          # numeraire is used by the AM, which is explicitly mapped via the lexicon
          # this information is ued to build a vocabulary trie for decoding
          self.lm = KenLM(lm_path, self.word_dict)
          self.trie = Trie(self.vocab_size, self.silence)
  
          start_state = self.lm.start(False)
          for i, (word, spellings) in enumerate(self.lexicon.items()):
              word_idx = self.word_dict.get_index(word)
              _, score = self.lm.score(start_state, word_idx)
              for spelling in spellings:
                  spelling_idxs = [
                      self.tokenizer_wrapper.token_to_id(token)
                      for token in spelling
                  ]
                  if self.tokenizer_wrapper.unk_id in spelling_idxs:
                      print(
                          f"tokenizer has unknown id for word[ {word} ] {spelling} {spelling_idxs}",
                          flush=True,
                      )
                      continue
                  self.trie.insert(
                      spelling_idxs,
                      word_idx,
                      score
                      if word not in boost_words
                      else float(boost_words[word]),
                  )
          # handle OOV boosted words
          for word, boost in boost_words.items():
              if word not in self.lexicon:
                  word_idx = self.word_dict.get_index(word)
                  spelling = self.tokenizer_wrapper.text_to_tokens(word)
                  spelling_idxs = [
                      self.tokenizer_wrapper.token_to_id(token)
                      for token in spelling
                  ]
                  if self.tokenizer_wrapper.unk_id in spelling_idxs:
                      print(
                          f"tokenizer has unknown id for word[ {word} ] {spelling} {spelling_idxs}",
                          flush=True,
                      )
                      continue
                  self.trie.insert(
                      spelling_idxs, word_idx, float(boost)
                  )
          self.trie.smear(SmearingMode.MAX)
  
          self.decoder_opts = LexiconDecoderOptions(
              beam_size=beam_size,
              beam_size_token=int(beam_size_token),
              beam_threshold=beam_threshold,
              lm_weight=lm_weight,
              word_score=word_score,
              unk_score=unk_weight,
              sil_score=sil_weight,
              log_add=False,
              criterion_type=self.criterion_type,
          )
  
          self.decoder = LexiconDecoder(
              self.decoder_opts,
              self.trie,
              self.lm,
              self.silence,
              self.blank,
              self.unk_word,
              [],
              False,
          )
      else:
          from flashlight.lib.text.decoder import (
              LexiconFreeDecoder,
              LexiconFreeDecoderOptions,
          )
  
          d = {
              w: [[w]]
              for w in self.tokenizer_wrapper.vocab
              + (
                  []
                  if "<unk>" in self.tokenizer_wrapper.vocab
                  else ["<unk>"]
              )
          }
          self.word_dict = create_word_dict(d)
          self.lm = KenLM(lm_path, self.word_dict)
          self.decoder_opts = LexiconFreeDecoderOptions(
              beam_size=beam_size,
              beam_size_token=int(beam_size_token),
              beam_threshold=beam_threshold,
              lm_weight=lm_weight,
              sil_score=sil_weight,
              log_add=False,
              criterion_type=self.criterion_type,
          )
          self.decoder = LexiconFreeDecoder(
              self.decoder_opts, self.lm, self.silence, self.blank, []
          )
  
imports: import itertools
  import math
  from typing import Iterable, List, Optional, Tuple, Union
  import numpy
  import torch
  from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec
  from nemo.core.classes import NeuralModule, typecheck
  from nemo.core.neural_types import LengthsType, LogprobsType, NeuralType, PredictionsType
label_desc: Use image node_id 1 to create a new FlashLightKenLMBeamSearchDecoder object from inherited base classes: NeuralModule with example: obj = FlashLightKenLMBeamSearchDecoder(lm_path, vocabulary, tokenizer, lexicon_path, boost_path, beam_size, beam_size_token, beam_threshold, lm_weight, word_score, unk_weight, sil_weight)