code: def quantize(
      self,
      parameter_group,
      overflow,
      eigenvalue_enabled,
      block_eigenvalue={},
  ):
      if overflow and not eigenvalue_enabled:
          return
  
      self.step()
  
      self.update_fp16_ratio()
  
      for i in range(len(parameter_group)):
          for p in parameter_group[i]:
              if (
                  len(p.size()) > 1
                  and hasattr(p, "start_bits")
                  and p.start_bits
              ):
                  param_id = id(p)
                  if block_eigenvalue is None:
                      eigenvalue, layer_id = None, 0
                  else:
                      eigenvalue, layer_id = (
                          block_eigenvalue[param_id]
                          if param_id in block_eigenvalue
                          else (None, 0)
                      )
                  if eigenvalue is not None:
                      factor = 1 + math.floor(eigenvalue * 4)
                      p.data = self.compute_quantization(
                          p.data, layer_id, factor
                      )
                  else:
                      p.data = self.compute_quantization(p, layer_id)
  
file_path: DeepSpeed/deepspeed/runtime/quantize.py
imports: import torch
  import math
  from deepspeed.utils import logger
  from deepspeed.ops.quantizer import ds_quantizer
label_desc: Use image node_id 3 for calling the Quantizer obj's underlying member method code with example usage: obj.quantize(parameter_group, overflow, eigenvalue_enabled, block_eigenvalue) without return types