[PyTorch][chapter 9][李宏毅深度学习][CNN]

前言：

卷积神经网络（Convolutional Neural Networks）是一种深度学习模型或类似于人工神经网络的多层感知器，常用来分析视觉图像。卷积神经网络的创始人是着名的计算机科学家Yann LeCun，目前在Facebook工作，他是第一个通过卷积神经网络在MNIST数据集上解决手写数字问题的人.

CNN 除了在图像分类,还有一些其它有趣的创意方案：

语音识别，风格迁移，DeepDream,围棋游戏方面的应用场景。

卷积神经神经网络架构
卷积层
池化层
Flatten
全连接层
梯度更新常用方案
卷积层
基于CNN的创意应用
PyTorch 模型搭建

一卷积神经网络的架构

卷积神经网络主要由五个部分组成：

Input layer	输入层
CONV layer	卷积层：多个反复叠加
Pooling layer	池化层 : 多个反复叠加
Flatten	张量展平
FC layer	全连接层

CNN 相对FC 网络主要引入了下面三个思想：

1.1：局部采样

A neuron does not have to see the whole image to
discover the pattern

采样输入图像的时候，不需要查看整个图像.

比如：一个神经元要实现识别鸟嘴功能,只需要每次采样局部图样处理

1.2: 权值共享

the same pattern appear in different regions

针对不同的采样区域使用同一个卷积核

例：如下图，鸟嘴在不同的位置，每次采样不同的位置的图片时候，我们使用同一组卷积核

提取其鸟嘴特征。

1.3 池化思想

subsampling the pixels will not change the object

降采样图像不会改变图片形状,降低了计算量

二卷积层（Convolution）

2.1 原理：

通过循环移动卷积核矩阵Filter, 提取图像的特征。

卷积核是通过训练学习出来的,有很多个.不同的卷积核可以

提取不同的图像纹理特征. 经过卷积后得到图像的称为feature map

2.2例子：

通过滑动移动卷积核,跟对应图像位置的矩阵做点积,求和.

$3=sum(A\odot B)$

k: kernel_size 卷积核大小

p: padding 填充

H: 原图像的宽或者高

s: stride 滑动步长

通过卷积后得到的新的尺寸为：

$O=[\frac{w-k+2p}{s}]+1$

可以通过pytorch API 直接计算

# -*- coding: utf-8 -*-
"""
Created on Sun Dec 31 17:04:34 2023

@author: cxf
"""
import torch
import torch.nn as nn

def CNN():
    
    conv_layer = nn.Conv2d(in_channels=1,
                  out_channels=1,
                  kernel_size=3,
                  stride =1,
                  padding=0,
                  bias=False)
    
    print("\n default conv kernel:", conv_layer.weight.shape)
    conv_layer.weight = torch.nn.parameter.Parameter(torch.tensor([[[[1,-1,-1],
                                                                [-1,1,-1],
                                                                [-1,-1,1]]
                                                              ]]).float(), requires_grad=True)


    
    print("\n weidht",conv_layer.weight.shape)
        
    image = torch.tensor(
            [[[1,0,0,0,0,1],
              [0,1,0,0,1,0],
             [0,0,1,1,0,0],
             [1,0,0,0,1,0],
             [0,1,0,0,1,0],
             [0,0,1,0,1,0]]]
            ,dtype= torch.float
            )
        
        
    feature = conv_layer(image)
        
    print("\n res",feature)

CNN()

in_channels 是指输入特征图的通道数，数据类型为 int
out_channels 是输出特征图的通道数，数据类型为 int，
kernel_size 是卷积核的大小，数据类型为 int 或 tuple
stride 滑动的步长，数据类型为 int 或 tuple，默认是 1，在。
padding 为补零的方式，注意当 padding 为’valid’或’same’时，stride 必须为 1。

三池化（Max-Pooling）

3.1 原理

我们得到feature map 后对里面的元素进行分组,每一组取最大值.

那反向传播算法的时候，如何求微分呢

3.2 Max-pooling 微分原理：

以下面方案为例：

3.1 输入

$x=[x_1,x_2]$

3.2 神经元输入(每层）：

$z^{l}=[z_1^{l},z_2^{l},z_3^{l},z_4^{l}]$

$z_1^{l}=w_1^{l}a^{l-1}$

$z_2^{l}=w_2^{l}a^{l-1}$

$z_3^{l}=w_3^{l}a^{l-1}$

$z_4^{l}=w_4^{l}a^{l-1}$

3.3 分组（Max-pooling）

每层中

$z_1,z_2$ 分为一组

$z_3,z_4$ 分为一组

3.4 神经元输出分组（Max-pooling）

$a_1^{l}=maxout(z_1^{l},z_2^{l})$

$a_2^{l}=maxout(z_3^{l},z_4^{l})$

如下图,假设红色部分为最大值，在反向传播的时候只会更新

$w_1^1,w_4^1,w_2^2,w_3^2$ 对应的权重系数梯度,作用跟relu 一样.

当输入不同的时候,就会训练到不同的参数

四 Flatten

作用：

把经过多次卷积,池化得到的特征图进行拉直.

import torch

batch_size = 10
width = 5
height =5 
a = torch.randn((batch_size,width,height))

b = torch.flatten(a, start_dim=1,end_dim=-1)
print(b.shape)

五全连接层

全连接层，是每一个结点都与上一层的所有结点相连，用来把前边提取到的特征综合起来。由于其全相连的特性，一般全连接层的参数也是最多的。

原理跟前面讲过的DNN是一样的

六梯度更新常用方案

6.1 Adagrad

AdaGrad，全称Adaptive Gradient，又叫自适应梯度算法，是一种具有自适应学习率的梯度下降优化方法。

$v_t= \sum_{i=0}^{t}(g^t)^2$

$w_{t+1}=w_t-\frac{\eta}{v_t}\odot g_t$

优点

① 避免手动去调整学习率
② 他可以自动的为每个参数单独设置学习率，这样梯度较大的参数学习率较小，更新减慢，梯度较小的参数学习率较大，更新加速。在梯度图上可以解释为更为平缓的方向，会取得更大的进步（因为平缓，所以历史梯度平方和较小，对应学习下降的幅度较小）
缺点

① 由于学习率分母中的
是历史梯度值平方的累加，因此随着迭代次数的增加，分母会越来越大，学习率衰减的速度会越来越快，学习率会越来越小甚至接近于0，因此AdaGrad迭代后期的学习率非常小，而非常容易出现梯度消失现象。

6.2 RMSProp

RMSProp全称为Root Mean Square Propagation，是一种未发表的自适应学习率方法，由Geoff Hinton提出，是梯度下降优化算法的扩展

$v_t=0.9 v_{t-1}^2+0.1g_t^2$

$w_{t+1}=w_t-\frac{\eta}{\sqrt{v_t}}\odot g_t$

6.3 momentum

计算t时刻的梯度 $g_t$

$m_t=\alpha m_{t-1}-(1-\alpha)g_t$

$w_{t+1}=w_t+m_t$

七卷积核提取了什么特征

我们知道一个神经网络读入一张图片，通过多层网络，最后输出一个分类的结果，但是我们仅仅知道一个结果并不够，神经网络的一个挑战是要理解在每一层到底都发生了什么事。

1 我们知道经过训练之后，每一层网络逐步提取越来越高级的图像特征，直到最后一层将这些特征比较做出分类的结果。比如前面几层也许在寻找边缘和拐角的特征，中间几层分析整体的轮廓特征，这样不断的增加层数就可以发展出越来越多的复杂特征，最后几层将这些特征要素组合起来形成完整的解释，这样到最后网络就会对非常复杂的东西，比如房子，小猫等图片有了反应。

2 为了理解神经网络是如何学习的，我们必须要理解特征是如何被提取和识别的，如果我们分析一些特定层的输出，我们可以发现当它识别到了一些特定的模式，它就会将这些特征显著地增强，而且层数越高，识别的模式就越复杂。当我们分析这些神经元的时候，我们输入很多图片，然后去理解这些神经元到底检测出了什么特征是不现实的，因为很多特征人眼是很难识别的。一个更好的办法是将神经网络颠倒一下，不是输入一些图片去测试神经元提取的特征，而是我们选出一些神经元，看它能够模拟出最可能的图片是什么，将这些信息反向传回网络，每个神经元将会显示出它想增强的模式或者特征。

常用方案如下：

7.1 看卷积核

可以直接查看第一层卷积核的参数,以图片的形式显示出来.如下图AlexNet

可以看到不同的卷积核在提取不同的特征.

1 使用浅层的神经网络将获得浅层的特征（边缘，圆形，颜色），如下图ResNet50

2 使用高层的神经网络将获得深层的特征，如下图

7.2 可以把卷积核提取的特征图片直接放在神经元里面,聚类.

7.3：ak响应

假设经过卷积核处理后得到一张feature map

对该feature map 里面相加求和得到 $a^{k}$ 。

我们输入不同的图片得到不同的 $a^{k}$ ,求其最大值

通过下面实验可以看到不同的filter 可以侦测不同的纹理特征

八基于CNN 的创意模型

8 .1 Deep Dream

2015年Google发布了一个很有意思的东西，叫做Deep Dream使用了梯度上升算法，通过随机生成的噪声或者提供的图片生成一张怪异的图片,输入图requires_grad = True,

损失函数跟一般的神经网络不同

图像在选定层上面的输出响应,要使得这些响应最大化.

loss_component = torch.nn.MSELoss(reduction='mean')(layer_activation, torch.zeros_like(layer_activation))
losses.append(loss_component)

loss = torch.mean(torch.stack(losses))
loss.backward()

具体可以参考： deep_dream_static_image 函数

GIt hub 参考代码：

GitHub - gordicaleksa/pytorch-deepdream: PyTorch implementation of DeepDream algorithm (Mordvintsev et al.). Additionally I've included playground.py to help you better understand basic concepts behind the algo. GitHub - hjptriplebee/deep_dream_tensorflow: An implement of google deep dream with tensorflow

8.2 Deep Style

Style Transfer是CNN的一個應用，在2015年 Gatys 等人發表的 A Neural Algorithm of Artistic Style中，採用了VGG的模型來對原圖(original image)及風格圖(style image)提取特徵，來實施將一張照片轉換成另一張圖的風格或是畫風，來生成一張新的圖片，讓它同時擁有原圖(original image)的內容以及風格圖(style image)的風格。

步骤： VGG 去掉后面的全连接部分

生成目标图片：先将内容图和风格图输入"喂给"VGG，然后生成目标内容图和目标风格图（仅一次输入），用作后面Loss的计算。
初始化合成图片：这里内容图上添加白噪声的方式来初始化合成图，我们将白噪声图片"喂给"VGG，就得到了合成图片。
载入预训练模型：Content信息捕捉，得到content loss，Style信息捕捉，得到style loss
计算总Loss值：这里我们分别采用内容损失+风格损失得出总的loss，两者配置一定权值
优化函数：这里优化函数采用AdamOptimizer
训练模型

详细参考： https://www.cnblogs.com/yifanrensheng/p/12547660.html

8.3 围棋

8.4 语音辨识

语音做傅里叶变换后，横向为时间,纵向为频率.

可以进行语音文字识别处理.

九 LeNet5 手写数字简单模型搭建

# -*- coding: utf-8 -*-
"""
Created on Tue Jan  2 16:59:55 2024

@author: chengxf2
"""

import torch
import torch.nn as nn

class LeNet(nn.Module):
    
    
    def __init__(self):
        
        super(LeNet, self).__init__()
        
        #特征提取
        self.layer1 =nn.Sequential(
            nn.Conv2d(in_channels = 1, out_channels =6, kernel_size=5, stride=1 ,padding=0),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride =2),
            
            nn.Conv2d(in_channels = 6, out_channels =16, kernel_size=5, stride=1 ,padding=0),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride =2)
            )
        
        # fully layer
        self.layer2 =self.classifier = nn.Sequential(
                        # FC1层，输入为5*5*16=400，输出数为指定的参数值
                        nn.Linear(in_features=400, out_features=120),
                        nn.ReLU(),
                        # FC2 层
                        nn.Linear(in_features=120, out_features=84),
                        nn.ReLU(),
                        # FC3 层
                        nn.Linear(in_features=84, out_features=10)
                        )

      
        
    
    def forward(self, x):
        #前向传播
        x = self.layer1(x)
        print("\n 卷积 池化后输出  ",x.shape)
        
        x = torch.flatten(x,1)
        print("\n  flatten 后输出  ",x.shape)
        
        out = self.layer2(x)
        return out
        

if __name__ == "__main__":
    
    model = LeNet()
    image = torch.rand((1,1,32,32))
    out = model(image)

参考：

https://www.cnblogs.com/yifanrensheng/p/12547660.html

9.1 Deep Dream：计算机生成梦幻图像 - csmhwu

10: Convolutional Neural Network_哔哩哔哩_bilibili

深度学习——优化算法 - 知乎

LeNet5—论文及源码阅读_lenet5论文-CSDN博客

谷歌Deep Dream解析（附源代码，可以直接运行）-CSDN博客

【Neural Style Transfer】Deep Photo Style Transfer（含代码详解）-CSDN博客