• 2021-09-30 10:48:39

日常学习，给自己挖坑，and造轮子

class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
如下是MaxPool2d的解释：

class MaxPool2d(_MaxPoolNd):
r"""Applies a 2D max pooling over an input signal composed of several input
planes.

In the simplest case, the output value of the layer with input size :math:(N, C, H, W),output :math:(N, C, H_{out}, W_{out}) and :attr:kernel_size :math:(kH, kW)can be precisely described as:

.. math::
\begin{aligned}
out(N_i, C_j, h, w) ={} & \max_{m=0, \ldots, kH-1} \max_{n=0, \ldots, kW-1} \\
& \text{input}(N_i, C_j, \text{stride[0]} \times h + m,
\text{stride[1]} \times w + n)
\end{aligned}

If :attr:padding is non-zero, then the input is implicitly zero-padded on both sides
for :attr:padding number of points. :attr:dilation controls the spacing between the kernel points.
It is harder to describe, but this link_ has a nice visualization of what :attr:dilation does.

The parameters :attr:kernel_size, :attr:stride, :attr:padding, :attr:dilation can either be:

- a single int -- in which case the same value is used for the height and width dimension
- a tuple of two ints -- in which case, the first int is used for the height dimension, and the second int for the width dimension

Args:
kernel_size: the size of the window to take a max over
stride: the stride of the window. Default value is :attr:kernel_size
dilation: a parameter that controls the stride of elements in the window
return_indices: if True, will return the max indices along with the outputs.
Useful for :class:torch.nn.MaxUnpool2d later
ceil_mode: when True, will use ceil instead of floor to compute the output shape

Shape:
- Input: :math:(N, C, H_{in}, W_{in})
- Output: :math:(N, C, H_{out}, W_{out}), where

.. math::
H_{out} = \left\lfloor\frac{H_{in} + 2 * \text{padding[0]} - \text{dilation[0]}
\times (\text{kernel\_size[0]} - 1) - 1}{\text{stride[0]}} + 1\right\rfloor

.. math::
W_{out} = \left\lfloor\frac{W_{in} + 2 * \text{padding[1]} - \text{dilation[1]}
\times (\text{kernel\_size[1]} - 1) - 1}{\text{stride[1]}} + 1\right\rfloor

Examples::

>>> # pool of square window of size=3, stride=2
>>> m = nn.MaxPool2d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.MaxPool2d((3, 2), stride=(2, 1))
>>> input = torch.randn(20, 16, 50, 32)
>>> output = m(input)

"""

def forward(self, input):
return F.max_pool2d(input, self.kernel_size, self.stride,
self.return_indices)



大致解释为：
在由多个输入通道组成的输入信号上应用2D max池。

在最简单的情况下，具有输入大小的层的输出值：(N, C, H, W)
输出：(N, C, H_{out}, W_{out})kernel_size，和 (kH, kW)可以准确地描述为：

out(N_i, C_j, h, w) ={} & \max_{m=0, \ldots, kH-1} \max_{n=0, \ldots, kW-1} \\
& \text{input}(N_i, C_j, \text{stride[0]} \times h + m,
\text{stride[1]} \times w + n)


如果 padding 非零，那么输入的两边都隐式地被0填充；dilation用于控制内核点之间的距离
这里很好地展示了 diagration 的作用。

这些参数：kernel_sizestridepadding, ，dilation 可以为：
-单个int值–在这种情况下，高度和宽度标注使用相同的值
-两个整数组成的数组——在这种情况下，第一个int用于高度维度，第二个int表示宽度

参数：

kernel_size(int or tuple) ：max pooling的窗口大小
stride(int or tuple, optional)：max pooling的窗口移动的步长。默认值是kernel_size
padding(int or tuple, optional) ：输入的每一条边补充0的层数
dilation(int or tuple, optional)：一个控制窗口中元素步幅的参数
return_indices ：如果等于True，会返回输出最大值的序号，对于上采样操作会有帮助
ceil_mode ：如果等于True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作

Shape:
- Input: :math:(N, C, H_{in}, W_{in})
- Output: :math:(N, C, H_{out}, W_{out}), where

.. math::
H_{out} = \left\lfloor\frac{H_{in} + 2 * \text{padding[0]} - \text{dilation[0]}
\times (\text{kernel\_size[0]} - 1) - 1}{\text{stride[0]}} + 1\right\rfloor

.. math::
W_{out} = \left\lfloor\frac{W_{in} + 2 * \text{padding[1]} - \text{dilation[1]}
\times (\text{kernel\_size[1]} - 1) - 1}{\text{stride[1]}} + 1\right\rfloor

Examples::

>>> # pool of square window of size=3, stride=2
>>> m = nn.MaxPool2d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.MaxPool2d((3, 2), stride=(2, 1))
>>> input = torch.randn(20, 16, 50, 32)
>>> output = m(input)

更多相关内容
• nn.MaxPool2d(kernel_size=2, stride=(2, 1), padding=(0, 0))， 这样在用交叉熵做损失函数的时候，有时候会出现loss为nan的情况，检查的时候发现，某些样本的提取出来的feature全为nan。 以上这篇浅谈pytorch池化...
• ## MaxPool2d

千次阅读 2022-02-15 20:54:33
(kernel_size, stride=None, padding=0, dilation=1,...) kernel_size：卷积核大小 stride：官方定义stride=传入的stride参数或者stride=kernel_size

kernel_size：卷积核大小

stride：官方定义stride=传入的stride参数或者stride=kernel_size

展开全文
• ## torch.nn.MaxPool2d详解

万次阅读 多人点赞 2020-11-22 20:18:38
_) class MaxPool2d(_MaxPoolNd): kernel_size: _size_2_t stride: _size_2_t padding: _size_2_t dilation: _size_2_t def forward(self, input: Tensor) -> Tensor: return F.max_pool2d(input, self.kernel_size,...

注意：这里展示的是本篇博文写时的版本最新的实现，但是后续会代码可能会迭代更新，建议对照官方文档进行学习。

先来看源码：

# 这个类是是许多池化类的基类，这里有必要了解一下
class _MaxPoolNd(Module):
__constants__ = ['kernel_size', 'stride', 'padding', 'dilation',
'return_indices', 'ceil_mode']
return_indices: bool
ceil_mode: bool
# 构造函数，这里只需要了解这个初始化函数即可。
def __init__(self, kernel_size: _size_any_t, stride: Optional[_size_any_t] = None,
padding: _size_any_t = 0, dilation: _size_any_t = 1,
return_indices: bool = False, ceil_mode: bool = False) -> None:
super(_MaxPoolNd, self).__init__()
self.kernel_size = kernel_size
self.stride = stride if (stride is not None) else kernel_size
self.dilation = dilation
self.return_indices = return_indices
self.ceil_mode = ceil_mode

def extra_repr(self) -> str:
', dilation={dilation}, ceil_mode={ceil_mode}'.format(**self.__dict__)

class MaxPool2d(_MaxPoolNd):
kernel_size: _size_2_t
stride: _size_2_t
dilation: _size_2_t

def forward(self, input: Tensor) -> Tensor:
return F.max_pool2d(input, self.kernel_size, self.stride,
self.return_indices)


MaxPool2d 这个类的实现十分简单。

我们先来看一下基本参数，一共六个：

1. kernel_size ：表示做最大池化的窗口大小，可以是单个值，也可以是tuple元组
2. stride ：步长，可以是单个值，也可以是tuple元组
3. padding ：填充，可以是单个值，也可以是tuple元组
4. dilation ：控制窗口中元素步幅
5. return_indices ：布尔类型，返回最大值位置索引
6. ceil_mode ：布尔类型，为True，用向上取整的方法，计算输出形状；默认是向下取整。

关于 kernel_size 的详解

注意这里的 kernel_size 跟卷积核不是一个东西。 kernel_size 可以看做是一个滑动窗口，这个窗口的大小由自己指定，如果输入是单个值，例如 3 3 ，那么窗口的大小就是 3 × 3 3 \times 3 ，还可以输入元组，例如 (3, 2) ，那么窗口大小就是 3 × 2 3 \times 2

最大池化的方法就是取这个窗口覆盖元素中的最大值。

关于 stride 的详解

上一个参数我们确定了滑动窗口的大小，现在我们来确定这个窗口如何进行滑动。如果不指定这个参数，那么默认步长跟最大池化窗口大小一致。如果指定了参数，那么将按照我们指定的参数进行滑动。例如 stride=(2,3) ， 那么窗口将每次向右滑动三个元素位置，或者向下滑动两个元素位置。

关于 padding 的详解

这参数控制如何进行填充，填充值默认为0。如果是单个值，例如 1，那么将在周围填充一圈0。还可以用元组指定如何填充，例如 p a d d i n g = ( 2 , 1 ) padding=(2, 1) ，表示在上下两个方向个填充两行0，在左右两个方向各填充一列0。

关于 dilation 的详解

不会

关于 return_indices 的详解

这是个布尔类型值，表示返回值中是否包含最大值位置的索引。注意这个最大值指的是在所有窗口中产生的最大值，如果窗口产生的最大值总共有5个，就会有5个返回值。

关于 ceil_mode 的详解

这个也是布尔类型值，它决定的是在计算输出结果形状的时候，是使用向上取整还是向下取整。怎么计算输出形状，下面会讲到。一看就知道了。

——————————————参数解析结束分界线——————————————

最大池化层输出形状计算
H o u t = ⌊ H i n + 2 × p a d d i n g ⌊ 0 ⌋ − d i l a t i o n ⌊ 0 ⌋ × ( k e r n e l _ s i z e ⌊ 0 ⌋ − 1 ) − 1 s t r i d e ⌊ 0 ⌋ + 1 ⌋ H_{out}=\lfloor \frac{H_{in} + 2 \times padding\lfloor 0 \rfloor - dilation \lfloor 0 \rfloor \times (kernel\_size\lfloor 0 \rfloor - 1)-1}{stride\lfloor 0 \rfloor} + 1 \rfloor

W o u t = ⌊ W i n + 2 × p a d d i n g ⌊ 1 ⌋ − d i l a t i o n ⌊ 1 ⌋ × ( k e r n e l _ s i z e ⌊ 1 ⌋ − 1 ) − 1 s t r i d e ⌊ 1 ⌋ + 1 ⌋ W_{out}=\lfloor \frac{W_{in} + 2 \times padding\lfloor 1 \rfloor - dilation \lfloor 1 \rfloor \times (kernel\_size\lfloor 1 \rfloor - 1)-1}{stride\lfloor 1 \rfloor} + 1 \rfloor

看到向下取整的符号了吗？这个就是由 ceil_mode 控制的。

——————————————结束分界线——————————————

下面我们写代码验证一下最大池化层是如何计算的：

首先验证 kernel_size 参数

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3))

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print(output)


结果：

第一个tensor是我们的输入数据 1 × 1 × 6 × 6 1 \times 1 \times 6 \times 6 ，我们画红线的区域就是我们设置的窗口大小 3 × 3 3 \times 3 ，背景色为红色的值，为该区域的最大值。

第二个tensor就是我们最大池化后的结果，跟我们标注的一模一样。

这个就是最基本的最大池化。

之后我们验证一下 stride 参数

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2))

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print(output)


结果：

红色的还是我们的窗口，但是我们的步长变为了2，可以看到第一个窗口和向右滑动后的窗口，他们的最大值刚好是重叠的部分都是2.688，向下滑动之后，最大值是0.8030，再次向右滑动，最大值是2.4859。

可以看到我们在滑动的时候省略了部分数值，因为剩下的数据不够一次滑动了，于是我们将他们丢弃了。

其实最后图片的宽度和高度还可以通过上面两个公式来计算，我们公式中用的是向下取整，因此我们丢弃了不足的数据。现在我们试试向上取整。

利用 ceil_mode 参数向上取整

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2), ceil_mode=True)

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print('\n\n\n\n\n')

print(output)


结果：

从结果可以看出，输出的size由原来的 2 × 2 2 \times 2 变成了现在的 3 × 3 3 \times 3 。这就是向上取整的结果。为什么会出现这样的结果呢？

这看起来像是我们对输入进行了填充，但是这个填充值不会参与到计算最大值中。

继续验证 padding 参数

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3), stride=(3, 3), padding=(1, 1))

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print('\n\n')

print(output)


结果：

我们对周围填充了一圈0，我们滑动窗口的范围就变化了，这就是填充的作用。

但是有一点需要注意，就是即使我们填充了0，这个0也不会被选为最大值。例如上图的左上角四个数据，如果我们全部变为负数，结果是-0.1711，而不会是我们填充的0值，这一点要注意。

最后验证 return_indices 参数：

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3), return_indices=True)

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print(output)


结果：

仅仅是多返回了一个位置信息。元素位置从0开始计数，6表示第7个元素，9表示第10个元素…需要注意的是，返回值实际上是多维的数据，但是我们只看相关的元素位置信息，忽略维度的问题。

最后一个参数 dilation ，不会

展开全文
• MaxPool2d的使用方法。 API官网文档 MaxPool2d 参数介绍 kernel_size ：表示做最大池化的窗口大小，可以是单个值，也可以是tuple元组 stride ：步长，可以是单个值，也可以是tuple元组 padding ：填充，可以是...

在神经网络中 池化层是比较重要的，是提取重要信息的操作，可以去掉不重要的信息，减少计算开销。下面我们来介绍
MaxPool2d的使用方法。

API官网文档

## MaxPool2d 参数介绍

• kernel_size ：表示做最大池化的窗口大小，可以是单个值，也可以是tuple元组
• stride ：步长，可以是单个值，也可以是tuple元组
• dilation ：控制窗口中元素步幅
• return_indices ：布尔类型，返回最大值位置索引
• ceil_mode ：布尔类型，为True，用向上取整的方法，计算输出形状；默认是向下取整。

### kernel_size 的详解

注意这里的 kernel_size 跟卷积核不是一个东西。 kernel_size 可以看做是一个滑动窗口，这个窗口的大小由自己指定，如果输入是单个值，例如 3 ，那么窗口的大小就是 3 × 3 3 ，还可以输入元组，例如 (3, 2) ，那么窗口大小就是 3 × 2。
最大池化的方法就是取这个窗口覆盖元素中的最大值

### stride 的详解

上一个参数我们确定了滑动窗口的大小，现在我们来确定这个窗口如何进行滑动。如果不指定这个参数，那么默认步长跟最大池化窗口大小一致。如果指定了参数，那么将按照我们指定的参数进行滑动。例如 stride=(2,3) ， 那么窗口将每次向右滑动三个元素位置，或者向下滑动两个元素位置

### dilation 的详解

空洞卷积，默认 dilation=1，如果kernel_size =3，那么卷积核就是33的框。如果dilation = 2，kernel_size =3，那么每列数据与每列数据中间再加一列空洞，那么卷积核就变成55的框。

### return_indices 的详解

这是个布尔类型值，表示返回值中是否包含最大值位置的索引。注意这个最大值指的是在所有窗口中产生的最大值，如果窗口产生的最大值总共有5个，就会有5个返回值。

### ceil_mode 的详解

这个也是布尔类型值，它决定的是在计算输出结果形状的时候，是使用向上取整还是向下取整。怎么计算输出形状，下面会讲到。一看就知道了。

### 最大池化层输出形状计算

看到向下取整的符号了吗？这个就是由 ceil_mode 控制的。

## 参数示例介绍

### 验证 kernel_size 参数

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3))

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print(output)



第一个tensor是我们的输入数据 1 × 1 × 6 × 6 ，我们画红线的区域就是我们设置的窗口大小 3 × 3 ，背景色为红色的值，为该区域的最大值。

第二个tensor就是我们最大池化后的结果，跟我们标注的一模一样。

### 验证一下 stride 参数

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2))

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print(output)



红色的还是我们的窗口，但是我们的步长变为了2，可以看到第一个窗口和向右滑动后的窗口，他们的最大值刚好是重叠的部分都是2.688，向下滑动之后，最大值是0.8030，再次向右滑动，最大值是2.4859。

可以看到我们在滑动的时候省略了部分数值，因为剩下的数据不够一次滑动了，于是我们将他们丢弃了。

其实最后图片的宽度和高度还可以通过上面两个公式来计算，我们公式中用的是向下取整，因此我们丢弃了不足的数据。现在我们试试向上取整。

### 利用 ceil_mode 参数向上取整

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2), ceil_mode=True)

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print('\n\n\n\n\n')

print(output)



从结果可以看出，输出的size由原来的 2 × 2 变成了现在的 3 × 3。这就是向上取整的结果。为什么会出现这样的结果呢？

这看起来像是我们对输入进行了填充，但是这个填充值不会参与到计算最大值中

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3), stride=(3, 3), padding=(1, 1))

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print('\n\n')

print(output)



我们对周围填充了一圈0，我们滑动窗口的范围就变化了，这就是填充的作用。

但是有一点需要注意，就是即使我们填充了0，这个0也不会被选为最大值。例如上图的左上角四个数据，如果我们全部变为负数，结果是-0.1711，而不会是我们填充的0值，这一点要注意。

### 验证 return_indices 参数

import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3), return_indices=True)

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print(output)



### 验证 dilation 参数


python
import torch
import torch.nn as nn

# 仅定义一个 3x3 的池化层窗口
m = nn.MaxPool2d(kernel_size=(3, 3),dilation=2)

# 定义输入
# 四个参数分别表示 (batch_size, C_in, H_in, W_in)
# 分别对应，批处理大小，输入通道数，图像高度（像素），图像宽度（像素）
# 为了简化表示，我们只模拟单张图片输入，单通道图片，图片大小是6x6
input = torch.randn(1, 1, 6, 6)

print(input)

output = m(input)

print(output)
`

参考文档: https://blog.csdn.net/weixin_38481963/article/details/109962715

展开全文
• torch.nn.MaxPool2d和torch.nn.functional.max_pool2d，在pytorch构建模型中，都可以作为最大池化层的引入，但前者为类模块，后者为函数，在使用上存在不同。 1. torch.nn.functional.max_pool2d pytorch中的函数，...
• Pytorch nn.MaxPool1d； nn.functional.max_pool1d pytorch 中nn.MaxPool1d() 和nn.MaxPool2d()对比
• MaxPool2d 的使用 此处我们仍然使用官网自带的数据集进行训练,最后将其可视化 加载数据集和可视化部分在此处不在介绍,若需要了解: 加载数据集:torch.utils.data中的DataLoader数据加载器(附代码)_硕大的蛋的博客-...
• torch.nn.MaxPool2d和torch.nn.functional.max_pool2d两者本质上是一样的，具体可以参考torch.nn.MaxPool2d的源代码，核心源代码如下所示： from .. import functional as F class MaxPool2d(_MaxPoolNd): kernel_...
• 1.tf.nn.maxpool2d()函数介绍 tf.nn.max_pool2d(input, ksize, strides, padding, data_format='NHWC', name=None) 参数说明： Args input A 4-DTensorof the format specified bydata_format. ...
• ## Pytorch MaxPool2d

千次阅读 2020-08-07 12:24:42
再说说我学nn.MaxPool2d时遇到的问题： import torch import torch.nn as nn m=nn.MaxPool2d(3,stride=2) input=torch.randn(6,6) output=m(input) 然后就会报这个错： RuntimeError: non-empty 3D or 4D (batch ...
• 第1章 关于1维MaxPool1d、2维MaxPool2d、3维MaxPool3d的说明 第2章MaxPool2d详解 2.1 功能说明 2.2MaxPool2d的本质 2.3 类原型 2.4 参数说明 前言： 本文是深度学习框架 pytorch 的API ： torch.nn.MaxPool2d...
• tf.keras.layers.MaxPool2D 示例 池化层 import tensorflow as tf import numpy as np inputs = np.random.randint( # 随机生成整数 low=1, # 最小整数（包括） high=10, # 最大整数（不包括） size=(4, 28, 28,...
• 相关文章 Pytorch学习笔记(一):torch.cat()模块的详解 文章目录1.函数语法格式和作用2.参数解释3.... 1.函数语法格式和作用 ...MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_
• #%% import torch from torch import nn #%% 最大值池化 arry = torch.arange(16,...maxp = nn.MaxPool2d(kernel_size=2) #kernel_size=2,stride=kernel_size Avgp = nn.AvgPool2d(kernel_size=2) #kernel_size=2,s.
• ## torch.nn.MaxPool2d

万次阅读 2020-07-28 15:57:52
• 在上一节中我们详细的阐述了Conv2d的计算原理，今天我们来讲述下Pytorch中其他比较常见的操作！...在pytorch中使用Pooling操作来实现采样，常见的pool操作包含Max_pool，Avg_poolMax_pool x = t.rand(1,3,7,7...
• ## MaxPool2d()参数解释

万次阅读 2020-07-02 17:02:57
class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False) 对于输入信号的输入通道，提供2维最大池化（max pooling）操作 如果输入的大小是(N,C,H,W)...
• 官方文档 作用 计算最大值池化 定义 def __init__(self, pool_size=(2, 2), strides=None, padding='valid', data_format=None, **kwargs) 输入 如果da...
• nn.MaxPool2d(kernel_size=2, stride=(2, 1), padding=(0, 1)) 千万不要用： nn.MaxPool2d(kernel_size=2, stride=(2, 1), padding=(0, 0))， 这样在用交叉熵做损失函数的时候，有时候会出现loss为na...
• 使用最大值操作的池化层被称之为最大池化层（max pooling），使用平均值操作的池化层称之为平均池化层（average pooling），总的来说，池化层的作用是可以压缩数据和参数的量， 减小过拟合。 如下
• MaxPool1d torch.nn.MaxPool1d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False) 输入size为(N,C,L)，在L维进行池化 参数： kernel_size – 池化窗口大小 stride – ...
• MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
• tf.keras.layers.MaxPool2D 最大池化层 示例 import tensorflow as tf import numpy as np inputs = np.random.randint( # 随机生成整数 low=1, # 最小整数（包括） high=10, # 最大整数（不包括） size=(4, 28,...
• 1.应用 import torch import torch.nn as nn m = nn.MaxPool2d(2) ...CLASS torch.nn.MaxPool2d(kernel_size: Union[T, Tuple[T, ...]], stride: Optional[Union[T, Tuple[T, ...]]] = None, padding: Union
• conv2d的输出计算

...