[Windows] 通过 infer_paddle_model_shape.py 修改 PP-OCRv5_mobile_det_infer 模型输入 shape 失败

[Melody-Zhou]

请将下面信息填写完整，便于我们快速解决问题，谢谢！

问题描述

运行提供的脚本文件 tools/paddle/infer_paddle_model_shape.py 修改 PP-OCRv5 文本检测模型的输入 shape 失败

更多信息 :

• 用于部署的推理引擎: tensorRT
• 为什么需要转换为ONNX格式：端侧部署，需要模型输入宽高静态
• Paddle2ONNX版本: 2.0.2rc1
• 你的联系方式(Email/Wechat/Phone):

报错截图

其他信息

• paddle2paddle 3.0.0.dev20250523
• paddlex 3.0.0

[Melody-Zhou]

我在调试时发现版本为 paddlepaddle==3.0.0.dev20250523 源码中，paddle.base.libpaddle.pir.Operation 对象确实没有 type 属性，接口如下所示：

class Operation:
    """
    
        In IR, all the operation are represented by Operation, and Operation
        is regarded as a build in an instruction of a Block. Users can call
        python api to describe their neural network.
    
        Notes:
            The constructor of operator should not be invoked directly. Use
            python api, for example: paddle.mean for building mean operation.
    
      
    """
    def __repr__(self) -> str:
        ...
    def as_if_op(self) -> typing.Any:
        ...
    def as_pylayer_op(self) -> typing.Any:
        ...
    def as_tuple_pop_op(self) -> typing.Any:
        ...
    def as_while_op(self) -> typing.Any:
        ...
    def attrs(self) -> dict:
        ...
    def blocks(self) -> typing.Any:
        ...
    def clone(self, arg0: IrMapping, arg1: CloneOptions) -> Operation:
        ...
    def copy_attrs_from(self, arg0: Operation) -> None:
        ...
    def erase(self) -> None:
        ...
    def erase_attr(self, arg0: str) -> None:
        ...
    def get_attr_names(self) -> list:
        ...
    def get_input_grad_semantics(self) -> list:
        ...
    def get_input_names(self) -> list:
        ...
    def get_output_intermediate_status(self) -> list:
        ...
    def get_output_names(self) -> list:
        ...
    def get_parent_block(self) -> Block:
        ...
    def has_attr(self, arg0: str) -> bool:
        ...
    def id(self) -> int:
        ...
    def int_attr(self, arg0: str) -> typing.Any:
        ...
    def is_no_need_buffer(self, arg0: Value) -> bool:
        ...
    def move_before(self, arg0: Operation) -> None:
        ...
    def name(self) -> str:
        ...
    def num_operands(self) -> int:
        ...
    def num_regions(self) -> int:
        ...
    def num_results(self) -> int:
        ...
    def operand(self, arg0: int) -> typing.Any:
        ...
    def operand_source(self, arg0: int) -> Value:
        ...
    def operands(self) -> list[typing.Any]:
        ...
    def operands_source(self) -> list:
        ...
    def replace_all_uses_with(self, arg0: list[Value]) -> None:
        ...
    def result(self, arg0: int) -> Value:
        ...
    def results(self) -> list:
        ...
    def set_bool_attr(self, arg0: str, arg1: bool) -> None:
        ...
    def set_execution_stream(self, arg0: str) -> None:
        ...
    def set_int_array_attr(self, arg0: str, arg1: list[int]) -> None:
        ...
    def set_int_attr(self, arg0: str, arg1: int) -> None:
        ...
    def set_scheduling_priority(self, arg0: int) -> None:
        ...
    def set_str_array_attr(self, arg0: str, arg1: list[str]) -> None:
        ...
    def set_str_attr(self, arg0: str, arg1: str) -> None:
        ...
    def str_attr(self, arg0: str) -> typing.Any:
        ...
    @property
    def callstack(self) -> list:
        ...
    @callstack.setter
    def callstack(self, arg1: list[str]) -> None:
        ...
    @property
    def chunk_id(self) -> typing.Any:
        ...
    @chunk_id.setter
    def chunk_id(self, arg1: int) -> None:
        ...
    @property
    def dist_attr(self) -> typing.Any:
        ...
    @dist_attr.setter
    def dist_attr(self, arg1: typing.Any) -> None:
        ...
    @property
    def op_role(self) -> typing.Any:
        ...
    @op_role.setter
    def op_role(self, arg1: int) -> None:
        ...

此外，还有一些其它的问题，例如：

AttributeError: 'paddle.base.libpaddle.pir.Block' object has no attribute 'var'

因此，我想知道 paddle2onnx==2.0.2rc1 版本下的 infer_paddle_model_shape.py 这个脚本是基于 paddlepaddle 哪个版本实现的

我在最新的 3.0 版本测试下发现无法正常运行。但是切换回 2.x（paddlepaddle==2.6.1） 版本由于最新的 paddle 模型存储方式发生了变化，提示 No such file or directory: 'PP-OCRv5_mobile_det_infer\\inference.pdmodel' 的错误

请问有没有一个比较好的解决方案呢？

期待回复，感谢

[qingyanbaby]

+1 遇到同样的问题。请问v5的模型，转onnx时，怎么修改输入shape

[qingyanbaby]

我现在的解决方案是转为onnx，再修改onnx的输入shape，测试没什么问题

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
ONNX模型修改工具
支持输入形状修改、节点插入、输出信息查看等功能
"""

import onnx
import onnx.helper as helper
from onnx.helper import TensorProto
import numpy as np
import argparse
import os
from typing import List, Dict, Tuple, Optional

def analyze_onnx_model(model_path: str):
    """分析ONNX模型的结构"""
    print(f"� 分析ONNX模型: {model_path}")
    print("=" * 60)
    
    try:
        model = onnx.load(model_path)
        
        # 检查模型有效性
        onnx.checker.check_model(model)
        print("✅ ONNX模型格式验证通过")
        
        # 显示基本信息
        print(f"�️  IR版本: {model.ir_version}")
        print(f"�️  Opset版本: {[opset.version for opset in model.opset_import]}")
        
        # 显示输入信息
        print("\n� 模型输入信息:")
        for i, input_info in enumerate(model.graph.input):
            name = input_info.name
            shape = []
            dtype = input_info.type.tensor_type.elem_type
            
            for dim in input_info.type.tensor_type.shape.dim:
                if dim.dim_value:
                    shape.append(dim.dim_value)
                elif dim.dim_param:
                    shape.append(f"'{dim.dim_param}'")
                else:
                    shape.append("?")
            
            dtype_name = TensorProto.DataType.Name(dtype)
            print(f"  {i+1}. {name}: {shape} ({dtype_name})")
        
        # 显示输出信息
        print("\n� 模型输出信息:")
        for i, output_info in enumerate(model.graph.output):
            name = output_info.name
            shape = []
            dtype = output_info.type.tensor_type.elem_type
            
            for dim in output_info.type.tensor_type.shape.dim:
                if dim.dim_value:
                    shape.append(dim.dim_value)
                elif dim.dim_param:
                    shape.append(f"'{dim.dim_param}'")
                else:
                    shape.append("?")
            
            dtype_name = TensorProto.DataType.Name(dtype)
            print(f"  {i+1}. {name}: {shape} ({dtype_name})")
        
        # 显示节点统计
        node_types = {}
        for node in model.graph.node:
            op_type = node.op_type
            node_types[op_type] = node_types.get(op_type, 0) + 1
        
        print(f"\n� 节点统计 (总共 {len(model.graph.node)} 个节点):")
        for op_type, count in sorted(node_types.items()):
            print(f"  {op_type}: {count}")
        
        return model
        
    except Exception as e:
        print(f"❌ 分析失败: {e}")
        return None

def modify_input_shapes(model: onnx.ModelProto, shape_dict: Dict[str, List[int]]) -> onnx.ModelProto:
    """修改ONNX模型的输入形状"""
    print(f"\n� 修改输入形状...")
    
    # 修改输入信息
    for input_info in model.graph.input:
        input_name = input_info.name
        if input_name in shape_dict:
            new_shape = shape_dict[input_name]
            print(f"� 修改 {input_name} 形状为: {new_shape}")
            
            # 清除原有维度
            input_info.type.tensor_type.shape.ClearField('dim')
            
            # 添加新维度
            for i, dim_size in enumerate(new_shape):
                dim = input_info.type.tensor_type.shape.dim.add()
                if dim_size == -1:
                    # 动态维度
                    dim.dim_param = f"dynamic_{input_name}_{i}"
                else:
                    # 固定维度
                    dim.dim_value = dim_size
    
    return model

def insert_reshape_node(model: onnx.ModelProto, 
                       target_input: str, 
                       new_shape: List[int],
                       reshape_name: str = "inserted_reshape") -> onnx.ModelProto:
    """在指定输入后插入Reshape节点"""
    print(f"\n� 在 {target_input} 后插入Reshape节点...")
    
    # 创建新的输入张量（原始输入）
    original_input_name = f"original_{target_input}"
    
    # 创建shape常量
    shape_tensor_name = f"{reshape_name}_shape"
    shape_tensor = helper.make_tensor(
        name=shape_tensor_name,
        data_type=TensorProto.INT64,
        dims=[len(new_shape)],
        vals=new_shape
    )
    
    # 添加shape常量到initializer
    model.graph.initializer.append(shape_tensor)
    
    # 创建Reshape节点
    reshape_node = helper.make_node(
        'Reshape',
        inputs=[original_input_name, shape_tensor_name],
        outputs=[target_input],
        name=reshape_name
    )
    
    # 找到原始输入
    original_input = None
    for i, input_info in enumerate(model.graph.input):
        if input_info.name == target_input:
            original_input = input_info
            # 修改输入名称
            original_input.name = original_input_name
            break
    
    if original_input is None:
        raise ValueError(f"未找到输入: {target_input}")
    
    # 创建新的输出张量信息（用于Reshape的输出）
    reshaped_output = helper.make_tensor_value_info(
        target_input,
        original_input.type.tensor_type.elem_type,
        new_shape
    )
    
    # 在模型开始处插入Reshape节点
    model.graph.node.insert(0, reshape_node)
    
    print(f"✅ 成功插入Reshape节点: {original_input_name} -> {target_input}")
    return model

def add_dynamic_batch_support(model: onnx.ModelProto, batch_input_names: List[str] = None) -> onnx.ModelProto:
    """为指定输入添加动态batch支持"""
    print(f"\n� 添加动态batch支持...")
    
    for input_info in model.graph.input:
        input_name = input_info.name
        
        # 如果指定了特定输入名称，只处理这些输入
        if batch_input_names and input_name not in batch_input_names:
            continue
            
        # 修改第一个维度为动态
        if len(input_info.type.tensor_type.shape.dim) > 0:
            first_dim = input_info.type.tensor_type.shape.dim[0]
            first_dim.ClearField('dim_value')
            first_dim.dim_param = f"batch_size"
            print(f"� {input_name} 的batch维度设为动态")
    
    return model

def optimize_model(model: onnx.ModelProto) -> onnx.ModelProto:
    """优化ONNX模型"""
    print(f"\n� 优化ONNX模型...")
    
    try:
        # 使用ONNX的内置优化
        from onnx import optimizer
        
        # 可用的优化passes
        passes = [
            'eliminate_deadend',
            'eliminate_identity',
            'eliminate_nop_dropout',
            'eliminate_nop_pad',
            'eliminate_unused_initializer',
            'extract_constant_to_initializer',
            'fuse_add_bias_into_conv',
            'fuse_bn_into_conv',
            'fuse_consecutive_concats',
            'fuse_consecutive_reduce_unsqueeze',
            'fuse_consecutive_squeezes',
            'fuse_consecutive_transposes',
            'fuse_matmul_add_bias_into_gemm',
            'fuse_pad_into_conv',
            'fuse_transpose_into_gemm',
        ]
        
        # 应用优化
        optimized_model = optimizer.optimize(model, passes)
        print(f"✅ 模型优化完成")
        return optimized_model
        
    except ImportError:
        print("⚠️  onnx.optimizer不可用，跳过优化")
        return model
    except Exception as e:
        print(f"⚠️  优化失败: {e}")
        return model

def validate_modified_model(model: onnx.ModelProto) -> bool:
    """验证修改后的模型"""
    print(f"\n� 验证修改后的模型...")
    
    try:
        onnx.checker.check_model(model)
        print("✅ 模型验证通过")
        return True
    except Exception as e:
        print(f"❌ 模型验证失败: {e}")
        return False

def test_model_inference(model_path: str, input_shapes: Dict[str, List[int]]):
    """测试模型推理"""
    print(f"\n� 测试模型推理...")
    
    try:
        import onnxruntime as ort
        
        # 创建推理会话
        sess = ort.InferenceSession(model_path)
        
        # 获取输入信息
        input_names = [input.name for input in sess.get_inputs()]
        print(f"� 模型输入: {input_names}")
        
        # 创建测试数据
        feed_dict = {}
        for input_name in input_names:
            input_shape = None
            
            # 从指定形状中获取
            if input_name in input_shapes:
                input_shape = input_shapes[input_name]
            else:
                # 从模型中获取
                for input_info in sess.get_inputs():
                    if input_info.name == input_name:
                        input_shape = input_info.shape
                        break
            
            if input_shape:
                # 替换动态维度
                test_shape = []
                for dim in input_shape:
                    if isinstance(dim, str) or dim == -1:
                        test_shape.append(1)
                    else:
                        test_shape.append(dim)
                
                test_data = np.random.random(test_shape).astype(np.float32)
                feed_dict[input_name] = test_data
                print(f"� 测试数据 {input_name}: {test_shape}")
        
        # 执行推理
        outputs = sess.run(None, feed_dict)
        print(f"✅ 推理成功，输出数量: {len(outputs)}")
        
        for i, output in enumerate(outputs):
            print(f"  输出 {i}: {output.shape}")
        
        return True
        
    except ImportError:
        print("⚠️  onnxruntime未安装，跳过推理测试")
        return True
    except Exception as e:
        print(f"❌ 推理测试失败: {e}")
        return False

def main():
    parser = argparse.ArgumentParser(description="ONNX模型修改工具")
    parser.add_argument("--input_model", required=True, help="输入ONNX模型路径")
    parser.add_argument("--output_model", help="输出ONNX模型路径")
    parser.add_argument("--analyze_only", action="store_true", help="仅分析模型，不进行修改")
    parser.add_argument("--input_shapes", help="输入形状字典，JSON格式")
    parser.add_argument("--insert_reshape", help="插入Reshape节点，格式: input_name:shape")
    parser.add_argument("--dynamic_batch", action="store_true", help="添加动态batch支持")
    parser.add_argument("--optimize", action="store_true", help="优化模型")
    parser.add_argument("--test_inference", action="store_true", help="测试推理")
    
    args = parser.parse_args()
    
    # 检查输入文件
    if not os.path.exists(args.input_model):
        print(f"❌ 输入文件不存在: {args.input_model}")
        return
    
    # 分析模型
    model = analyze_onnx_model(args.input_model)
    if model is None:
        return
    
    # 如果只是分析，直接返回
    if args.analyze_only:
        return
    
    # 解析输入形状
    input_shapes = {}
    if args.input_shapes:
        try:
            import json
            input_shapes = json.loads(args.input_shapes.replace("'", '"'))
            print(f"� 指定的输入形状: {input_shapes}")
        except Exception as e:
            print(f"❌ 输入形状解析失败: {e}")
            return
    
    # 修改输入形状
    if input_shapes:
        model = modify_input_shapes(model, input_shapes)
    
    # 插入Reshape节点
    if args.insert_reshape:
        try:
            parts = args.insert_reshape.split(':')
            if len(parts) != 2:
                raise ValueError("格式错误")
            
            input_name = parts[0]
            shape_str = parts[1]
            new_shape = [int(x) for x in shape_str.strip('[]').split(',')]
            
            model = insert_reshape_node(model, input_name, new_shape)
        except Exception as e:
            print(f"❌ 插入Reshape节点失败: {e}")
            return
    
    # 添加动态batch支持
    if args.dynamic_batch:
        model = add_dynamic_batch_support(model)
    
    # 优化模型
    if args.optimize:
        model = optimize_model(model)
    
    # 验证模型
    if not validate_modified_model(model):
        print("❌ 模型验证失败，停止保存")
        return
    
    # 保存模型
    output_path = args.output_model or args.input_model.replace('.onnx', '_modified.onnx')
    
    try:
        onnx.save_model(model, output_path)
        print(f"✅ 修改后的模型已保存: {output_path}")
        
        # 检查文件大小
        input_size = os.path.getsize(args.input_model) / (1024 * 1024)
        output_size = os.path.getsize(output_path) / (1024 * 1024)
        print(f"� 原模型大小: {input_size:.2f} MB")
        print(f"� 新模型大小: {output_size:.2f} MB")
        
        # 测试推理
        if args.test_inference:
            test_model_inference(output_path, input_shapes)
        
    except Exception as e:
        print(f"❌ 保存模型失败: {e}")

if __name__ == "__main__":
    main() 

[Melody-Zhou]

@qingyanbaby

我有试过你的脚本或者通过 onnxruntime 的 API 接口来直接修改导出的 onnx 的输入 shape：

python -m onnxruntime.tools.make_dynamic_shape_fixed --input_name x --input_shape 1,3,640,640 models\PP-OCRv5_mobile_det_infer_onnx\inference.onnx static.onnx

导出的 ONNX 如下所示：

感觉上仅仅简单修改了输入的 shape 并没有 forward 一遍，导致各个节点的 shape 没有 trace，输出的 shape 也是未知的，不像我之前利用 infer_paddle_model_shape.py 脚本修改 PP-OCRv4 模型那样，之前修改后的 ONNX 如下图所示：

我不知道这种方法修改的 shape 对于后续部署是否存在影响，还没测试过

此外，我利用 onnx-simplify 简化导出的 onnx 模型时出现了如下错误：

RuntimeError: Your model ir_version 11 is higher than the checker's (10).

似乎导出的 PP-OCRv5 的 ONNX 模型 IR 版本是 v11，而最新的 onnx-simplify 支持的 IR 版本是 v10，但是 paddle2onnx 似乎没有控制 IR 版本的参数。我又看了下之前 PP-OCRv4 的 ONNX 模型的 IR 版本是 8

目前是有这些问题，还没有头绪