Adaptiveavgpool2d does not support onnx export. Customize a class to replace adaptiveavgpool2d

AdaptiveAvgPool2D I won't support it onnx export , The export process will tell you ,onnx The dynamic operation barabara... Is not supported

I use it pp_liteseg Export to onnx Model , Are all the same ,paddle and Torch Of Adaptive Pool2D It's all dynamic ,onnx Not supported for the time being , I use the following formula , take AdaptiveAvgPool2D Changed , It can be used onnx It is derived that , But you need to specify the size of the original image , And the size of the output graph

$$\begin{array}{rl}hstart& =floor(i\ast H_{in}/H_{out})\\ hend& =ceil((i+1)\ast H_{in}/H_{out})\\ wstart& =floor(j\ast W_{in}/W_{out})\\ wend& =ceil((j+1)\ast W_{in}/W_{out})\\ Output(i,j)& =\frac{\sum Input[hstart:hend,wstart:wend]}{(hend-hstart)\ast (wend-wstart)}\end{array}$$
Reference from ：
AdaptiveAvgPool2D

class CostomAdaptiveAvgPool2D(nn.Layer):
    
    def __init__(self, output_size, input_size):
        
        super(CostomAdaptiveAvgPool2D, self).__init__()
        
        self.output_size = output_size
        self.input_size  = input_size
        
    def forward(self, x):
        
        H_in,  W_in  = self.input_size
        H_out, W_out = [self.output_size, self.output_size] \
                       if isinstance(self.output_size, int) \
                       else self.output_size
        
        out_i = []
        for i in range(H_out):
            out_j = []
            for j in range(W_out):
                
                hs = int(np.floor(i * H_in / H_out))
                he = int(np.ceil((i+1) * H_in / H_out))
                
                ws = int(np.floor(j * W_in / W_out))
                we = int(np.ceil((j+1) * W_in / W_out))
                
                # print(hs, he, ws, we)
                kernel_size = [he-hs, we-ws]
                
                out = F.avg_pool2d(x[:, :, hs:he, ws:we], kernel_size) 
                out_j.append(out)
                
            out_j = paddle.concat(out_j, -1)
            out_i.append(out_j)
            
        out_i = paddle.concat(out_i, -2)
        return out_i

use CostomAdaptiveAvgPool2D Exchange AdaptiveAvgPool2D, And you can specify the size of the original image and the output image

[14,14] Is the size of the input graph , This is me. pp_liteseg Input shape yes $224\times 224$, So on the upper floor shape yes

[-1, 512, 14, 14]

Then three at a time AdaptiveAvgPool2D become

[-1, 512,  1,   1]
[-1, 512,  2,   2]
[-1, 512,  4,   4]

then paddle2onnx Export it

paddle2onnx --model_dir . \
            --model_filename model.pdmodel \
            --params_filename model.pdiparams \
            --opset_version 11 \
            --save_file output.onnx