mindspore 版 AdaptiveAvgPool2d 替代方案参考

最新推荐文章于 2024-02-06 11:43:53 发布
最新推荐文章于 2024-02-06 11:43:53 发布
阅读量642 收藏 1
点赞数
原文链接：https://bbs.huaweicloud.com/forum/thread-123473-1-1.html
版权

转载地址：https://bbs.huaweicloud.com/forum/thread-123473-1-1.html

作者： luxuff

前言

最近用 mindspore 复现 Fast SCNN 网络的时候，里面用到了一个自适应平均池化算子 “nn.AdaptiveAvgPool2d”，但是 mindspore 目前的版本还没有提供对应的算子供开发者使用，所以笔者查阅了一部分资料，了解了其计算原理。实验结果表明，下述方法可以替代 AdaptiveAvgPool2d 算子，可以此为基础迁移至其他 AI 框架(比如mindspore、tensorflow)中。

一、AdaptiveAvgPool2d

AdaptiveAvgPool2d 的功能简单来讲就是，开发者只需要传入“待处理数据” 和 “目标大小”，该算子会自动计算池化操作时的kernel_size和stride等数据，使得输出结果的shape为“目标大小”。

但其实上述理解是不完全正确的，甚至是错误的。基于此理解可以稍微理解其功能，但是如果想对其进行复现，则会完全陷入误区。

目前普遍存在的一种复现方式是，既然我们知道普通池化操作的计算过程是：

已知池化层的kernel_size、padding、stride 以及输入张量的大小input_size，则输出张量大小 output_size 为：

    output_size =（input_size+2*padding-kernel_size）/stride +1

（此处简化了计算，如果输入张量的 column 值和 row 值不等，则分别计算）

那么我们就想办法通过 input_size 和 output_size 反推出 kernel_size、stride 等数值就好了，反向回去计算一定可以得到我们需要的数据。

但其实这种方法仅合其形，不对其意。我们只能使得输出张量是我们需要的“目标大小”，其内部数值却和 “nn.AdaptiveAvgPool2d” 的计算结果有不小差异，究其原因，在于出发点的错误。

二、AdaptiveAvgPool2d 计算原理

笔者翻阅了不少资料，最终在https://discuss.pytorch.org/t/what-is-adaptiveavgpool2d/26897 找到了我需要的内容。其中 Thomas 对AdaptiveAvgPool2d 做了相当准确的解释，我将其分享的代码改进为了 NCHW 的模式：

import torch.nn as nn
import torch

def torch_pool(inputs, target_size):
    #NCHW
    H = target_size[0]
    W = target_size[1]
    s_p1 = (torch.arange(W, dtype=torch.float32) * (inputs.size(-1) / W)).long()
    e_p1 = ((torch.arange(W, dtype=torch.float32)+1) * (inputs.size(-1) / W)).ceil().long()

    s_p2 = (torch.arange(H, dtype=torch.float32) * (inputs.size(-2) / H)).long()
    e_p2 = ((torch.arange(H, dtype=torch.float32)+1) * (inputs.size(-2) / H)).ceil().long()

    pooled2 = []
    for i_H in range(H):
      pooled = []
      for i_W in range(W):
          res = torch.mean(inputs[:, :, s_p2[i_H]:e_p2[i_H],s_p1[i_W]:e_p1[i_W]], dim=(-2,-1), keepdim=True)
          pooled.append(res)
      pooled = torch.cat(pooled, -1)
      pooled2.append(pooled)
    pooled2 = torch.cat(pooled2,-2)
    return pooled2

if __name__ == '__main__':

    data = [[[[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]]
              ,
            [[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]]
              ]]

    inputs = torch.tensor(data,dtype=torch.float32)
    print(inputs)
    print(inputs.size())
    print("*********************************")

    avgpool1 = torch_pool(inputs, (1,3))
    avgpool2 = torch_pool(inputs, (2,3))
    avgpool3 = torch_pool(inputs, (3,3))
    avgpool6 = torch_pool(inputs, (6,5))

    print(avgpool1)
    print("*********************************")
    print(avgpool2)
    print("*********************************")
    print(avgpool3)
    print("*********************************")
    print(avgpool6)

计算结果：

tensor([[[[2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.]],

         [[2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.]]]])
torch.Size([1, 2, 6, 8])
*********************************
tensor([[[[3., 6., 8.]],

         [[3., 6., 8.]]]])
*********************************
tensor([[[[3., 6., 8.],
          [3., 6., 8.]],

         [[3., 6., 8.],
          [3., 6., 8.]]]])
*********************************
tensor([[[[3., 6., 8.],
          [3., 6., 8.],
          [3., 6., 8.]],

         [[3., 6., 8.],
          [3., 6., 8.],
          [3., 6., 8.]]]])
*********************************
tensor([[[[2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000]],

         [[2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000]]]])

与 pytorch 的 nn.AdaptiveAvgPool2d 算子进行对比验证：

import torch.nn as nn
import torch

if __name__ == '__main__':

    data = [[[[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]]
              ,
            [[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]
              ,[2,3,4,5,6,9,7,8]]
              ]]

    x = torch.tensor(data,dtype=torch.float32)
    print(x)
    print(x.size())
    print("*********************************")

    avgpool1 = nn.AdaptiveAvgPool2d((1,3))
    avgpool2 = nn.AdaptiveAvgPool2d((2,3))
    avgpool3 = nn.AdaptiveAvgPool2d((3,3))
    avgpool6 = nn.AdaptiveAvgPool2d((6,5))
    print(avgpool1(x))
    print("*********************************")
    print(avgpool2(x))
    print("*********************************")
    print(avgpool3(x))
    print("*********************************")
    print(avgpool6(x))

计算结果：

tensor([[[[2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.]],

         [[2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.],
          [2., 3., 4., 5., 6., 9., 7., 8.]]]])
torch.Size([1, 2, 6, 8])
*********************************
tensor([[[[3., 6., 8.]],

         [[3., 6., 8.]]]])
*********************************
tensor([[[[3., 6., 8.],
          [3., 6., 8.]],

         [[3., 6., 8.],
          [3., 6., 8.]]]])
*********************************
tensor([[[[3., 6., 8.],
          [3., 6., 8.],
          [3., 6., 8.]],

         [[3., 6., 8.],
          [3., 6., 8.],
          [3., 6., 8.]]]])
*********************************
tensor([[[[2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000]],

         [[2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000],
          [2.5000, 4.0000, 5.5000, 7.3333, 7.5000]]]])

可以发现，无论是输出 shape 还是 Tensor 内部数值，二者都是一样的。

而且无论改变 NCHW 的哪一部分内容，扩充 N、C、H、W 的任意一维，最后的计算结果都是保持一致的。

三、AdaptiveAvgPool2d 计算原理详解

待补充。

至此，探究明白了 “nn.AdaptiveAvgPool2d” 的内部计算原理。并可以此为基础迁移至其他 AI 框架中。

四、mindspore版 AdaptiveAvgPool2d

观察上述代码，如果要重写成mindspore版的代码，我们只需要替换掉‘torch.arange’、‘torch.mean’、‘torch.cat’这三个主要算子，以及添加一个取整操作，在mindspore中就是ops.ReduceMean(keep_dims=True)、P.Concat(axis=-1)等算子，只要做对应替换就可以了。
但我之前在重写 res = torch.mean(inputs[:, :, s_p2[i_H]:e_p2[i_H],s_p1[i_W]:e_p1[i_W]], dim=(-2,-1), keepdim=True)这一句时，发现mindspore对‘变量下标’做切片操作时会发生异常，不太清楚是不是我的用法有问题。不过我写了一个临时的版本，比如如果要将NCx32x64的数据池化成NCx6x6大小,我们可以提前计算出需要切片的下标，就可以得到这样一版可用的代码了：

def _AvgPool2d6x6(self,x):
        s_p1 = [ 0, 10, 21, 32, 42, 53]
        e_p1 = [11, 22, 32, 43, 54, 64]
        s_p2 = [ 0,  5, 10, 16, 21, 26]
        e_p2 = [ 6, 11, 16, 22, 27, 32]       
        pooled2 = []
        for i_H in range(6):
          pooled = []
          for i_W in range(6):
              res = self.reduceMean(x[:, :, s_p2[i_H]:e_p2[i_H],s_p1[i_W]:e_p1[i_W]], (-2,-1))
              pooled.append(res)
          pooled = self.concat1((pooled[0],pooled[1],pooled[2],pooled[3],pooled[4],pooled[5]))
          pooled2.append(pooled)
        pooled2 = self.concat2((pooled2[0],pooled2[1],pooled2[2],pooled2[3],pooled2[4],pooled2[5]))       
        return pooled2

原载于http://luxuff.cn ，作者还是我自己。
转载请注明出处。

Beef_EATER
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AdaptiveAvgPool2D 不支持 onnx 导出，自定义一个类代替 AdaptiveAvgPool2D
先说一下，就简单地写点儿氵文，不是博客，只是我的笔记本
06-21 2938
AdaptiveAvgPool2D 不支持 onnx 导出，导出过程会告诉你，onnx不支持那个动态操作巴拉巴拉我用的是 pp_liteseg 导出为 onnx 模型，都一样，paddle和Torch的 Adaptive Pool2D 都是动态的，onnx暂时都不支持，我根据下述公式，将 AdaptiveAvgPool2D 改了，可以用onnx导出了，但是需要指定一下原图的大小，和输出图的大小hstart=floor(i∗Hin/Hout)hend=ceil((i+1)∗Hin/Hout)wstart=f
nn.AdaptiveAvgPool2d和nn.AvgPool2d的区别
AI浩
12-21 2587
功能：该函数与二维平均池化运算类似，区别主要体现在自适应上，对于任何输入大小，输出大小均为指定的H×W大小。output_size：指定的输出大小，可以是元组(H，W)，或者是单个的数，如果是单个的数，则表示输出的高和宽尺寸一样，output_size大小可以大于输入的图片尺寸大小。
nn.AdaptiveAvgPool2d() 与 nn.AvgPool2d() 模块的区别
热门推荐
qq_34706871的博客
10-13 4万+
两者都是做二维的平均池化，但是它们关注的参数却不一样。 1、nn.AvgPool2d() 模块 模块原型为 其中参数为 一般我们使用它的时候，只需要关注 kernel_size 、stride 与 padding 三个参数就行了，最后输出的尺寸为： 其中，x 表示输入的维度大小， y 表示对应输出的维度大小。 2、nn.AdaptiveAvgPool2d() 模块 ...
tensorflow改写torch的AdaptiveAvgPool2d
qq_39321513的博客
07-19 873
通过对比pytorch的tensor和tensorflow的tensor可以验证改写成功，只不过精度有点区别。
MindSpore实现AdaptiveAvgPool2d
wan_15的博客
07-30 949
MindSpore实现AdaptiveAvgPool2d
pytorch torch.nn.AdaptiveAvgPool2d()自适应平均池化函数详解
12-23
AdaptiveAvgPool2d CLASStorch.nn.AdaptiveAvgPool2d(output_size)[SOURCE] Applies a 2D adaptive average pooling over an input signal composed of several input planes. The output is of size H x W, for ...
2d横版游戏Demo
08-09
Unity3D开发的一个2d横版游戏demo源码，可动态更改材质，Unity3D开发2d游戏同样很强大。画质什么都比较好
Direct2D API参考
11-26
完全来自于微软官网，作者只是收集整理了一下，方便大家使用
java版JBox2D文档详解.doc
02-01
java版JBox2D文档详解，摘录于 《android游戏开发大全》JBOX2D篇，供参考
AdaptiveAvgPool2d理解（中网、外网整合)
xiyou__的博客
11-12 2万+
结合中网和外网关于pytorch的AdaptiveAvg2d的优秀解答，并结合自己的理解，分析了AdaptiveAvg2d和一般池化的区别，并举实例帮助理解。
MSAdapter，一款高效迁移PyTorch代码到昇思MindSpore生态的适配工具
Kenji_Shinji的博客
04-13 496
下面以AlexNet模型为例，训练CIFAR10数据集的PyTorch代码转到MSAdapter代码，完整的代码可以从MSAdapterModelZoo获取（https://openi.pcl.ac.cn/OpenI/MSAdapterModelZoo/src/branch/master/official/cv/alexnet）为了帮助用户高效迁移PyTorch代码到昇思MindSpore生态，昇思MindSpore和鹏城实验室联合开发的一款昇思MindSpore生态适配工具——MSAdapter。
AdaptiveAvgPool2d的学习笔记
墨门
05-11 3495
1 致谢 感谢 Thomas V的解答，请参阅《AdaptiveAvgPool2d In More Detail | Thomas V》～ 2 AdaptiveAvgPool2d: torch.nn.AdaptiveAvgPool2d 对于AdaptiveAvgPool2d算法，它跟GAP算法是十分类似的，其优点在于：可以将特征图resize到给定的输出尺寸，这一点跟F.interpolate()比较类似，不过这里的元素聚合的方式用的是pool操作； 具体来说，AdaptiveAvgPool2d首
关于pytorch转onnx经常出现的问题
Mr_health的博客
07-25 1974
关于pytorch转onnx经常出现的问题
常见的几种池化操作：MaxPool2d/AdaptiveMaxPool2d/AvgPool2d/AdaptiveAvgPool2d...（Pytorch）
NorthSmile的博客
09-01 8886
case3：output_size=（H_out,None）或output_size=（None,W_out），此时指定为None的维度与输入中保持一致，既output_size=（H_out,None）时W_out=W_in；case3：output_size=（H_out,None）或output_size=（None,W_out），此时指定为None的维度与输入中保持一致，既output_size=（H_out,None）时W_out=W_in；因为执行的是最大池化操作，所以在填充时使用负无穷。
Pytorch自适应平均池化工作原理（AdaptiveAvgPool2d无法导出ONNX，寻找替换方法）
最新发布
q852474220的博客
02-06 1366
​自适应平均池化是一种池化方法，可以在不同大小的输入中自适应地对每个位置进行平均池化。与传统的平均池化方法不同，自适应平均池化不需要指定池化核的大小，而是通过输出的大小来决定池化的大小和步幅。自适应平均池化的输出形状可以由用户指定，因此可以用于任何大小的输入。这使得自适应平均池化在处理不同大小的输入时非常有用。根据上述数据相信你已经有了自己的答案，自适应池化不能导出的原因是因为输出特征图比输入大，ONNX没有相应的池化算子，下面链接的方法把paddle换成torch,Layer换成Module可以运行。
nn.AdaptiveAvgPool2d() 与 nn.AvgPool2d() 模块各自的用途
qq_37297763的博客
12-16 3264
首先介绍一下我为啥会关注到这个问题，因为我在使用加了SE模块的Resnet的时候，程序出bug了，原来问题出在我使用了nn.AvgPool2d() ，而应该使用nn.AdaptiveAvgPool2d() 。 1. 问题 下边是我写的SEResnet模块的代码，然后我会贴出我程序报的错误： class SEResNet(nn.Module): def __init__(self, block, layers, num_classes=1000): self.inplanes = 6
[开发技巧]·AdaptivePooling与Max/AvgPooling相互转换
简明AI工作室
04-22 1万+
[开发技巧]·AdaptivePooling与Max/AvgPooling相互转换 个人网站-->http://www.yansongsong.cn 1.问题描述 自适应池化Adaptive Pooling是PyTorch的一种池化层，根据1D，2D，3D以及Max与Avg可分为六种形式。 自适应池化Adaptive Pooling与标准的Max/AvgPooling区别在于，...
nn.AdaptiveAvgPool2d
芒果干的博客
11-06 1万+
torch.nn.AdaptiveAvgPool2d torch.nn.AdaptiveAvgPool2d(output_size) output_size：可以为tuple类型(H, W)，也可以为一个数字H表示(H, H)，H,W可以为int或者None类型，如果是None默认与输入相同大小 二维平均自适应池化，只需要给出输出的参数就可以自动寻找相应的kernal size以及stride Applies a 2D adaptive average pooling over an input si
AdaptiveAvgPool2d
05-26
AdaptiveAvgPool2d是PyTorch中的一个操作，用于对输入的二维张量进行自适应平均池化（adaptive average pooling）。与传统的平均池化不同，自适应平均池化的输出大小不是固定的，而是由输入的大小和期望输出的大小来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值