code: def __init__(self, model: "Whisper", options: DecodingOptions):
      self.model = model
  
      language = options.language or "en"
      tokenizer = get_tokenizer(
          model.is_multilingual,
          num_languages=model.num_languages,
          language=language,
          task=options.task,
      )
      self.tokenizer: Tokenizer = tokenizer
      self.options: DecodingOptions = self._verify_options(options)
  
      self.n_group: int = options.beam_size or options.best_of or 1
      self.n_ctx: int = model.dims.n_text_ctx
      self.sample_len: int = (
          options.sample_len or model.dims.n_text_ctx // 2
      )
  
      self.sot_sequence: Tuple[int] = tokenizer.sot_sequence
      if self.options.without_timestamps:
          self.sot_sequence = (
              tokenizer.sot_sequence_including_notimestamps
          )
  
      self.initial_tokens: Tuple[int] = self._get_initial_tokens()
      self.sample_begin: int = len(self.initial_tokens)
      self.sot_index: int = self.initial_tokens.index(tokenizer.sot)
  
      # inference: implements the forward pass through the decoder, including kv caching
      self.inference = PyTorchInference(model, len(self.initial_tokens))
  
      # sequence ranker: implements how to rank a group of sampled sequences
      self.sequence_ranker = MaximumLikelihoodRanker(
          options.length_penalty
      )
  
      # decoder: implements how to select the next tokens, given the autoregressive distribution
      if options.beam_size is not None:
          self.decoder = BeamSearchDecoder(
              options.beam_size,
              tokenizer.eot,
              self.inference,
              options.patience,
          )
      else:
          self.decoder = GreedyDecoder(
              options.temperature, tokenizer.eot
          )
  
      # logit filters: applies various rules to suppress or penalize certain tokens
      self.logit_filters = []
      if self.options.suppress_blank:
          self.logit_filters.append(
              SuppressBlank(self.tokenizer, self.sample_begin)
          )
      if self.options.suppress_tokens:
          self.logit_filters.append(
              SuppressTokens(self._get_suppress_tokens())
          )
      if not options.without_timestamps:
          precision = (
              CHUNK_LENGTH / model.dims.n_audio_ctx
          )  # usually 0.02 seconds
          max_initial_timestamp_index = None
          if options.max_initial_timestamp:
              max_initial_timestamp_index = round(
                  self.options.max_initial_timestamp / precision
              )
          self.logit_filters.append(
              ApplyTimestampRules(
                  tokenizer,
                  self.sample_begin,
                  max_initial_timestamp_index,
              )
          )
  
imports: from dataclasses import dataclass, field, replace
  from typing import TYPE_CHECKING, Dict, Iterable, List, Optional, Sequence, Tuple, Union
  import numpy
  import torch
  import torch.nn.functional
  from torch import Tensor
  from torch.distributions import Categorical
  from .audio import CHUNK_LENGTH
  from .tokenizer import Tokenizer, get_tokenizer
  from .utils import compression_ratio
label_desc: Use image node_id 1 to create a new DecodingTask object  with example: obj = DecodingTask(model, options)