code: def test_qlinear_model(self):
      class LinearModel(torch.nn.Module):
          def __init__(self):
              super().__init__()
              self.qconfig = torch.ao.quantization.default_qconfig
              self.fc1 = torch.ao.quantization.QuantWrapper(
                  torch.nn.Linear(5, 10).to(dtype=torch.float)
              )
  
          def forward(self, x):
              x = self.fc1(x)
              return x
  
      torch.backends.quantized.engine = "qnnpack"
      qconfig = torch.ao.quantization.default_qconfig
      model = LinearModel()
      model.qconfig = qconfig
      model = torch.ao.quantization.prepare(model)
      model = torch.ao.quantization.convert(model)
  
      x_numpy = np.random.rand(1, 2, 5).astype(np.float32)
      x = torch.from_numpy(x_numpy).to(dtype=torch.float)
      outputs = model(x)
      input_names = ["x"]
      onnx_model = self.export_to_onnx(model, x, input_names)
  
      caffe_res = c2.run_model(
          onnx_model, dict(zip(input_names, x_numpy))
      )[0]
      output_diff = np.absolute(np.squeeze(outputs.numpy()) - caffe_res)
      max_diff = np.amax(output_diff)
  
      # Permute pytorch output to NHWC
      # This check had to be changed to account for changes in
      # qnnpack's requant logic.
      np.testing.assert_(
          max_diff <= 1,
          "Maximum absolute difference must be less than 1",
      )
  
imports: import io
  import caffe2.python.onnx.backend
  import numpy
  import onnx
  import pytorch_test_common
  import torch.ao.nn.quantized
  import torch.nn
  import torch.onnx
  from torch.testing._internal import common_utils
label_desc: Use image node_id 6 for calling the TestQuantizedOps obj's underlying member method code with example usage: obj.test_qlinear_model() and returns: x