class_docstr: This is a generic GPTQ runner that takes an existing model and applies GPTQ.
  It uses torch._dynamo.export to obtain a graph of the model and then hooks
  into function calls and when it detects a linear, it applies GPTQ to the weight
  given the calibration of inputs passed in at initialization. It puts the results
  into the state_dict so that the quantized model weights/qparams can be loaded
  directly into the model.
  
  This class is expected to work in concert with a GPTQSimpleQuantizer
  class to define the specific type of quantization being done.
code: def __init__(
      self,
      model,
      inputs: MultiInput,
      blocksize=128,
      percdamp=0.01,
      groupsize=128,
  ):
      self.id_to_name = {
          id(value): name
          for name, value in dict(model.named_parameters()).items()
      }
  
      # trace model for one input
      one_input = [multi.values[0] for multi in inputs]
      exported_model = torch._dynamo.export(
          model, aten_graph=True, pre_dispatch=True, tracing_mode="fake"
      )(*one_input)
      super().__init__(exported_model.graph_module)
      self.new_state_dict = model.state_dict()
      self.blocksize = blocksize
      self.percdamp = percdamp
      self.groupsize = groupsize
      self.inputs = inputs
      self.gptq_done = False
      self.debug = False
  
imports: import os
  import sys
  import torch
  import main
  import torch.fx
  import torch.nn
  import torch.nn.functional
  from torch.utils._pytree import tree_flatten, tree_unflatten
  from eval import setup_cache_padded_seq_input_pos_max_seq_length_for_prefill
  from generate import encode_tokens
label_desc: Use image node_id 1 to create a new GenericGPTQRunner object from inherited base classes: fx with example: obj = GenericGPTQRunner(model, inputs, blocksize, percdamp, groupsize)