p2o 0.1.1

A PaddlePaddle New IR (PIR) to ONNX model converter.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use crate::helper;
use crate::proto::onnx;
use serde_json::Value;

impl super::super::Converter {
    pub fn op_conv2d_transpose(&mut self, op: &Value) -> anyhow::Result<()> {
        let inputs = helper::op_input_ids(op);
        if inputs.len() < 2 {
            anyhow::bail!("conv2d_transpose missing input/filter tensors");
        }
        // Paddle's 3rd input is output_size, not ONNX bias. A 4th input is bias.
        if inputs.len() >= 4 {
            anyhow::bail!(
                "ConvTranspose with bias as 4th input is not supported; \
                 use a separate Add node for bias"
            );
        }

        let mut onnx_node = onnx::NodeProto {
            op_type: "ConvTranspose".to_string(),
            input: vec![
                self.get_tensor_name(inputs[0])?,
                self.get_tensor_name(inputs[1])?,
            ],
            ..Default::default()
        };
        if let Some(attrs) = op.get("A") {
            onnx_node.attribute = self.extract_attributes("conv2d_transpose", attrs);
        }
        if let Some(output_size) = inputs
            .get(2)
            .and_then(|id| self.state.constants.get(id))
            .map(|vals| vals.iter().map(|&v| v as i64).collect::<Vec<_>>())
        {
            onnx_node
                .attribute
                .retain(|attr| attr.name.as_str() != "output_shape");
            onnx_node
                .attribute
                .push(helper::attr_ints("output_shape", &output_size));
        }
        let out_id = helper::op_out_id(op)?;
        onnx_node.output.push(self.get_tensor_name(out_id)?);
        self.onnx_graph.node.push(onnx_node);
        Ok(())
    }

    pub fn op_pool2d(&mut self, op: &Value) -> anyhow::Result<()> {
        let is_avg = helper::attr(op, "pooling_type").and_then(|d| d.as_str()) == Some("avg");
        let is_adaptive = helper::attr(op, "adaptive")
            .and_then(|d| d.as_bool())
            .unwrap_or(false);
        let is_global = helper::attr(op, "global_pooling")
            .and_then(|d| d.as_bool())
            .unwrap_or(false);

        let mut pool_type = if is_avg { "AveragePool" } else { "MaxPool" };
        let mut onnx_node = onnx::NodeProto {
            op_type: pool_type.to_string(),
            ..Default::default()
        };

        if let Some(attrs) = op.get("A") {
            onnx_node.attribute = self.extract_attributes("pool2d", attrs);
        }
        if self.target_opset < 10 {
            if helper::attr(op, "ceil_mode")
                .and_then(|d| d.as_bool())
                .unwrap_or(false)
            {
                anyhow::bail!("pool2d ceil_mode requires opset >= 10");
            }
            onnx_node
                .attribute
                .retain(|attr| attr.name.as_str() != "ceil_mode");
        }

        let inputs = helper::op_input_ids(op);
        if !inputs.is_empty() {
            onnx_node.input.push(self.get_tensor_name(inputs[0])?);

            let output_size = inputs
                .get(1)
                .and_then(|id| self.state.constants.get(id))
                .map(|vals| vals.iter().map(|&v| v as i64).collect::<Vec<_>>());
            let has_same_auto_pad = onnx_node
                .attribute
                .iter()
                .any(|attr| attr.name == "auto_pad" && attr.s == b"SAME_UPPER");
            let use_global_pool =
                is_global || (matches!(output_size.as_deref(), Some([1, 1])) && is_adaptive);

            if use_global_pool {
                pool_type = if is_avg {
                    "GlobalAveragePool"
                } else {
                    "GlobalMaxPool"
                };
                onnx_node.op_type = pool_type.to_string();
                onnx_node.attribute.clear();
            } else if is_adaptive {
                anyhow::bail!(
                    "adaptive pool2d only supports global output_size=[1,1]; non-global adaptive pooling requires derived kernel/stride"
                );
            } else if let Some(ksize) = output_size {
                if has_same_auto_pad && ksize == [1, 1] {
                    anyhow::bail!(
                        "pool2d with padding_algorithm=SAME does not support output_size=[1,1] unless adaptive=true"
                    );
                }
                onnx_node
                    .attribute
                    .push(helper::attr_ints("kernel_shape", &ksize));
            }
        }
        if is_avg
            && !helper::attr(op, "exclusive")
                .and_then(|d| d.as_bool())
                .unwrap_or(true)
        {
            onnx_node
                .attribute
                .push(helper::attr_int("count_include_pad", 1));
        }

        let out_id = helper::op_out_id(op)?;
        onnx_node.output.push(self.get_tensor_name(out_id)?);
        self.onnx_graph.node.push(onnx_node);
        Ok(())
    }
}