class_docstr: Quantized counterpart of the nn.Embedding module that applies QuantNoise during training.
  
  Args:
      - num_embeddings: number of tokens
      - embedding_dim: embedding dimension
      - p: amount of noise to inject (0 = no quantization, 1 = quantize all the weights)
      - bits: number of bits
      - method: choose among {"tensor", "histogram", "channel"}
      - update_step: recompute scale and zero_point every update_steps iterations
  
  Remarks:
      - We use the straight-through estimator so that the gradients
        back-propagate nicely in the network, this is implemented with
        the detach() trick
      - Parameters scale and zero_point are recomputed every update_step
        forward pass to reduce the overhead
      - At test time, the weights are fully quantized
code: def extra_repr(self):
      s = "{num_embeddings}, {embedding_dim}"
      if self.padding_idx is not None:
          s += ", padding_idx={padding_idx}"
      if self.max_norm is not None:
          s += ", max_norm={max_norm}"
      if self.norm_type != 2:
          s += ", norm_type={norm_type}"
      if self.scale_grad_by_freq is not False:
          s += ", scale_grad_by_freq={scale_grad_by_freq}"
      if self.sparse is not False:
          s += ", sparse=True"
      s += "quant_noise={p}, bits={bits}, method={method}"
      return s.format(**self.__dict__)
  
file_path: fairseq/fairseq/modules/quantization/scalar/modules/qemb.py
imports: import torch
  import torch.nn
  import torch.nn.functional
  from ..ops import emulate_int
label_desc: Use image node_id 4 for calling the IntEmbedding obj's underlying member method code with example usage: obj.extra_repr() and returns: s