Add comprehensive debugging utilities for model inspection and quantization analysis

[dvsav]

What

Let's add comprehensive debugging utilities to TICO that would enable users to:

1. Analyze PyTorch computation graphs (torch.fx.GraphModule):

   • Print detailed graph structure with all nodes
   • Display node information: operation type, inputs, outputs, users

2. Analyze Circle models (tico.serialize.circle_graph.CircleModel, CircleSubgraph):

   • Print Circle graph structure (tensors, operators, inputs/outputs)
   • Display Circle tensor information with quantization parameters
   • Show operator codes and their configurations

Why

Current Limitations:

• TICO has minimal debugging functionality (only basic dump_exported_program.py)
• No tools to visualize model structure or graph topology
• No comprehensive quantization parameter inspection
• Difficult to debug quantization issues without visibility into intermediate states
• Hard to understand what transformations are applied during the conversion pipeline

Benefits:

• Users can inspect models at every stage (original → prepared → quantized → Circle)
• Easier to identify where quantization issues occur
• Better understanding of how quantization parameters flow through the pipeline
• Helps users understand TICO's internal workings
• Makes it easier to learn the quantization pipeline
• Provides examples of how to inspect model structures
• Users can verify quantization parameters are correct
• Can confirm that Circle conversion preserves quantization information
• Can compare different quantization algorithms side-by-side

[dvsav]

Example debug info for torch.fx.Node

Below is an example printout for two different graph nodes. Tensor values for placeholders are pulled from the ExportedProgram's state_dict automatically.

  Node:          p_wrapped_module_linear_weight
    op:          placeholder
    target:      p_wrapped_module_linear_weight
    users:       {fake_quantize_per_channel_affine: None}
    dtype:       torch.float32
    shape:       torch.Size([5, 10])
    tensor:      tensor([[-0.7757,  0.2567,  0.4353,  0.7045, -0.2209,  0.2450,  0.1945, -1.0374,  0.5806,  0.3191],
                         [ 0.1804, -0.0387, -0.2081,  0.9124, -0.5637,  0.2319, -0.1771,  0.9094,  0.0954,  0.0745],
                         [-0.4800,  0.0097, -0.5333, -0.2130, -0.6562,  0.1587, -0.4145, -0.3257,  0.2538,  0.1966],
                         [ 0.3683,  0.4689,  0.0897, -1.0240,  0.2647,  0.2753, -0.7187, -0.2633,  0.3587, -0.4953],
                         [ 0.0109, -0.5244,  0.1323,  0.0182,  0.3997,  0.2061,  0.0404, -0.4597, -0.8893, -0.0057]], requires_grad=True)

  Node:          fake_quantize_per_channel_affine
    op:          call_function
    target:      aten.fake_quantize_per_channel_affine.default
    args:        (p_wrapped_module_linear_weight, c_wrapped_weight_obs__cached_scale, c_wrapped_weight_obs__cached_zp, 0, 0, 255)
    input_nodes: [p_wrapped_module_linear_weight, c_wrapped_weight_obs__cached_scale, c_wrapped_weight_obs__cached_zp]
    users:       {linear: None}
    dtype:       torch.float32
    shape:       torch.Size([5, 10])

This can be implemented as a function def node_to_str(node : torch.fx.Node) -> str.

Example debug info for tico.serialize.circle_graph.CircleModel

{
    'version':        0,
    'subgraphs':      [<tico.serialize.circle_graph.CircleSubgraph object>],
    'description':    'circle',
    'metadataBuffer': None,
    'metadata':       None,
    'signatureDefs':  None,
    'operatorCodes':
    [
        <tico.serialize.operators.hashable_opcode.OpCode object>
        {
            'deprecatedBuiltinCode': 9,
            'customCode':            None,
            'version':               1,
            'builtinCode':           9
        }
    ],
    'buffers':
    [
        <circle_schema.v0_10.circle.Buffer.BufferT object>
        {
            'data': None,
            'offset': 0,
            'size':   0
        },
        <circle_schema.v0_10.circle.Buffer.BufferT object>
        {
            'data': array([205, 204, 204,  61, 205, 204, 204,  61, 205, 204,
                           204,  61, 205, 204, 204,  61, 205, 204, 204,  61], dtype=uint8),
            'offset': 0,
            'size':   0
        },
        <circle_schema.v0_10.circle.Buffer.BufferT object at 0x7bc2dd51f790>
        {
            'data': array([ 21,  17, 228,  59, 179, 190, 154,  59,  73,  74,
                           243,  59, 159, 113,  23,  60, 179,  64,  91,  59], dtype=uint8),
            'offset': 0,
            'size':   0
        },
        <circle_schema.v0_10.circle.Buffer.BufferT object>
        {
            'data': array([125,   0,   0,   0, 171,   0,   0,   0,  99,   0,
                             0,   0, 116,   0,   0,   0,  63,   0,   0,   0], dtype=uint8),
            'offset': 0,
            'size':   0
        },
        <circle_schema.v0_10.circle.Buffer.BufferT object>
        {
            'data': array([132,  75,   0, 163, 146, 119, 255, 126, 134,  29,
                           163,  23, 169, 255, 182, 196,  19,   0, 106, 208,
                           72,  255, 139, 167,   0,  78, 113, 102,  51,  54,
                           124, 119, 110, 105, 255,   0,  97,  88, 134, 206,
                           0,   123, 103, 188, 255, 116, 107, 173,  59, 199], dtype=uint8),
            'offset': 0,
            'size':   0
        },
        <circle_schema.v0_10.circle.Buffer.BufferT object>
        {
            'data': array([201,   2,   0,   0,  27,   4,   0,   0, 156,   2,
                             0,   0,  25,   2,   0,   0, 203,   5,   0,   0], dtype=uint8),
            'offset': 0,
            'size':   0
        },
        <circle_schema.v0_10.circle.Buffer.BufferT object>
        {
            'data': None,
            'offset': 0,
            'size':   0
        },
        <circle_schema.v0_10.circle.Buffer.BufferT object>
        {
            'data': None,
            'offset': 0,
            'size':   0
        }
    ]
}

Example debug info for tico.serialize.circle_graph.CircleSubgraph

{
    'inputs':             [5],
    'outputs':            [6],
    'name':               'subgraph',
    'debugMetadataIndex': -1,
    'model':              <tico.serialize.circle_graph.CircleModel object>,
    'counter':            defaultdict(<class 'int'>, {}),
    'name_to_tid':
    {
        'p_wrapped_module_linear_bias':       0,
        'c_wrapped_weight_obs__cached_scale': 1,
        'c_wrapped_weight_obs__cached_zp':    2,
        '_prop_tensor_constant6':             3,
        'p_wrapped_module_linear_bias7':      4,
        'args_0':                             5,
        'linear':                             6
    },
    'name_to_node':
    {
        'p_wrapped_module_linear_bias':       p_wrapped_module_linear_bias,
        'c_wrapped_weight_obs__cached_scale': c_wrapped_weight_obs__cached_scale,
        'c_wrapped_weight_obs__cached_zp':    c_wrapped_weight_obs__cached_zp,
        '_prop_tensor_constant6':             _prop_tensor_constant6,
        'p_wrapped_module_linear_bias7':      p_wrapped_module_linear_bias7,
        'args_0':                             args_0,
        'linear':                             linear
    },
    'operators':
    [
        <circle_schema.v0_10.circle.Operator.OperatorT object>
        {
            'builtinOptions':           <circle_schema.v0_10.circle.FullyConnectedOptions.FullyConnectedOptionsT object>,
            'builtinOptions2':          None,
            'builtinOptions2Type':      0,
            'builtinOptionsType':       8,
            'customOptions':            None,
            'customOptionsFormat':      0,
            'debugMetadataIndex':       -1,
            'inputs':                   [5, 3, 4],
            'intermediates':            None,
            'largeCustomOptionsOffset': 0,
            'largeCustomOptionsSize':   0,
            'mutatingVariableInputs':   None,
            'opcodeIndex':              0,
            'outputs':                  [6]
        }
    ],
    'tensors':
    [
        <circle_schema.v0_10.circle.Tensor.TensorT object>
        {
            'shape':           [5],
            'type':            0,
            'buffer':          1,
            'name':            'tico::p_wrapped_module_linear_bias',
            'quantization':    None,
            'isVariable':      False,
            'sparsity':        None,
            'shapeSignature':  None,
            'hasRank':         False,
            'variantTensors':  None,
            'compressionType': 0
        },
        <circle_schema.v0_10.circle.Tensor.TensorT object>
        {
            'shape':           [5],
            'type':            0,
            'buffer':          2,
            'name':            'tico::c_wrapped_weight_obs__cached_scale',
            'quantization':    None,
            'isVariable':      False,
            'sparsity':        None,
            'shapeSignature':  None,
            'hasRank':         False,
            'variantTensors':  None,
            'compressionType': 0
        },
        <circle_schema.v0_10.circle.Tensor.TensorT object>
        {
            'shape':           [5],
            'type':            2,
            'buffer':          3,
            'name':            'tico::c_wrapped_weight_obs__cached_zp',
            'quantization':    None,
            'isVariable':      False,
            'sparsity':        None,
            'shapeSignature':  None,
            'hasRank':         False,
            'variantTensors':  None,
            'compressionType': 0
        },
        <circle_schema.v0_10.circle.Tensor.TensorT object>
        {
            'buffer':          4,
            'compressionType': 0,
            'hasRank':         False,
            'isVariable':      False,
            'name':            '__main__.QuantLinearModule::_prop_tensor_constant6',
            'quantization':    <circle_schema.v0_10.circle.QuantizationParameters.QuantizationParametersT object>
                               {
                                   'details':            None,
                                   'detailsType':        0,
                                   'max':                None,
                                   'min':                None,
                                   'quantizedDimension': 0,
                                   'scale':              [0.006960, 0.004722, 0.007424, 0.009243, 0.003345],
                                   'zeroPoint':          [125, 171, 99, 116, 63]
                               },
            'shape':           [5, 10],
            'shapeSignature':  None,
            'sparsity':        None,
            'type':            3,
            'variantTensors':  None
        },
        <circle_schema.v0_10.circle.Tensor.TensorT object>
        {
            'buffer':          5,
            'compressionType': 0,
            'hasRank':         False,
            'isVariable':      False,
            'name':            'tico::p_wrapped_module_linear_bias7',
            'quantization':    <circle_schema.v0_10.circle.QuantizationParameters.QuantizationParametersT object>
                               {
                                   'details':            None,
                                   'detailsType':        0,
                                   'max':                None,
                                   'min':                None,
                                   'quantizedDimension': 0,
                                   'scale':              [0.000140, 9.516183e-05, 0.000149, 0.000186, 6.741575e-05],
                                   'zeroPoint':          [0, 0, 0, 0, 0]
                               },
            'shape':           [5],
            'shapeSignature':  None,
            'sparsity':        None,
            'type':            2,
            'variantTensors':  None
        },
        <circle_schema.v0_10.circle.Tensor.TensorT object>
        {
            'buffer':          6,
            'compressionType': 0,
            'hasRank':         False,
            'isVariable':      False,
            'name':            'tico::args_0',
            'quantization':    <circle_schema.v0_10.circle.QuantizationParameters.QuantizationParametersT object>
                               {
                                   'details':            None,
                                   'detailsType':        0,
                                   'max':                None,
                                   'min':                None,
                                   'quantizedDimension': 0,
                                   'scale':              [0.020150],
                                   'zeroPoint':          [117]
                               },
            'shape':           [10, 10],
            'shapeSignature':  None,
            'sparsity':        None,
            'type':            3,
            'variantTensors':  None
        },
        <circle_schema.v0_10.circle.Tensor.TensorT object>
        {
            'buffer':          7,
            'compressionType': 0,
            'hasRank':         False,
            'isVariable':      False,
            'name':            '__main__.QuantLinearModule::linear',
            'quantization':    <circle_schema.v0_10.circle.QuantizationParameters.QuantizationParametersT object>
                               {
                                   'details':            None,
                                   'detailsType':        0,
                                   'max':                None,
                                   'min':                None,
                                   'quantizedDimension': 0,
                                   'scale':              [0.040019],
                                   'zeroPoint':          [100]
                               },
            'shape':           [10, 5],
            'shapeSignature':  None,
            'sparsity':        None,
            'type':            3,
            'variantTensors':  None
        }
    ]
}