DL-卷积神经网络 CNN (Convolutional Neural Network)

2024-03-11 17:03:49

卷积和神经网络

神经网络是由一连串的神经层组成,每一层神经层里面有很多神经元. 神经元是神经网络识别事物的关键.

每一种神经网络都会有输入输出值, 当输入值是图片的时候, 实际上输入神经网络的并不是那些色彩缤纷的图案,而是一堆堆的数字.

当神经网络需要处理这么多输入信息的时候, 也就是卷积神经网络就可以发挥它的优势的时候了.

卷积神经网络拆开来看. “卷积” 和 “神经网络”.

卷积也就是说神经网络不再是对每个像素的输入信息做处理了,而是图片上每一小块像素区域进行处理,

这种做法加强了图片信息的连续性. 使得神经网络能看到图形, 而非一个点. 同时也加深了神经网络对图片的理解.

具体来说, 卷积神经网络有一个批量过滤器, 持续不断的在图片上滚动收集图片里的信息,每一次收集的时候都只是收集一小块像素区域,

然后把收集来的信息进行整理, 这时候整理出来的信息有了一些实际上的呈现（比如这时的神经网络能看到一些边缘的图片信息），

然后在以同样的步骤, 用类似的批量过滤器扫过产生的这些边缘信息,

神经网络从这些边缘信息里面总结出更高层的信息结构,比如说总结的边缘能够画出眼睛,鼻子等等.

再经过一次过滤, 脸部的信息也从这些眼睛鼻子的信息中被总结出来.

最后我们再把这些信息套入几层普通的全连接神经层进行分类, 这样就能得到输入的图片能被分为哪一类的结果了.

图片是如何被卷积的

上面是一张猫的图片, 图片有长, 宽, 高三个参数. 这里的高指的是计算机用于产生颜色使用的信息. 如果是黑白照片的话, 高的单位就只有1, 如果是彩色照片, 就可能有红绿蓝三种颜色的信息, 这时的高度为3. 我们以彩色照片为例子.

过滤器就是影像中不断移动的东西, 他不断在图片收集小批小批的像素块, 收集完所有信息后输出值,

输出的值,我们可以理解成是一个高度更高,长和宽更小的”图片”. 这个图片里就能包含一些边缘信息.

然后以同样的步骤再进行多次卷积, 将图片的长宽再压缩, 高度再增加, 就有了对输入图片更深的理解.

将压缩,增高的信息嵌套在普通的分类神经层上,我们就能对这种图片进行分类了.

池化(pooling)

每一次卷积的时候, 神经层可能会无意地丢失一些信息. 这时, 池化 (pooling) 就可以很好地解决这一问题.

池化是一个筛选过滤的过程, 能将 layer 中有用的信息筛选出来, 给下一个层分析.

同时也减轻了神经网络的计算负担. 也就是说在卷积的时候, 我们不压缩长宽, 尽量地保留更多信息, 压缩的工作就交给池化了,

这样的一项附加工作能够很有效的提高准确性. 有了这些技术,我们就可以搭建一个属于我们自己的卷积神经网络啦.

流行的CNN结构

比较流行的一种搭建结构从下到上的顺序：

输入的图片(image)-> 经过一层卷积层 (convolution)->用池化(pooling)方式处理卷积的信息,(这里使用的是 max pooling )->再经过一次同样的处理->

把信息传入两层全连接的神经层 (fully connected),->接上一个分类器(classifier)进行分类预测.

MNIST手写数据

定义training data的数据

import torch
import torch.nn as nn  #简写代称
import torch.utils.data as Data
import torchvision      # 数据库模块
import matplotlib.pyplot as plt

torch.manual_seed(1)    # reproducible

# Hyper Parameters
EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
BATCH_SIZE = 50
LR = 0.001          # 学习率
DOWNLOAD_MNIST = True  # 如果你已经下载好了mnist数据就写上 False


# Mnist 手写数字库下载
train_data = torchvision.datasets.MNIST(
    root='./mnist/',    # 保存或者提取位置
    train=True,  # 是训练数据
    transform=torchvision.transforms.ToTensor(),# 转换 PIL.Image or numpy.ndarray 成
    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间（0到1）
    download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
)

画图呈现

图片

黑色的地方的值都是0, 白色的地方值大于0.

测试数据

test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)#非训练数据，是测试数据

# 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# 为了节约时间, 我们测试时只测试前2000个
test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000]/255.  
#只有在train_loader中才会自己变成0-1之间，所以这里手动-255变区间
# shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_data.test_labels[:2000]

cnn模型

用一个 class 来建立 CNN 模型.

这个 CNN 整体流程是卷积(Conv2d) -> 激励函数(ReLU) -> 池化, 向下采样 (MaxPooling) -> 再来一遍 -> 展平多维的卷积成的特征图 -> 接入全连接层 (Linear) -> 输出

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(  # input shape (1, 28, 28)搭建卷积层
            nn.Conv2d(              #卷积层（过滤器）
                in_channels=1,      # input height 高度（灰度图片只有1层，RGB图片3层）
                out_channels=16,    # n_filters     每一小块加工后输出高度为16的图片
                kernel_size=5,      # filter size    用5*5的像素点进行扫描
                stride=1,   # filter 每隔多少步跳一下，第一个filter与第二个中间隔了一个pixcel
                padding=2,     
                 # 如果想要 con2d 出来的图片长宽没有变化, padding=(kernel_size-1)/2 
            ),      # output shape (16, 28, 28)
            nn.ReLU(),    # 神经网络：激活函数
            nn.MaxPool2d(kernel_size=2),    
          # 池化层：在 2x2 空间里向下采样, output shape (16, 14, 14)
          #生成更厚的图片之后筛选出重要信息，去区域最大的值，选2*2中间最大的值，宽更窄，高不变
        )
        self.conv2 = nn.Sequential(  # input shape (16, 14, 14)
            nn.Conv2d(16, 32, 5, 1, 2), # output shape (32, 14, 14)
            #对应上面的变量直接写数值简化操作
            nn.ReLU(),  # activation
            nn.MaxPool2d(2),  # output shape (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   # 全连接层, 输出10个分类

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)   #（batch,32,7,7）
        x = x.view(x.size(0), -1)   # 展平多维的卷积图成 (batch_size, 32 * 7 * 7)batch维度保留
        output = self.out(x)#放入out
        return output

cnn = CNN()
print(cnn)  # net architecture
"""
CNN (
  (conv1): Sequential (
    (0): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU ()
    (2): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
  )
  (conv2): Sequential (
    (0): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU ()
    (2): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
  )
  (out): Linear (1568 -> 10)
)
"""

训练, 将 x y 都用 Variable 包起来, 放入 cnn 中计算 output, 最后再计算误差.

下面代码省略了计算精确度 accuracy 的部分,

optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.CrossEntropyLoss()   # the target label is not one-hotted

# training and testing
for epoch in range(EPOCH):
    for step, (b_x, b_y) in enumerate(train_loader):   # 分配 batch data, normalize x when iterate train_loader
        output = cnn(b_x)               # cnn output
        loss = loss_func(output, b_y)   # cross entropy loss
        optimizer.zero_grad()           # clear gradients for this training step
        loss.backward()                 # backpropagation, compute gradients
        optimizer.step()                # apply gradients

"""
...
Epoch:  0 | train loss: 0.0306 | test accuracy: 0.97
Epoch:  0 | train loss: 0.0147 | test accuracy: 0.98
Epoch:  0 | train loss: 0.0427 | test accuracy: 0.98
Epoch:  0 | train loss: 0.0078 | test accuracy: 0.98
"""

每50步输出打印

输出结果

取10个数据，看预测值

test_output = cnn(test_x[:10])
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')

"""
[7 2 1 0 4 1 4 9 5 9] prediction number
[7 2 1 0 4 1 4 9 5 9] real number
"""

可视化训练

可视化的代码主要是用 matplotlib 和 sklearn 来完成的,

因为其中我们用到了 T-SNE 的降维手段, 将高维的 CNN 最后一层输出结果可视化, 也就是 CNN forward 代码中的 x = x.view(x.size(0), -1) 这一个结果.

可视化的结果

码农公寓