卷积层
nn.Conv2d()
#八个参数
in_channels #输入数据体深度
out_channels #输出数据体深度
kernel_size #滤波器（卷积核大小）
stride #滑动的步长
padding #零填充数量
dilation #卷积对输入数据体的空间间隔
groups #表示输出数据体深度上和输入数据体上深度上的联系
bias #默认为True，使用偏置
池化层
nn.MaxPool2d() #表示网络中的最大值池化
#6个参数
kernel_size
stride
dilation
padding
return_indices #表示是否返回最大值所处的下表，默认为False
ceil_mode #标志使用一些放个代替层结构 一般不使用 默认为False
nn.AvgPool2d()
#多了1个参数
count_include_pad（）#计算均值是是否包含0填充，默认为True
代码实现
import torch
import torch.nn as nn
class SimpleCNN(nn.Module):
def __init__(self):
super(SimpleCNN,self).__init__()
layer1 = nn.Sequential()
layer1.add_module('conv1',nn.Conv2d(3,32,3,1,padding=1))
layer1.add_module('relu1',nn.ReLU(True))
layer1.add_module('pool1',nn.MaxPool2d(2,2))
self.layer1 = layer1
layer2 = nn.Sequential()
layer2.add_module('conv2',nn.Conv2d(32,64,3,1,padding=1))
layer2.add_module('relu2',nn.ReLU(True))
layer2.add_module('pool2',nn.MaxPool2d(2,2))
self.layer2 = layer2
layer3 = nn.Sequential()
layer3.add_module('conv3',nn.Conv2d(64,128,3,1,padding=1))
layer3.add_module('relu3',nn.ReLU(True))
layer3.add_module('pool3',nn.MaxPool2d(2,2))
self.layer3 = layer3
layer4 = nn.Sequential()
layer4.add_module('fc1',nn.Linear(2048,512)))
layer4.add_module('fc_relu1',nn.ReLU(True))
layer4.add_module('fc2',nn.Linear(512,64))
layer4.add_module('fc_relu2',nn.ReLU(True))
layer4.add_module('fc3',nn.Linear(64,10))
self.layer4 = layer4
def forward(self,x):
conv1 = self.layer1(x)
conv2 = self.layer2(conv1)
conv3 = self.layer3(conv2)
fc_input = conv3.view(conv3.size(0),-1)
fc_out = self.layer4(fc_input)
return fc_out
model = SimpleCNN()
关键函数
add_module(name, module)
将一个 child module 添加到当前 module。 被添加的module可以通过 name属性来获取
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.add_module("conv", nn.Conv2d(10, 20, 4))
#self.conv = nn.Conv2d(10, 20, 4) 和上面这个增加module的方式等价
model = Model()
print(model.conv)
class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
一维卷积层，卷积核是一维的，输入的尺度是(N, C_in,L)，输出尺度（ N,C_out,L_out）的计算方式：N是batch，L是长度，C是深度，
o
u
t
(
N
i
,
C
o
u
t
j
)
=
b
i
a
s
(
C
o
u
t
j
)
+
∑
k
=
0
C
i
n
−
1
w
e
i
g
h
t
(
C
o
u
t
j
,
k
)
⨂
i
n
p
u
t
(
N
i
,
k
)
out(N_i, C_{out_j})=bias(C {out_j})+\sum^{C{in}-1}_{k=0}weight(C{out_j},k)\bigotimes input(N_i,k)
out(Ni,Coutj)=bias(Coutj)+k=0∑Cin−1weight(Coutj,k)⨂input(Ni,k)
weight(tensor) - 卷积的权重，shape是(out_channels, in_channels,kernel_size)`
权重就是卷积核矩阵中的数字。
bias(tensor) - 卷积的偏置系数，shape是（out_channel）
深度上每一层的数据与权重做内积求和，得出的结果加上偏置输出，为输出深度的其中一层的结果。
L
o
u
t
=
f
l
o
o
r
(
L
i
n
+
2
p
a
d
d
i
n
g
−
d
i
l
a
t
i
o
n
(
k
e
r
n
e
r
l
_
s
i
z
e
−
1
)
−
1
s
t
r
i
d
e
+
1
)
L_{out}=floor(\frac{L_{in}+2padding-dilation(kernerl\_size-1)-1}{stride}+1)
Lout=floor(strideLin+2padding−dilation(kernerl_size−1)−1+1)
class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
二维卷积层, 卷积核是二维的，输入的尺度是(N, C_in,H,W)，输出尺度（N,C_out,H_out,W_out）的计算方式：H是高度，W是宽度，C是深度
o
u
t
(
N
i
,
C
o
u
t
j
)
=
b
i
a
s
(
C
o
u
t
j
)
+
∑
k
=
0
C
i
n
−
1
w
e
i
g
h
t
(
C
o
u
t
j
,
k
)
⨂
i
n
p
u
t
(
N
i
,
k
)
out(N_i, C_{out_j})=bias(C_{out_j})+\sum^{C_{in}-1}_{k=0}weight(C{out_j},k)\bigotimes input(N_i,k)
out(Ni,Coutj)=bias(Coutj)+k=0∑Cin−1weight(Coutj,k)⨂input(Ni,k)
H
o
u
t
=
f
l
o
o
r
(
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
r
l
_
s
i
z
e
[
0
]
−
1
)
−
1
s
t
r
i
d
e
[
0
]
+
1
)
H_{out}=floor(\frac{H_{in}+2padding[0]-dilation[0](kernerl\_size[0]-1)-1}{stride[0]}+1)
Hout=floor(stride[0]Hin+2padding[0]−dilation[0](kernerl_size[0]−1)−1+1)
W
o
u
t
=
f
l
o
o
r
(
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
r
l
_
s
i
z
e
[
1
]
−
1
)
−
1
s
t
r
i
d
e
[
1
]
+
1
)
W_{out}=floor(\frac{W_{in}+2padding[1]-dilation[1](kernerl\_size[1]-1)-1}{stride[1]+1})
Wout=floor(stride[1]+1Win+2padding[1]−dilation[1](kernerl_size[1]−1)−1)
class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
提取层结构
对于给定的模型，不想要模型中的所有结构，只希望提取网络中的一层或者两层改如何处理呢？
nn.Module的几个重要属性
children() #返回下一级模块的迭代器
#只会返回在layer1、2、3、4上的迭代器，不会返回其中的内容。
modules() #返回所有的迭代器
如何提取参数及自定义初始化
for param in model.named_parameters(): #返回名称以及参数 去掉named，只返回参数
print(param[0])
比如
('layer2.conv2.bias', Parameter containing:
tensor([-0.0280,0.0085, 0.0302, -0.0502, -0.0220, 0.0553, -0.0145, 0.0082,
0.0141,-0.0443, -0.0152,-0.0234, 0.0164, 0.0291, 0.0333, -0.0361,
0.0396, -0.0166, 0.0254,0.0435, -0.0558, 0.0444, 0.0406, -0.0531,
0.0232, 0.0496, 0.0069,0.0286, -0.0169, -0.0493, -0.0269, 0.0145,
0.0012, -0.0516, -0.0528,0.0354, 0.0273, 0.0228, -0.0027, 0.0282,
-0.0310, -0.0570, -0.0265,0.0183, -0.0072, -0.0006, -0.0378, -0.0184,
-0.0522, 0.0337, -0.0275,0.0259, 0.0148, -0.0560, -0.0267, 0.0209,
0.0246, -0.0447, 0.0279,-0.0227,0.0022, -0.0468, -0.0409, -0.0336],
requires_grad=True))
878
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
