class_docstr: Constructs a Wav2Vec2 processor which wraps a Wav2Vec2 feature extractor, a Wav2Vec2 CTC tokenizer and a decoder
  with language model support into a single processor for language model boosted speech recognition decoding.
  
  Args:
      feature_extractor ([`Wav2Vec2FeatureExtractor`]):
          An instance of [`Wav2Vec2FeatureExtractor`]. The feature extractor is a required input.
      tokenizer ([`Wav2Vec2CTCTokenizer`]):
          An instance of [`Wav2Vec2CTCTokenizer`]. The tokenizer is a required input.
      decoder (`pyctcdecode.BeamSearchDecoderCTC`):
          An instance of [`pyctcdecode.BeamSearchDecoderCTC`]. The decoder is a required input.
docstr: Batch decode output logits to audio transcription with language model support.
  
  <Tip>
  
  This function makes use of Python's multiprocessing. Currently, multiprocessing is available only on Unix
  systems (see this [issue](https://github.com/kensho-technologies/pyctcdecode/issues/65)).
  
  If you are decoding multiple batches, consider creating a `Pool` and passing it to `batch_decode`. Otherwise,
  `batch_decode` will be very slow since it will create a fresh `Pool` for each call. See usage example below.
  
  </Tip>
  
  Args:
      logits (`np.ndarray`):
          The logits output vector of the model representing the log probabilities for each token.
      pool (`multiprocessing.Pool`, *optional*):
          An optional user-managed pool. If not set, one will be automatically created and closed. The pool
          should be instantiated *after* `Wav2Vec2ProcessorWithLM`. Otherwise, the LM won't be available to the
          pool's sub-processes.
  
          <Tip>
  
          Currently, only pools created with a 'fork' context can be used. If a 'spawn' pool is passed, it will
          be ignored and sequential decoding will be used instead.
  
          </Tip>
  
      num_processes (`int`, *optional*):
          If `pool` is not set, number of processes on which the function should be parallelized over. Defaults
          to the number of available CPUs.
      beam_width (`int`, *optional*):
          Maximum number of beams at each step in decoding. Defaults to pyctcdecode's DEFAULT_BEAM_WIDTH.
      beam_prune_logp (`int`, *optional*):
          Beams that are much worse than best beam will be pruned Defaults to pyctcdecode's DEFAULT_PRUNE_LOGP.
      token_min_logp (`int`, *optional*):
          Tokens below this logp are skipped unless they are argmax of frame Defaults to pyctcdecode's
          DEFAULT_MIN_TOKEN_LOGP.
      hotwords (`List[str]`, *optional*):
          List of words with extra importance, can be OOV for LM
      hotword_weight (`int`, *optional*):
          Weight factor for hotword importance Defaults to pyctcdecode's DEFAULT_HOTWORD_WEIGHT.
      alpha (`float`, *optional*):
          Weight for language model during shallow fusion
      beta (`float`, *optional*):
          Weight for length score adjustment of during scoring
      unk_score_offset (`float`, *optional*):
          Amount of log score offset for unknown tokens
      lm_score_boundary (`bool`, *optional*):
          Whether to have kenlm respect boundaries when scoring
      output_word_offsets (`bool`, *optional*, defaults to `False`):
          Whether or not to output word offsets. Word offsets can be used in combination with the sampling rate
          and model downsampling rate to compute the time-stamps of transcribed words.
  
          <Tip>
  
          Please take a look at the Example of [`~Wav2Vec2ProcessorWithLM.decode`] to better understand how to
          make use of `output_word_offsets`. [`~Wav2Vec2ProcessorWithLM.batch_decode`] works the same way with
          batched output.
  
          </Tip>
  
  Returns:
      [`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`].
  
  Example:
      See [Decoding multiple audios](#decoding-multiple-audios).
docstr_tok: ["Batch","decode","output","logits","to","audio","transcription","with","language","model","support",".","<","Tip",">","This","function","makes","use","of","Python","'s","multiprocessing",".","Currently",",","multiprocessing","is","available","only","on","Unix","systems","(","see","this","[","issue","]","(","https",":","\/\/github.com\/kensho-technologies\/pyctcdecode\/issues\/65",")",")",".","If","you","are","decoding","multiple","batches",",","consider","creating","a","`","Pool","`","and","passing","it","to","`","batch_decode","`",".","Otherwise",",","`","batch_decode","`","will","be","very","slow","since","it","will","create","a","fresh","`","Pool","`","for","each","call",".","See","usage","example","below",".","<","\/Tip",">","Args",":","logits","(","`","np.ndarray","`",")",":","The","logits","output","vector","of","the","model","representing","the","log","probabilities","for","each","token",".","pool","(","`","multiprocessing.Pool","`",",","*","optional","*",")",":","An","optional","user-managed","pool",".","If","not","set",",","one","will","be","automatically","created","and","closed",".","The","pool","should","be","instantiated","*","after","*","`","Wav2Vec2ProcessorWithLM","`",".","Otherwise",",","the","LM","wo","n't","be","available","to","the","pool","'s","sub-processes",".","<","Tip",">","Currently",",","only","pools","created","with","a","'fork","'","context","can","be","used",".","If","a","'spawn","'","pool","is","passed",",","it","will","be","ignored","and","sequential","decoding","will","be","used","instead",".","<","\/Tip",">","num_processes","(","`","int","`",",","*","optional","*",")",":","If","`","pool","`","is","not","set",",","number","of","processes","on","which","the","function","should","be","parallelized","over",".","Defaults","to","the","number","of","available","CPUs",".","beam_width","(","`","int","`",",","*","optional","*",")",":","Maximum","number","of","beams","at","each","step","in","decoding",".","Defaults","to","pyctcdecode","'s","DEFAULT_BEAM_WIDTH",".","beam_prune_logp","(","`","int","`",",","*","optional","*",")",":","Beams","that","are","much","worse","than","best","beam","will","be","pruned","Defaults","to","pyctcdecode","'s","DEFAULT_PRUNE_LOGP",".","token_min_logp","(","`","int","`",",","*","optional","*",")",":","Tokens","below","this","logp","are","skipped","unless","they","are","argmax","of","frame","Defaults","to","pyctcdecode's","DEFAULT_MIN_TOKEN_LOGP",".","hotwords","(","`","List","[","str","]","`",",","*","optional","*",")",":","List","of","words","with","extra","importance",",","can","be","OOV","for","LM","hotword_weight","(","`","int","`",",","*","optional","*",")",":","Weight","factor","for","hotword","importance","Defaults","to","pyctcdecode","'s","DEFAULT_HOTWORD_WEIGHT",".","alpha","(","`","float","`",",","*","optional","*",")",":","Weight","for","language","model","during","shallow","fusion","beta","(","`","float","`",",","*","optional","*",")",":","Weight","for","length","score","adjustment","of","during","scoring","unk_score_offset","(","`","float","`",",","*","optional","*",")",":","Amount","of","log","score","offset","for","unknown","tokens","lm_score_boundary","(","`","bool","`",",","*","optional","*",")",":","Whether","to","have","kenlm","respect","boundaries","when","scoring","output_word_offsets","(","`","bool","`",",","*","optional","*",",","defaults","to","`","False","`",")",":","Whether","or","not","to","output","word","offsets",".","Word","offsets","can","be","used","in","combination","with","the","sampling","rate","and","model","downsampling","rate","to","compute","the","time-stamps","of","transcribed","words",".","<","Tip",">","Please","take","a","look","at","the","Example","of","[","`","~Wav2Vec2ProcessorWithLM.decode","`","]","to","better","understand","how","to","make","use","of","`","output_word_offsets","`",".","[","`","~Wav2Vec2ProcessorWithLM.batch_decode","`","]","works","the","same","way","with","batched","output",".","<","\/Tip",">","Returns",":","[","`","~models.wav2vec2.Wav2Vec2DecoderWithLMOutput","`","]",".","Example",":","See","[","Decoding","multiple","audios","]","(","#","decoding-multiple-audios",")","."]
code: def batch_decode(
      self,
      logits: np.ndarray,
      pool: Optional[Pool] = None,
      num_processes: Optional[int] = None,
      beam_width: Optional[int] = None,
      beam_prune_logp: Optional[float] = None,
      token_min_logp: Optional[float] = None,
      hotwords: Optional[Iterable[str]] = None,
      hotword_weight: Optional[float] = None,
      alpha: Optional[float] = None,
      beta: Optional[float] = None,
      unk_score_offset: Optional[float] = None,
      lm_score_boundary: Optional[bool] = None,
      output_word_offsets: bool = False,
  ):
      """
      Batch decode output logits to audio transcription with language model support.
  
      <Tip>
  
      This function makes use of Python's multiprocessing. Currently, multiprocessing is available only on Unix
      systems (see this [issue](https://github.com/kensho-technologies/pyctcdecode/issues/65)).
  
      If you are decoding multiple batches, consider creating a `Pool` and passing it to `batch_decode`. Otherwise,
      `batch_decode` will be very slow since it will create a fresh `Pool` for each call. See usage example below.
  
      </Tip>
  
      Args:
          logits (`np.ndarray`):
              The logits output vector of the model representing the log probabilities for each token.
          pool (`multiprocessing.Pool`, *optional*):
              An optional user-managed pool. If not set, one will be automatically created and closed. The pool
              should be instantiated *after* `Wav2Vec2ProcessorWithLM`. Otherwise, the LM won't be available to the
              pool's sub-processes.
  
              <Tip>
  
              Currently, only pools created with a 'fork' context can be used. If a 'spawn' pool is passed, it will
              be ignored and sequential decoding will be used instead.
  
              </Tip>
  
          num_processes (`int`, *optional*):
              If `pool` is not set, number of processes on which the function should be parallelized over. Defaults
              to the number of available CPUs.
          beam_width (`int`, *optional*):
              Maximum number of beams at each step in decoding. Defaults to pyctcdecode's DEFAULT_BEAM_WIDTH.
          beam_prune_logp (`int`, *optional*):
              Beams that are much worse than best beam will be pruned Defaults to pyctcdecode's DEFAULT_PRUNE_LOGP.
          token_min_logp (`int`, *optional*):
              Tokens below this logp are skipped unless they are argmax of frame Defaults to pyctcdecode's
              DEFAULT_MIN_TOKEN_LOGP.
          hotwords (`List[str]`, *optional*):
              List of words with extra importance, can be OOV for LM
          hotword_weight (`int`, *optional*):
              Weight factor for hotword importance Defaults to pyctcdecode's DEFAULT_HOTWORD_WEIGHT.
          alpha (`float`, *optional*):
              Weight for language model during shallow fusion
          beta (`float`, *optional*):
              Weight for length score adjustment of during scoring
          unk_score_offset (`float`, *optional*):
              Amount of log score offset for unknown tokens
          lm_score_boundary (`bool`, *optional*):
              Whether to have kenlm respect boundaries when scoring
          output_word_offsets (`bool`, *optional*, defaults to `False`):
              Whether or not to output word offsets. Word offsets can be used in combination with the sampling rate
              and model downsampling rate to compute the time-stamps of transcribed words.
  
              <Tip>
  
              Please take a look at the Example of [`~Wav2Vec2ProcessorWithLM.decode`] to better understand how to
              make use of `output_word_offsets`. [`~Wav2Vec2ProcessorWithLM.batch_decode`] works the same way with
              batched output.
  
              </Tip>
  
      Returns:
          [`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`].
  
      Example:
          See [Decoding multiple audios](#decoding-multiple-audios).
      """
  
      from pyctcdecode.constants import (
          DEFAULT_BEAM_WIDTH,
          DEFAULT_HOTWORD_WEIGHT,
          DEFAULT_MIN_TOKEN_LOGP,
          DEFAULT_PRUNE_LOGP,
      )
  
      # set defaults
      beam_width = (
          beam_width if beam_width is not None else DEFAULT_BEAM_WIDTH
      )
      beam_prune_logp = (
          beam_prune_logp
          if beam_prune_logp is not None
          else DEFAULT_PRUNE_LOGP
      )
      token_min_logp = (
          token_min_logp
          if token_min_logp is not None
          else DEFAULT_MIN_TOKEN_LOGP
      )
      hotword_weight = (
          hotword_weight
          if hotword_weight is not None
          else DEFAULT_HOTWORD_WEIGHT
      )
  
      # reset params at every forward call. It's just a `set` method in pyctcdecode
      self.decoder.reset_params(
          alpha=alpha,
          beta=beta,
          unk_score_offset=unk_score_offset,
          lm_score_boundary=lm_score_boundary,
      )
  
      # create multiprocessing pool and list numpy arrays
      # filter out logits padding
      logits_list = [
          array[(array != -100.0).all(axis=-1)] for array in logits
      ]
  
      # create a pool if necessary while also using it as a context manager to close itself
      if pool is None:
          # fork is safe to use only on Unix, see "Contexts and start methods" section on
          # multiprocessing's docs (https://docs.python.org/3/library/multiprocessing.html#contexts-and-start-methods)
          default_context = get_start_method()
  
          if default_context == "fork":
              cm = pool = get_context().Pool(num_processes)
          else:
              logger.warning(
                  "Parallel batch decoding is not currently supported in this platform. "
                  "Falling back to sequential decoding."
              )
              cm = nullcontext()
      else:
          # pool is managed by the user, so we don't need to close it
          cm = nullcontext()
  
          if num_processes is not None:
              logger.warning(
                  "Parameter `num_process` was passed, but it will be ignored since `pool` was also specified."
              )
  
      # pyctcdecode
      with cm:
          decoded_beams = self.decoder.decode_beams_batch(
              pool=pool,
              logits_list=logits_list,
              beam_width=beam_width,
              beam_prune_logp=beam_prune_logp,
              token_min_logp=token_min_logp,
              hotwords=hotwords,
              hotword_weight=hotword_weight,
          )
  
      # extract text and scores
      batch_texts, logit_scores, lm_scores, word_offsets = (
          [],
          [],
          [],
          [],
      )
      for d in decoded_beams:
          batch_texts.append(d[0][0])
          logit_scores.append(d[0][-2])
          lm_scores.append(d[0][-1])
          word_offsets.append(
              [
                  {
                      "word": t[0],
                      "start_offset": t[1][0],
                      "end_offset": t[1][1],
                  }
                  for t in d[0][1]
              ]
          )
  
      word_offsets = word_offsets if output_word_offsets else None
  
      return Wav2Vec2DecoderWithLMOutput(
          text=batch_texts,
          logit_score=logit_scores,
          lm_score=lm_scores,
          word_offsets=word_offsets,
      )
  
imports: import os
  import warnings
  from contextlib import contextmanager, nullcontext
  from dataclasses import dataclass
  from multiprocessing import Pool, get_context, get_start_method
  from typing import TYPE_CHECKING, Dict, Iterable, List, Optional, Union
  import numpy
  from ...processing_utils import ProcessorMixin
  from ...utils import ModelOutput, logging, requires_backends
label_desc: Use image node_id 9 for calling the Wav2Vec2ProcessorWithLM obj's underlying member method code with example usage: obj.batch_decode(logits, pool, num_processes, beam_width, beam_prune_logp, token_min_logp, hotwords, hotword_weight, alpha, beta, unk_score_offset, lm_score_boundary, output_word_offsets) and returns: Wav2Vec2DecoderWithLMOutput