code: def test_quant_linear_layer_forward():
      batch_size, seq_len = kt.bs_sl()
      hidden_size = ql_config_fp16.in_features
      print(
          f"(batch_size, seq_len, hidden_size): ({batch_size}, {seq_len}, {hidden_size})"
      )
  
      inputs = kt.rand((batch_size, seq_len, hidden_size))
  
      if kt.dtype == torch.float:
          custom_layer = custom_quant_linear_layer_fp32
      else:
          custom_layer = custom_quant_linear_layer_fp16
  
      weight = custom_layer.weight
      bias = custom_layer.bias
      cmax = custom_layer.clip_max
      print(bias)
  
      def custom():
          res = custom_layer(inputs)
          return [
              res.contiguous().detach(),
              # bias.contiguous().detach(),
          ]
  
      def baseline():
          x = kt.dequantize(kt.quantize(inputs, cmax[0])[0], cmax[0])
          fweight = kt.dequantize(
              kt.quantize(weight, cmax[1])[0], cmax[1]
          )
          out = torch.nn.functional.linear(x, fweight)
  
          out = kt.dequantize(kt.quantize(out, cmax[2])[0], cmax[2])
          if bias is not None:
              out = out + bias
  
          return [
              out.contiguous().detach(),
              # bias.contiguous().detach(),
          ]
  
      return custom, baseline
  
imports: import random
  import math
  from copy import deepcopy
  from dataclasses import dataclass
  import torch
  import torch.nn
  from tests.util import TestDecorator, get_fairseq_enc_params, get_fairseq_dec_params, max_batch_tokens, max_seq_len, split_custom_layer_grad, copy_grad_from_paras, copy_cmax_grad_from_paras
  from tests import fairseq_layers
  from lightseq.training.ops.pytorch.transformer_encoder_layer import LSTransformerEncoderLayer
  from lightseq.training.ops.pytorch.transformer_embedding_layer import LSTransformerEmbeddingLayer
  from lightseq.training.ops.pytorch.cross_entropy_layer import LSCrossEntropyLayer
  from lightseq.training.ops.pytorch.quant_linear_layer import LSQuantLinearLayer
  from lightseq.training.cli.fs_modules.ls_fs_transformer_decoder_layer import LSFSTransformerDecoderLayer
  from lightseq.training.ops.pytorch.quantization import enable_quant, disable_quant, qat_mode, ptq_mode
label_desc: Use image node_id 31 for calling a global function with example usage: test_quant_linear_layer_forward() and returns: custom,  baseline, list, list