code: def hybrid_asr_model(test_data_dir):
      preprocessor = {
          "cls": "nemo.collections.asr.modules.AudioToMelSpectrogramPreprocessor",
          "params": dict({}),
      }
  
      model_defaults = {"enc_hidden": 1024, "pred_hidden": 64}
  
      encoder = {
          "cls": "nemo.collections.asr.modules.ConvASREncoder",
          "params": {
              "feat_in": 64,
              "activation": "relu",
              "conv_mask": True,
              "jasper": [
                  {
                      "filters": model_defaults["enc_hidden"],
                      "repeat": 1,
                      "kernel": [1],
                      "stride": [1],
                      "dilation": [1],
                      "dropout": 0.0,
                      "residual": False,
                      "separable": True,
                      "se": True,
                      "se_context_size": -1,
                  }
              ],
          },
      }
  
      decoder = {
          "_target_": "nemo.collections.asr.modules.RNNTDecoder",
          "prednet": {
              "pred_hidden": model_defaults["pred_hidden"],
              "pred_rnn_layers": 1,
          },
      }
  
      joint = {
          "_target_": "nemo.collections.asr.modules.RNNTJoint",
          "jointnet": {
              "joint_hidden": 32,
              "activation": "relu",
          },
      }
  
      decoding = {
          "strategy": "greedy_batch",
          "greedy": {"max_symbols": 30},
      }
  
      tokenizer = {
          "dir": os.path.join(
              test_data_dir, "asr", "tokenizers", "an4_wpe_128"
          ),
          "type": "wpe",
      }
  
      loss = {
          "loss_name": "default",
          "warprnnt_numba_kwargs": {"fastemit_lambda": 0.001},
      }
  
      aux_ctc = {
          "ctc_loss_weight": 0.3,
          "use_cer": False,
          "ctc_reduction": "mean_batch",
          "decoder": {
              "_target_": "nemo.collections.asr.modules.ConvASRDecoder",
              "feat_in": 1024,
              "num_classes": -2,
              "vocabulary": None,
          },
          "decoding": DictConfig(CTCBPEDecodingConfig),
      }
  
      modelConfig = DictConfig(
          {
              "preprocessor": DictConfig(preprocessor),
              "model_defaults": DictConfig(model_defaults),
              "encoder": DictConfig(encoder),
              "decoder": DictConfig(decoder),
              "joint": DictConfig(joint),
              "tokenizer": DictConfig(tokenizer),
              "decoding": DictConfig(decoding),
              "loss": DictConfig(loss),
              "aux_ctc": DictConfig(aux_ctc),
          }
      )
  
      model_instance = EncDecHybridRNNTCTCBPEModel(cfg=modelConfig)
      return model_instance
  
imports: import os
  import shutil
  import tempfile
  import pytest
  import torch
  from omegaconf import DictConfig
  from nemo.collections.asr.models.hybrid_rnnt_ctc_bpe_models import EncDecHybridRNNTCTCBPEModel
  from nemo.collections.asr.parts.submodules import rnnt_beam_decoding
  from nemo.collections.asr.parts.submodules import rnnt_greedy_decoding
  from nemo.collections.asr.parts.submodules.ctc_decoding import CTCBPEDecoding, CTCBPEDecodingConfig
  from nemo.collections.common import tokenizers
  from nemo.core.utils import numba_utils
  from nemo.core.utils.numba_utils import __NUMBA_MINIMUM_VERSION__
label_desc: Use image node_id 1 for calling a global function with example usage: hybrid_asr_model(test_data_dir) and returns: model_instance