code: def test_launch_dropout_gelu_bias_i8I_i8O_bwd():
      batch_size, seq_len = kt.bs_sl()
      hidden_dim = kt.hidden_dim * 4
      print("test shape:", (batch_size, seq_len, hidden_dim))
  
      # shared weights
      inp = kt.randint8((batch_size, seq_len, hidden_dim))
      bias = kt.rand((hidden_dim,))
      out_grad = kt.rand((batch_size, seq_len, hidden_dim))
      mask = kt.ones((batch_size, seq_len, hidden_dim)).to(torch.uint8)
      cmax_out = (kt.topk(inp) / 127).to(kt.dtype)
      cmax_in = (kt.topk(inp) / 127).to(kt.dtype)
      inp_dq = kt.dequantize(inp, cmax_out)
      gelu_inp = inp_dq + bias
      gelu_inp.requires_grad_()
      gelu_out = torch.nn.functional.gelu(gelu_inp)
      gelu_out_sum = gelu_out.sum()
      res = torch.nn.functional.dropout(gelu_out, p=0)
  
      # custom weights
      custom_inp_grad = kt.rand((batch_size, seq_len, hidden_dim))
      custom_bias_grad = kt.rand((hidden_dim))
      custom_cmask_out = kt.get_cmask(inp, cmax_out)
      custom_cmask_in = kt.get_cmask(res, cmax_in)
      custom_cmax_in_grad = kt.zeros(1)
      custom_cmax_out_grad = kt.zeros(1)
  
      if kt.dtype == torch.float:
          cus_func = (
              cuda_module.torch_launch_ls_quant_dropout_gelu_bias_bwd_fp32
          )
      else:
          cus_func = (
              cuda_module.torch_launch_ls_quant_dropout_gelu_bias_bwd_fp16
          )
  
      def custom():
          cus_func(
              custom_inp_grad,
              custom_bias_grad,
              custom_cmax_out_grad,
              custom_cmax_in_grad,
              mask,
              inp,
              cmax_out,
              custom_cmask_out,
              custom_cmask_in,
              bias,
              out_grad,
              batch_size * seq_len,
              hidden_dim,
              0,
          )
  
          return custom_inp_grad, custom_bias_grad, custom_cmax_in_grad
  
      def baseline():
          out_grad_inrange = kt.tensor_inrange(out_grad, res, cmax_in)
          out_grad_outrange = kt.tensor_outrange(out_grad, res, cmax_in)
          base_cmax_in_grad = out_grad_outrange.sum()
  
          temp = out_grad_inrange * mask
          if gelu_inp.grad is not None:
              gelu_inp.grad.zero_()
          gelu_out_sum.backward(retain_graph=True)
          base_inp_grad = temp * gelu_inp.grad
          base_bias_grad = torch.sum(base_inp_grad, (0, 1))
  
          return base_inp_grad, base_bias_grad, base_cmax_in_grad
  
      return custom, baseline
  
imports: import random
  import torch
  from torch._C import ScriptModule, dtype
  from torch.nn import functional
  from lightseq.training.ops.pytorch.builder import KernelBuilder, AdamBuilder
  from tests.util import TestDecorator
  from torch_crf import CRF
label_desc: Use image node_id 25 for calling a global function with example usage: test_launch_dropout_gelu_bias_i8I_i8O_bwd() and returns: custom,  baseline, custom_inp_grad,  custom_bias_grad,  custom_cmax_in_grad, base_inp_grad,  base_bias_grad,  base_cmax_in_grad