import pickletools

op_list = pickletools.opcodes

def opcode_value(code):
    if isinstance(code, str):
        return ord(code)
    return code

op_list_sorted = sorted(op_list, key=lambda op: opcode_value(op.code))

print(f"{'Hex':<6} | {'Dec':<3} | {'Opcode Name':<16} | Min Proto | Description")
print("-" * 120)

for op in op_list_sorted:
    code_val = opcode_value(op.code)

    hex_byte = f"0x{code_val:02X}"

    desc = ""
    if op.doc:
        desc = op.doc.splitlines()[0].strip()

    print(
        f"{hex_byte:<6} | "
        f"{code_val:<3} | "
        f"{op.name:<16} | "
        f"{op.proto:<9} | "
        f"{desc}"
    )

# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler.  DO NOT EDIT!
# NO CHECKED-IN PROTOBUF GENCODE
# source: addressbook.proto
# Protobuf Python Version: 6.31.1
"""Generated protocol buffer code."""
from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import runtime_version as _runtime_version
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder
_runtime_version.ValidateProtobufRuntimeVersion(
    _runtime_version.Domain.PUBLIC,
    6,
    31,
    1,
    '',
    'addressbook.proto'
)
# @@protoc_insertion_point(imports)

_sym_db = _symbol_database.Default()




DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x11\x61\x64\x64ressbook.proto\"1\n\x06Person\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\n\n\x02id\x18\x02 \x01(\x05\x12\r\n\x05\x65mail\x18\x03 \x01(\t\"&\n\x0b\x41\x64\x64ressBook\x12\x17\n\x06people\x18\x01 \x03(\x0b\x32\x07.Personb\x06proto3')

_globals = globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'addressbook_pb2', _globals)
if not _descriptor._USE_C_DESCRIPTORS:
  DESCRIPTOR._loaded_options = None
  _globals['_PERSON']._serialized_start=21
  _globals['_PERSON']._serialized_end=70
  _globals['_ADDRESSBOOK']._serialized_start=72
  _globals['_ADDRESSBOOK']._serialized_end=110
# @@protoc_insertion_point(module_scope)

import addressbook_pb2

# ============ 1. 序列化：创建对象并写入文件 ============
# 创建一个通讯录对象
book = addressbook_pb2.AddressBook()

# 添加第一个人
person1 = book.people.add()
person1.name = "张三"
person1.id = 1001
person1.email = "zhangsan@example.com"

# 添加第二个人
person2 = book.people.add()
person2.name = "李四"
person2.id = 1002
person2.email = "lisi@example.com"

# 将通讯录序列化为二进制数据，并写入本地文件
with open("addressbook.data", "wb") as f:
    f.write(book.SerializeToString())
print("✅ 序列化完成，数据已写入 addressbook.data")

# ============ 2. 反序列化：从文件读取并解析 ============
# 创建一个空的通讯录对象
new_book = addressbook_pb2.AddressBook()

# 从文件中读取二进制数据并反序列化到 new_book
with open("addressbook.data", "rb") as f:
    new_book.ParseFromString(f.read())

# 打印解析出的数据
print("\n✅ 反序列化成功，读取到的内容如下：")
for person in new_book.people:
    print(f"姓名: {person.name}, ID: {person.id}, 邮箱: {person.email}")

  1 import os
  2 import torch
  3 import torch.nn as nn
  4 import torch.nn.functional as F
  5 import warnings
  6 from PIL import Image
  7 
  8 # 🌟 核心操作：在代码最顶层直接屏蔽掉传统的 TorchScript 弃用黄色警告
  9 # 让控制台只输出我们关心的 ✓ 和 ✗
 10 warnings.filterwarnings("ignore", category=DeprecationWarning)
 11 
 12 # ==========================================
 13 # 1. 100% 完美还原你训练源码中的 DeepMNIST 模型结构
 14 # ==========================================
 15 class DeepMNIST(nn.Module):
 16     def __init__(self):
 17         super(DeepMNIST, self).__init__()
 18         
 19         # 1. 卷积特征提取层 (使用 nn.Sequential 容器)
 20         self.features = nn.Sequential(
 21             # 第一层：卷积 -> 批归一化 -> 激活 -> 池化
 22             nn.Conv2d(1, 32, kernel_size=3, padding=1), # in_channels=1 (灰度图)
 23             nn.BatchNorm2d(32),                         # 稳定分布
 24             nn.ReLU(inplace=True),                      # 非线性激活
 25             nn.MaxPool2d(kernel_size=2, stride=2),      # 28x28 -> 14x14
 26             
 27             # 第二层：进一步提取深层特征
 28             nn.Conv2d(32, 64, kernel_size=3, padding=1),
 29             nn.BatchNorm2d(64),
 30             nn.ReLU(inplace=True),
 31             nn.MaxPool2d(kernel_size=2, stride=2),      # 14x14 -> 7x7
 32             nn.Dropout(0.25)                            # 随机丢弃，防止过拟合
 33         )
 34         
 35         # 2. 分类层 (全连接层)
 36         self.classifier = nn.Sequential(
 37             nn.Flatten(),                               # 将 64x7x7 压平为 1D 向量
 38             nn.Linear(64 * 7 * 7, 128),                 # 特征线性组合
 39             nn.ReLU(inplace=True),
 40             nn.Dropout(0.5),                            # 全连接层常用的 Dropout
 41             nn.Linear(128, 10)                          # 最终映射到 10 个类别
 42         )
 43 
 44     def forward(self, x):
 45         x = self.features(x)
 46         x = self.classifier(x)
 47         return x
 48 
 49 # ==========================================
 50 # 2. 模型核心转换逻辑
 51 # ==========================================
 52 def convert_to_onnx(pth_path, onnx_path):
 53     # 实例化完全匹配的 DeepMNIST 模型
 54     model = DeepMNIST()
 55 
 56     print(f"正在加载 PyTorch 权重文件: {pth_path}")
 57     state_dict = torch.load(pth_path, map_location=torch.device('cpu'))
 58 
 59     # 自动解析包装过的 state_dict (兼容某些训练框架)
 60     if isinstance(state_dict, dict) and 'state_dict' in state_dict:
 61         state_dict = state_dict['state_dict']
 62 
 63     model.load_state_dict(state_dict)
 64     
 65     # 开启评估模式 (非常重要：会固化 BatchNorm 的均值方差和 Dropout 的行为)
 66     model.eval()
 67 
 68     # 构建一阶段 Trace 用的高维度随机虚拟输入 (1张 28x28 的灰度图)
 69     dummy_input = torch.randn(1, 1, 28, 28, requires_grad=True)
 70 
 71     print(f"正在进行 Tracing 并导出 ONNX 模型: {onnx_path} ...")
 72     torch.onnx.export(
 73         model,
 74         dummy_input,
 75         onnx_path,
 76         export_params=True,          # 导出模型权重参数
 77         opset_version=11,            # 推荐使用 opset 11 及以上版本，对 BatchNorm 支持极佳
 78         do_constant_folding=True,    # 开启常量折叠图优化
 79         input_names=['input'],       # 计算图的输入节点自定义名称
 80         output_names=['output'],     # 计算图的输出节点自定义名称
 81         dynamic_axes={               # 开启动态 Batch Size 推理轴支持
 82             'input': {0: 'batch_size'},
 83             'output': {0: 'batch_size'}
 84         }
 85     )
 86     print("✓ ONNX 导出流程成功结束。")
 87 
 88 
 89 # ==========================================
 90 # 3. ONNX 推理一致性校对
 91 # ==========================================
 92 def verify_onnx(pth_path, onnx_path):
 93     import onnx
 94     import onnxruntime as ort
 95     import numpy as np
 96 
 97     print("\n--- 启动 ONNX Runtime 精度与对齐测试 ---")
 98 
 99     # 3.1 验证 ONNX 计算图结构合法性
100     onnx_model = onnx.load(onnx_path)
101     onnx.checker.check_model(onnx_model)
102     print("✓ [ONNX Checker] 模型图物理结构校验通过！")
103 
104     # 3.2 使用测试图片数据或者生成随机测试样本数据
105     img_path = "debug_input.png"
106     if not os.path.exists(img_path):
107         print(f"未找到测试图片 '{img_path}'，将使用随机测试样本数据")
108         test_input_np = np.random.randn(1, 1, 28, 28).astype(np.float32)
109     else:
110         print(f"使用'{img_path}'进行验证")
111         from torchvision import transforms  # 🌟 引入 torchvision
112         # a. 严格复刻你前端/训练时的 1:1 黄金流水线
113         transform_pipeline = transforms.Compose([
114             transforms.Resize((28, 28)),
115             transforms.Grayscale(),
116             transforms.ToTensor(),
117             transforms.Normalize((0.1307,), (0.3081,)) # 🌟 灵魂所在，彻底对齐数据分布
118         ])
119         # b. 直接用 Pillow 打开图片（保持你之前的灰度转换）
120         img = Image.open(img_path).convert('L')
121         # c. 用流水线直接榨出标准的 PyTorch 四维张量
122         img_tensor = transform_pipeline(img)      # 出来是 (1, 28, 28)
123         img_tensor = img_tensor.unsqueeze(0)      # 升维成 (1, 1, 28, 28)
124         test_input_np = img_tensor.numpy().astype(np.float32) # 给 ONNX Runtime 用
125     test_input_torch = torch.from_numpy(test_input_np)
126 
127     # 3.3 运行 PyTorch 原生推理
128     model = DeepMNIST()
129     state_dict = torch.load(pth_path, map_location='cpu')
130     if isinstance(state_dict, dict) and 'state_dict' in state_dict:
131         state_dict = state_dict['state_dict']
132     model.load_state_dict(state_dict)
133     model.eval()
134     with torch.no_grad():
135         pytorch_output = model(test_input_torch).numpy()
136         #print(pytorch_output)
137     # 3.4 使用 ONNX Runtime 执行推理
138     ort_session = ort.InferenceSession(onnx_path)
139     ort_inputs = {ort_session.get_inputs()[0].name: test_input_np}
140     ort_outputs = ort_session.run(None, ort_inputs)
141     onnx_output = ort_outputs[0]
142     #print(onnx_output)
143     # 3.5 严格的数值对齐校验（相对误差 1e-3，绝对误差 1e-5）
144     try:
145         np.testing.assert_allclose(pytorch_output, onnx_output, rtol=1e-03, atol=1e-05)
146         print("✓ [精度校验] 恭喜！PyTorch 与 ONNX Runtime 数值完美对齐，误差精度在安全范围内。")
147         
148         # 调试打印：看看这张图片被模型预测成了数字几？
149         pred_digit = np.argmax(onnx_output)
150         confidence = np.max(onnx_output)
151         print(f"🔮 [模型最终预测] 数字是: {pred_digit} | 置信度: {confidence:.4f}")
152     except AssertionError as e:
153         print("✗ [精度校验] 两侧算子输出存在浮点对齐偏差，请排查！")
154         print(e)
155 
156 
157 if __name__ == "__main__":
158     pth_file = "mnist_cnn.pth"
159     onnx_file = "mnist_cnn.onnx"
160 
161     if not os.path.exists(pth_file):
162         print(f"致命错误：请将您训练生成的 {pth_file} 文件放置于脚本同级目录下再运行转换。")
163     else:
164         convert_to_onnx(pth_file, onnx_file)
165         try:
166             verify_onnx(pth_file, onnx_file)
167         except ImportError:
168             print("\n温馨提示: 补充安装 `pip install onnx onnxruntime` 可自动进行数值比对校验。")

message AttributeProto {
  reserved 12, 16 to 19;
  reserved "v";

  // Note: this enum is structurally identical to the OpSchema::AttrType
  // enum defined in schema.h.  If you rev one, you likely need to rev the other.
  enum AttributeType {
    UNDEFINED = 0;
    FLOAT = 1;
    INT = 2;
    ...
    FLOATS = 6;
    INTS = 7;
    STRINGS = 8;
    ...
  }
  ...

  // The type field MUST be present for this version of the IR.
  // For 0.0.1 versions of the IR, this field was not defined, and
  // implementations needed to use has_field heuristics to determine
  // which value field was in use.  For IR_VERSION 0.0.2 or later, this
  // field MUST be set and match the f|i|s|t|... field in use.  This
  // change was made to accommodate proto3 implementations.
  AttributeType type = 20;   // discriminator that indicates which field below is i
  ...
}

import onnx
from onnx import helper
from onnx import TensorProto

inh=8
inw=8
outh=16
outw=16

#define tensor
# 1. 定义张量 (外部接口 input 使用 UINT8)
input_tensor = helper.make_tensor_value_info('input', TensorProto.UINT8, [1, 3, inh, inw])
roi = helper.make_tensor_value_info('roi', TensorProto.FLOAT, [])
scales = helper.make_tensor_value_info('scales', TensorProto.FLOAT, [4])

# 内部连线：Resize 吐出 UINT8
conv_input_u8 = helper.make_tensor_value_info('conv_input_u8', TensorProto.UINT8, [1, 3, outh, outw])
# 内部连线：经过 Cast 后变成 FLOAT32，供 Conv 消费
conv_input_f32 = helper.make_tensor_value_info('conv_input_f32', TensorProto.FLOAT, [1, 3, outh, outw])

# 权重和偏置保持 FLOAT32 (我们在推理端传 float 格式的整数，比如 10.0，模拟整型加权)
conv_weight = helper.make_tensor_value_info('conv_weight', TensorProto.FLOAT, [32, 3, 3, 3])
conv_bias = helper.make_tensor_value_info('conv_bias', TensorProto.FLOAT, [32])
conv_output = helper.make_tensor_value_info('conv_output', TensorProto.FLOAT, [1, 32, outh, outw])
add_input = helper.make_tensor_value_info('add_input', TensorProto.FLOAT, [1])
output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 32, outh, outw])

# 2. 构建计算节点
# 节点A: Resize (输入 UINT8 -> 输出 UINT8)
resize_node = helper.make_node("Resize", ['input', 'roi', 'scales'], ['conv_input_u8'], name='resize')

# 节点B: Cast (将匹配完形状的 UINT8 特征图 强转为 FLOAT32)
# 属性 to=1 代表目标类型是 TensorProto.FLOAT
cast_node = helper.make_node("Cast", ['conv_input_u8'], ['conv_input_f32'], to=1, name='cast_to_float')

# 节点C: Conv (接收 FLOAT32，配合 pads=[1,1,1,1] 守恒尺寸)
conv_node = helper.make_node("Conv", ['conv_input_f32', 'conv_weight', 'conv_bias'], ['conv_output'], name='conv', pads=[1, 1, 1, 1])

# 节点D: Add (最后的广播加法)
add_node = helper.make_node('Add', ['conv_output', 'add_input'], ['output'], name='add')

# 3. 组装计算图 (为了调试，把中间的 conv_output 也作为官方出口抛出)
graph = helper.make_graph(
    [resize_node, cast_node, conv_node, add_node], 
    'resize_conv_add_uint8_debug_graph', 
    inputs=[input_tensor, roi, scales, conv_weight, conv_bias, add_input], 
    outputs=[output, conv_output, conv_input_u8]
)

# 4. 创建模型并锁定版本 (满足你的 ONNX Runtime 1.19.2 环境要求)
model = helper.make_model(graph, ir_version=10)
del model.opset_import[:]
model.opset_import.extend([helper.make_opsetid("", 13)]) # 使用极其稳定的 Opset 13

# 5. 校验并保存
onnx.checker.check_model(model)
onnx.save(model, 'resize_conv_addU8.onnx')

print("✅ 模型已成功生成（IR=10, Opset=19）！")

import numpy as np
import onnxruntime

inh=8
inw=8
outh=16
outw=16

# 1. 载入带有 Cast 保护的全新调试模型
session = onnxruntime.InferenceSession("resize_conv_addU8.onnx")

# 2. 构造符合调试预期的“整型测试数据”
# 图像输入：构造一个 [1, 3, 8, 8] 的整型矩阵，数值限制在 0~255 的 uint8
dummy_input = np.random.randint(0, 255, (1, 3, inh, inw)).astype(np.uint8)

# ROI 和 Scales
dummy_roi = np.array([], dtype=np.float32)
dummy_scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)

# 卷积核与偏置：我们用带有 .0 的浮点数来填满它，模拟没有小数点的“纯整型乘法”
# 比如每个权重都随机填 1.0 到 5.0 之间的整数
dummy_weight = np.random.randint(1, 5, (32, 3, 3, 3)).astype(np.float32)
dummy_bias = np.random.randint(0, 10, (32,)).astype(np.float32)

# 广播加法的输入：同样传一个整数值
dummy_add_input = np.array([10.0], dtype=np.float32)

# 3. 喂入输入字典
input_feed = {
    "input": dummy_input,
    "roi": dummy_roi,
    "scales": dummy_scales,
    "conv_weight": dummy_weight,
    "conv_bias": dummy_bias,
    "add_input": dummy_add_input,
}

print("--- 📌 1. 外部输入数据调试 ------------------------------------")
print(f"【输入 input】 形状: {input_feed['input'].shape} | 数据类型: {input_feed['input'].dtype}")
print(f"【输入 input】 : {input_feed['input']}")
print(f"【模拟整型卷积核权重】 权重块:\n{input_feed['conv_weight']}")
print(f"偏置块：\n{dummy_bias}")

# 4. 申请索要最终输出和中间卷积层的输出
output_names = ["output", "conv_output", "conv_input_u8"]

# 5. 跑通推理
res_output, res_conv_output, res_conv_input_u8 = session.run(output_names, input_feed)

print("--- 📌 经过 Resize 放大后的真实卷积输入 (第0通道左上角 3x3) ---")
print(res_conv_input_u8)

print("\n--- 📌 2. 运行时中间层与最终层数据追踪 -----------------------")
# 打印中间卷积层出来的数值（此时处于 FLOAT32 状态）
print(f"【中间卷积层 conv_output】 形状: {res_conv_output.shape} | 数据类型: {res_conv_output.dtype}")
print(f"【中间卷积层 conv_output】 加权和结果: {res_conv_output}")
np.savetxt("conv_output_full.txt", res_conv_output.flatten(), fmt="%.1f")
print("💾 完整卷积输出已写入本地 conv_output_full.txt！")

# 打印经过广播加法（+10.0）后的最终输出
print(f"【最终输出层 output】 形状: {res_output.shape} | 数据类型: {res_output.dtype}")
print(f"【最终输出层 output】 最终结果: {res_output}")

print("\n💡 验证加权和对齐: 最终输出的数值应该精准比卷积层大 10.0 (验证广播加法正确)")