code: def setUp(self, seed=0):
      super().setUp()
      torch.manual_seed(seed)
  
      self.batch_size = random.randint(1, 64)
      self.in_channels = random.randint(1, 64) * 8
      self.out_channels = random.randint(1, 64) * 8
      self.in_height = self.in_width = random.randint(5, 100)
      self.conv_kernel_size = random.randint(1, 5)
      self.conv_pad = random.randint(0, int(self.conv_kernel_size / 2))
      self.conv_stride = random.randint(1, 5)
      self.conv_dilation = 1
      self.out_height = self.out_width = math.floor(
          (
              self.in_height
              + 2 * self.conv_pad
              - self.conv_dilation * (self.conv_kernel_size - 1)
              - 1
          )
          / self.conv_stride
          + 1
      )
  
      self.x = (
          torch.randint(
              low=-16,
              high=16,
              size=[
                  self.batch_size,
                  self.in_channels,
                  self.in_height,
                  self.in_width,
              ],
          )
          .cuda()
          .to(memory_format=torch.channels_last)
          .float()
      )
      self.x_ = self.x.clone()
      self.x.requires_grad_()
      self.x_.requires_grad_()
  
      self.mask = (
          torch.randn(
              [
                  self.batch_size,
                  self.out_channels,
                  self.out_height,
                  self.out_width,
              ]
          )
          .cuda()
          .to(memory_format=torch.channels_last)
      )
      self.mask = (self.mask > 0).to(torch.int8)
      self.mask_ = self.mask.clone()
  
      self.scale = (
          torch.randn([1, self.out_channels, 1, 1]).half().cuda()
      )
      self.scale_ = self.scale.clone()
      self.bias = (
          torch.randn([1, self.out_channels, 1, 1]).half().cuda()
      )
      self.bias_ = self.bias.clone()
  
      self.conv1 = (
          torch.nn.Conv2d(
              self.in_channels,
              self.out_channels,
              self.conv_kernel_size,
              stride=self.conv_stride,
              padding=self.conv_pad,
          )
          .cuda()
          .to(memory_format=torch.channels_last)
      )
      self.conv1_ = copy.deepcopy(self.conv1)
  
      self.conv2 = (
          torch.nn.Conv2d(
              self.in_channels,
              self.out_channels,
              self.conv_kernel_size,
              stride=self.conv_stride,
              padding=self.conv_pad,
              bias=False,
          )
          .cuda()
          .to(memory_format=torch.channels_last)
      )
      self.conv2_ = copy.deepcopy(self.conv2)
  
      print()
      print(
          "> input=[{}, {}, {}, {}]".format(
              self.batch_size,
              self.in_channels,
              self.in_height,
              self.in_width,
          )
      )
      print(
          "> kernel=[{}, {}, {}, {}], stride={}, pad={}".format(
              self.out_channels,
              self.in_channels,
              self.conv_kernel_size,
              self.conv_kernel_size,
              self.conv_stride,
              self.conv_pad,
          )
      )
  
file_path: apex/apex/contrib/test/conv_bias_relu/test_conv_bias_relu.py
imports: import copy
  import math
  import random
  import unittest
  import torch
  import torch.nn.functional
label_desc: Use image node_id 1 for calling the FusedDenseTest obj's underlying member method code with example usage: obj.setUp(seed) without return types