Pytorch 张量及输入输出计算及参数量详细公式

1.张量

一般文本使用三维张量，适合用于RNN和NLP。如20句话，每句话10个单词，每个单词用100个分量的向量表示，得到的Tensor就是shape=[20, 10, 100]。

四维张量，适合用于CNN表示图像。例如100张MNIST数据集的灰度图(通道数为1，如果是RGB图像通道数就是3)，每张图高28像素，宽28像素，那么这个Tensor的shape=[100, 1, 28, 28]，也就是一个batch的数据维度：[batch_size, channel, height, width]。

2.给定输入计算输出的详细过程

首先给出计算公式

卷积后，池化后尺寸计算公式：
(图像尺寸-卷积核尺寸 + 2填充值)/步长+1
(图像尺寸-池化窗尺寸 + 2填充值)/步长+1

即：

卷积神将网络的计算公式为：
N=(W-F+2P)/S+1
其中
N：输出大小
W：输入大小
F：卷积核大小
P：填充值的大小
S：步长大小

参数量计算

全连接层：输入x输出 + 1（bias)
卷积层：kernelsize x channel number + 1(bias)
maxpooling： 0 不需要参数

Conv2d

class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
几个参数:
in_channels=3:表示的是输入的通道数，直接通过输入的通道的数量来确定。
out_channels:表示的是输出的通道数，设定输出通道数（这个是可以根据自己的需要来设置的）。
kernel_size=12:表示卷积核的大小是12x12的，也就是上面的 F=12。
stride=4:表示的是步长为4，也就是上面的S=4。
padding=2:表示的是填充值的大小为2，也就是上面的P=2。

MaxPool2d

class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
kernel_size(int or tuple) - max pooling的窗口大小
stride(int or tuple, optional) - max pooling的窗口移动的步长。默认值是kernel_size。
pool操作并不改变张量的通道个数。

下面通过一个简单的卷积神经网络来计算详细步骤

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
class ConvNet(nn.Module):
	def __init__(self):
		##nn.module子类的函数必须在构造函数中执行父类的构造函数
		##下式等价于nn.Module.__init__(self)
		super(ConvNet,self).__init__()
		self.conv1 = nn.Conv2d(1,10,5)
		self.pool1 = nn.MaxPool2d(2,2)
		self.conv2 = nn.Conv2d(10,20,5)
		self.pool2 = nn.MaxPool2d(2,2)
		self.fc1 = nn.Linear(320,50)
		self.fc2 = nn.Linear(50,10)
	def forward(self,input):
		x = self.pool1(F.relu(self.conv1(input)))
		x = self.pool2(F.relu(self.conv2(input)))
		x = self.fc2(self.fc1(x))
		return x
net = ConvNet()
print(net)
input = Variable(torch.randn(1,1,28,28))
out = net(input)
print(out.size())

我们可以看下网络结构部分：

self.conv1 = nn.Conv2d(1,10,5)
self.pool1 = nn.MaxPool2d(2,2)
self.conv2 = nn.Conv2d(10,20,5)
self.pool2 = nn.MaxPool2d(2,2)
self.fc1 = nn.Linear(320,50)
self.fc2 = nn.Linear(50,10)
def forward(self,input):
		x = self.pool1(F.relu(self.conv1(input)))
		x = self.pool2(F.relu(self.conv2(input)))
		x = self.fc2(self.fc1(x))

网络结构为：

conv2d – maxpool2d --conv2d – maxpool2d - fullyconnect --fullyconnect

对于给定输入：input = Variable(torch.randn(1,1,28,28)) 即 28*28的单通道图片。
下面分析每一层的输入和输出：

（1）conv2d(1,10,5)
输入 （1,1,28,28）
conv2d中，
1:从输入确定，输入的channel数量为1。
10: 输出的channel数量为10。
5：kernel size=5x5
下面计算输出的大小：

N：输出大小
W：输入大小 28x28
F：卷积核大小 5x5
P：填充值的大小 0默认值
S：步长大小 1默认值
N=(W-F+2P)/S+1=(28-5 + 2x0)/1 + 1 = 24
输出为：10x24x24
参数量：5x5x10 + 1 = 251

所以这一步输出大小（10,24,24）。

（2）MaxPool2d(2, 2)
pool不改变channel的值。
所以，只计算输出即可。

N：输出大小
W：输入大小 24x24
F：卷积核大小 5x5
P：填充值的大小 0默认值
S：步长大小 1默认值
N=(W-F+2P)/S+1=(24-2 + 2x0)/2 + 1 = 12
输出为：10x12x12
参数量： 0

所以这一步的每个样本的输出大小（10,12,12）。

(3)conv2d(10,20,5)

输入 （10,12,12）
conv2d中，
10:从输入确定，输入的channel数量为10。
20: 输出的channel数量为20。
5：kernel size=5*5
下面计算每个样本输出后的大小：

N：输出大小
W：输入大小 12x12
F：卷积核大小 5x5
P：填充值的大小 0默认值
S：步长大小 1默认值
N=(W-F+2P)/S+1=(12-5 + 2*0)/1 + 1 = 8
输出为：20x8x8

所以这一步的每个样本的输出大小（20,8,8）。
参数量：5x5x20+1 = 501

（4）MaxPool2d(2, 2)
pool不改变channel的值。
所以，只计算输出即可。

N：输出大小
W：输入大小 88
F：卷积核大小 55
P：填充值的大小 0默认值
S：步长大小 1默认值
N=(W-F+2P)/S+1=(8-2 + 2x0)/2 + 1 = 4
输出为：20x4x4
参数量： 0
所以这一步的每个样本的输出大小（20,4,4）。

(5)fully-connect Linear(320, 50)
输入：20x4x4=320，这里的320是从最上面的20x4x4得到。
输出：50。
参数量： 320x50 + 1

（6）fully-connect Linear(50, 10)
输入：50
输出：10
参数量: 50x10+1

所以最终一个样本输出的大小为（10）。

最后加上batch_size，输出为(1,10)。