Press "Enter" to skip to content

0603-常用的神经网络层

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

0603-常用的神经网络层

 

目录

 

pytorch完整教程目录: https://www.cnblogs.com/nickchen121/p/14662511.html

 

一、图像相关层

 

图像相关层主要包括卷积层(Conv)、池化层(Pool)等

这些层在实际的使用中也分为一维(1D)、二维(2D)和三维(3D)
池化方式分为平均池化(AvgPool)、最大值池化(MaxPool)、自适应池化(AdaptiveAvgPool)
卷积层除了常用的前向卷积,还有逆卷积(TransposeConv)

import torch as t
from torch import nn
from torch.autograd import Variable as V
from PIL import Image
from torchvision.transforms import ToTensor, ToPILImage
to_tensor = ToTensor()  # 把 img 转为 Tensor
to_pil = ToPILImage()
nick = Image.open('img/0802程序输出nick图.jpeg')  # 只能在这里牺牲我帅气的面貌
nick

 

 

上图是 nick 原图

 

# 锐化卷积核后的卷积,可以看上一篇文章分享的  06-01 -图像识别 那篇文章里讲到的特征提取
# 输入是一个 batch,batch_size=1
inp = to_tensor(nick).unsqueeze(0)
# 卷积核的构造
kernel = t.ones(3, 3, 3) / -9  # 锐化卷积核,即刻画人物边缘特征,去除掉背景
kernel[:, 1, 1] = 1
conv = nn.Conv2d(
    in_channels=3,  # 输入通道数
    out_channels=1,  # 输出通道数,等同于卷积核个数
    kernel_size=3,  # 核大小
    stride=1,
    bias=False)
conv.weight.data = kernel.view(1, 3, 3, 3)
"""
conv.weight.size() 输出为 torch.Size([1, 3, 3, 3])
第 1 个 1 代表着卷积核的个数,
第 2 个 3 表示的输入通道数,
后面两个 3 是二维卷积核的尺寸
"""
out = conv(V(inp))
to_pil(out.data.squeeze(0))

 

 

# 普通卷积
# 输入是一个 batch,batch_size=1
inp = to_tensor(nick).unsqueeze(0)
# 卷积核的构造
conv = nn.Conv2d(
    in_channels=3,  # 输入通道数
    out_channels=1,  # 输出通道数,等同于卷积核个数
    kernel_size=3,  # 核大小
    stride=1,
    bias=False)
out = conv(V(inp))
to_pil(out.data.squeeze(0))

 

 

上图是卷积后处理的 nick图,可以发现已经进行了一定程度的特征提取,并且通过对卷积核进行特定的处理,对人物边缘进行了一定的刻画,并且去除了背景

 

pool = nn.AvgPool2d(2, 2)
list(pool.parameters())

 

[]

 

out = pool(V(inp))
print(inp.size(), out.size())
to_pil(out.data.squeeze(0))

 

torch.Size([1, 3, 318, 320]) torch.Size([1, 3, 159, 160])

 

 

上图是池化后的 nick 图,由于我们选择 2 个像素池化为 1 个,可以发现池化后的图像大小正好是原图的 0.5 倍

 

除了卷积核池化,深度学习还经常用到以下几个层:

Linear:全连接层
BatchNorm:批规范化层,分为 1D、2D 和 3D。除了标准的 BatchNorm 外,还有在风格迁移中常用到的 InstanceNorm 层
Dropout:dropout 层,用来防止过拟合,同样分为 1D、2D 和 3D

下面讲解它们的用法。

 

# 输入 batch_size=2,维度为 3
inp = V(t.randn(2, 3))
linear = nn.Linear(3, 4)
h = linear(inp)  # (2,3)*(3,4)=(2,4)
h

 

tensor([[-0.7140, -0.0469,  1.1187,  2.0739],
        [-1.0575, -1.8866, -1.0009, -0.2695]], grad_fn=<AddmmBackward>)

 

# 4通道,初始化标准差为 4,均值为 0
bn = nn.BatchNorm1d(4)
bn.weight.data = t.ones(4) * 4
bn.bias.data = t.zeros(4)
bn_out = bn(h)
# 注意输出的均值和方差
# 方差是标准差的平方,计算无偏方差分母会减 1
# 使用 unbiased=False,分母不减 1
bn_out.mean(0), bn_out.var(0, unbiased=False)

 

(tensor([0., 0., 0., 0.], grad_fn=<MeanBackward1>),
 tensor([15.9946, 15.9998, 15.9999, 15.9999], grad_fn=<VarBackward1>))

 

# 每个元素以 0.5 的概率舍弃
dropout = nn.Dropout(0.5)
o = dropout(bn_out)
bn_out, o  # 有一半左右的数变为 0

 

(tensor([[ 3.9993,  4.0000,  4.0000,  4.0000],
         [-3.9993, -4.0000, -4.0000, -4.0000]],
        grad_fn=<NativeBatchNormBackward>),
 tensor([[ 0.0000,  8.0000,  8.0000,  0.0000],
         [-7.9986, -8.0000, -0.0000, -8.0000]], grad_fn=<MulBackward0>))

 

上述的例子中都对 module 的属性也就是 data 进行了直接操作,其中大多都是可学习参数,这些参数在学习中会不断变化。在实际使用中,如非必要,还是不要去修改它们。

 

二、激活函数

 

2.1 ReLU 函数

 

tocrh 实现了常见的激活函数,具体的使用可以去查看官方文档或查看上面分享的文章,看文章的时候需要注意的是激活函数也可以作为独立的 layer 使用。在这里我们就讲讲最常使用的 ReLU 函数,它的数学表达式为: \(ReLU(x) = max(0,x)\) ,其实就是小于 0 的数置为 0

 

relu = nn.ReLU(inplace=True)
inp = V(t.randn(2, 3))
inp

 

tensor([[-1.5703,  0.0868,  1.0811],
        [-0.9903,  0.5288,  0.5926]])

 

output = relu(inp)  # 小于 0 的都被置为 0,等价于 inp.camp(min=0)
output

 

tensor([[0.0000, 0.0868, 1.0811],
        [0.0000, 0.5288, 0.5926]])

 

其中 ReLU 函数有个 inplace 参数,如果设置为 True,它会让输出直接覆盖输入,这样可以节省内存的占用。

 

在上述例子中,是将每一层的输出直接作为下一层的输入,这种网络称为前馈传播网络。对于这类网络,如果每次也都写上 forward 函数,就会特别麻烦。因此又两者简化方式——ModuleList 和 Sequential。其中 Sequential 是一个特殊的 Module,包含几个子 module,可以像用 list 一样使用它,但不能直接把输入传给它。

 

2.2 通过Sequential 构建前馈传播网络

 

# Sequential 的三种写法
net1 = nn.Sequential()
net1.add_module('conv', nn.Conv2d(3, 3, 3))
net1.add_module('batchnorm', nn.BatchNorm2d(3))
net1.add_module('activation_layer', nn.ReLU())
net2 = nn.Sequential(nn.Conv2d(3, 3, 3), nn.BatchNorm2d(3), nn.ReLU())
from collections import OrderedDict
net3 = nn.Sequential(
    OrderedDict([('conv1', nn.Conv2d(3, 3, 3)), ('bn1', nn.BatchNorm2d(3)),
                 ('relu1', nn.ReLU())]))

 

net1

 

Sequential(
  (conv): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))
  (batchnorm): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (activation_layer): ReLU()
)

 

net2

 

Sequential(
  (0): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))
  (1): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (2): ReLU()
)

 

net3

 

Sequential(
  (conv1): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))
  (bn1): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu1): ReLU()
)

 

# 可以根据名字或序号取出子 module
net1.conv, net2[0], net3.conv1

 

(Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1)),
 Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1)),
 Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1)))

 

# 通过 Sequential 构建的网络处理数据
inp = V(t.rand(1, 3, 4, 4))
output = net1(inp)
output = net2(inp)
output = net3(inp)
output = net3.relu1(net1.batchnorm(net1.conv(inp)))

 

2.3 通过 ModuleList 构建前馈传播网络

 

modellist = nn.ModuleList([nn.Linear(3, 4), nn.ReLU(), nn.Linear(4, 2)])
inp = V(t.rand(1, 3))
for model in modellist:
    inp = model(inp)
# output = modellist(inp) # 报错,因为 modellist 没有实现 forward 方法,需要新建一个类定义 forward 方法

 

在这里使用 ModuleList 而不是使用 list,是因为 ModuleList 是 Module 的子类,在 Module 中使用它时,可以自动识别为子 module,下面我们举例说明。

 

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.list = [nn.Linear(3, 4), nn.ReLU()]
        self.module_list = nn.ModuleList([nn.Conv2d(3, 3, 3), nn.ReLU()])
    def forward(self):
        pass

model = MyModule()
model

 

MyModule(
  (module_list): ModuleList(
    (0): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))
    (1): ReLU()
  )
)

 

for name, param in model.named_parameters():
    print(name, param.size())

 

module_list.0.weight torch.Size([3, 3, 3, 3])
module_list.0.bias torch.Size([3])

 

从上面的打印结果可以看出,list 中的子 module 并没有被主 module ,而 ModuleList 中的子 module 却被主 module 识别了。这也意味着如果用 list 保存子 module,将无法调整其参数,因为这些参数会加入到 module 的参数中。

 

三、循环神经网络层

 

循环神经网络多用于自然语言处理(RNN),torch 中目前实现了最常用的三种 RNN:RNN(vanilla RNN)、LSTM 和 GRU,此外还有对应的三种 RNNCell。

 

RNN 和 RNNCell 的区别在于前者能够处理整个序列,而后者一次只处理序列中的一个时间点和数据,前者更易于使用,后者的灵活性更高。因此 RNN 一般组合调用 RNNCell 一起使用。

 

t.manual_seed(1000)
inp = V(t.randn(2, 3, 4))  # 输入:batch_size=3,序列长度为 2,序列中每个元素占 4 维
lstm = nn.LSTM(4, 3, 1)  # lstm 输入向量 4 维,3 个隐藏元,1 层
# 初始状态:1 层,batch_size=3,3 个隐藏元
h0 = V(t.randn(1, 3, 3))
c0 = V(t.randn(1, 3, 3))
out, hn = lstm(inp, (h0, c0))
out

 

tensor([[[-0.3610, -0.1643,  0.1631],
         [-0.0613, -0.4937, -0.1642],
         [ 0.5080, -0.4175,  0.2502]],
        [[-0.0703, -0.0393, -0.0429],
         [ 0.2085, -0.3005, -0.2686],
         [ 0.1482, -0.4728,  0.1425]]], grad_fn=<StackBackward>)

 

t.manual_seed(1000)
inp = V(t.randn(2, 3, 4))  # 输入:batch_size=3,序列长度为 2,序列中每个元素占 4 维
# 一个 LSTMCell 对应的层数只能是一层
lstm = nn.LSTMCell(4, 3)  # lstm 输入向量 4 维,3 个隐藏元,默认1 层也只能是一层
hx = V(t.randn(3, 3))
cx = V(t.randn(3, 3))
out = []
for i_ in inp:
    hx, cx = lstm(i_, (hx, cx))
    out.append(hx)
t.stack(out)

 

tensor([[[-0.3610, -0.1643,  0.1631],
         [-0.0613, -0.4937, -0.1642],
         [ 0.5080, -0.4175,  0.2502]],
        [[-0.0703, -0.0393, -0.0429],
         [ 0.2085, -0.3005, -0.2686],
         [ 0.1482, -0.4728,  0.1425]]], grad_fn=<StackBackward>)

 

词向量在自然语言中应用十分广泛,torch 同样也提供了 Embedding 层

 

embedding = nn.Embedding(4, 5)  # 有 4 个词,每个词用 5 维的向量表示
embedding.weight.data = t.arange(0, 20).view(4, 5)  # 可以用预训练好的词向量初始化 embedding

 

with t.no_grad():  # 下面代码的梯度回传有问题,因此去掉梯度
    inp = V(t.arange(3, 0, -1)).long()
    output = embedding(inp)
    print(output)

 

tensor([[15, 16, 17, 18, 19],
        [10, 11, 12, 13, 14],
        [ 5,  6,  7,  8,  9]])

 

四、损失函数

 

在深度学习中也要用到各种各样的损失函数,这些损失函数可以看作是特殊的 layer,torch 也将这些损失函数实现为 nn.Module 的子类。

 

然而在实际的应用中,一般把损失函数独立出来,作为独立的一部分。详细的 loss 使用可以参考官方文档,这里仅以最常用的交叉熵损失为例讲解。

 

# batch_size=3,计算对应每个类别的分数(只有两个类别)
score = V(t.randn(3, 2))
# 三个样本分别属于 1,0,1 类,label 必须是 LongTensor
label = V(t.Tensor([1, 0, 1])).long()
# loss 与普通的 layer 没有什幺差别
criterion = nn.CrossEntropyLoss()
loss = criterion(score, label)
loss

 

tensor([[ 1.0592,  1.4730],
        [-0.1558, -0.8712],
        [ 0.2548,  0.0817]])
tensor([1, 0, 1])


tensor(0.5630)

Be First to Comment

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注