code: def test_defused_embedding_bag_linear(self):
      for qengine in supported_qengines:
          with override_quantized_engine(qengine):
              model = DeFusedEmbeddingBagLinear().train()
              model = prepare_qat(
                  model, mapping=get_embedding_qat_module_mappings()
              )
              self.checkObservers(model)
  
              test_only_train_fn(model, self.embed_linear_data_train)
              # make sure activation_post_process is inserted after Linear.
              self.assertEqual(
                  type(model.linear.activation_post_process),
                  FusedMovingAvgObsFakeQuantize,
              )
              # make sure that Embedding has a noop for activation.
              self.assertEqual(
                  type(model.emb.activation_post_process), NoopObserver
              )
              # make sure that FakeQuant zero_points are correct dtype
              self.assertEqual(
                  model.emb.weight_fake_quant.zero_point.dtype,
                  torch.float32,
              )
              self.assertEqual(
                  model.linear.weight_fake_quant.zero_point.dtype,
                  torch.int32,
              )
  
              model = convert(
                  model,
                  mapping=get_embedding_static_quant_module_mappings(),
              )
  
              def checkQuantized(model):
                  # make sure Embedding is now a QuantizedEmbedding
                  self.assertEqual(
                      type(model.emb), nn.quantized.Embedding
                  )
                  # make sure Linear is now a QuantizedLinear
                  self.assertEqual(
                      type(model.linear), nn.quantized.Linear
                  )
  
                  test_only_eval_fn(model, self.embed_data)
                  self.checkScriptable(model, self.embed_data)
                  self.checkNoQconfig(model)
  
              checkQuantized(model)
  
imports: import copy
  import math
  import torch
  import torch.nn
  import torch.backends.mkldnn
  from torch.nn import Conv2d, BatchNorm2d, ReLU, init
  from torch.ao.nn.intrinsic.qat import ConvBn2d, ConvBnReLU2d
  from torch.nn.modules.utils import _pair
  import torch.ao.nn.quantized
  import torch.ao.nn.quantized.dynamic
  import torch.ao.nn.qat
  import torch.ao.nn.intrinsic.qat
  import torch.ao.nn.qat.dynamic
  from torch.ao.quantization import prepare, convert, prepare_qat, quantize_qat, QuantStub, DeQuantStub, default_qconfig, default_qat_qconfig, default_embedding_qat_qconfig, default_symmetric_qnnpack_qat_qconfig, get_default_qat_qconfig, FixedQParamsFakeQuantize, FusedMovingAvgObsFakeQuantize, get_embedding_qat_module_mappings, get_embedding_static_quant_module_mappings, NoopObserver
  from torch.ao.quantization.qconfig import qconfig_equals
  from torch.testing._internal.common_quantization import DeFusedEmbeddingBagLinear, QuantizationTestCase, QuantStubModel, ManualLinearQATModel, ManualDropoutQATModel, ManualLinearDynamicQATModel, ManualConvLinearQATModel, ManualConvLinearSymmQATModel, ManualEmbeddingBagLinear, TwoLayerLinearModel, test_only_eval_fn, test_only_train_fn
  from torch.testing._internal.common_quantized import override_quantized_engine, supported_qengines, override_qengines
  from torch.testing._internal.common_utils import skipIfNoXNNPACK
  from hypothesis import given
  from hypothesis import strategies
  import torch.testing._internal.hypothesis_utils
  from functools import reduce
label_desc: Use image node_id 8 for calling the TestQuantizeEagerQAT obj's underlying member method code with example usage: obj.test_defused_embedding_bag_linear() without return types