网络模型整理

photo_chip

已于 2023-05-15 19:32:36 修改

阅读量367

点赞数 3

文章标签： python

于 2023-04-30 18:26:07 首次发布

本文链接：https://blog.csdn.net/photo_chip/article/details/130450422

版权

文章目录

一、EEGNet：[《EEGNet: A Compact Convolutional Neural Network for EEG-based Brain-Computer Interfaces》](https://iopscience.iop.org/article/10.1088/1741-2552/aace8c/meta)
二、TCN： [An Empirical Evaluation of Generic Convolutional and Recurrent Networks for Sequence Modeling](https://arxiv.org/pdf/1803.01271.pdf)

一、EEGNet：《EEGNet: A Compact Convolutional Neural Network for EEG-based Brain-Computer Interfaces》

参考

本文是18年发表在2区期刊上的文章，设计思路借鉴MobileNet，轻量级模型，创新点是是depthwise conv 和separable conv这两个卷积模块。

激活函数

传统激活函数发展 sigmoid -> tanh -> ReLU （目前最常用的激活函数）,EEGnet有使用ELU激活函数，其具有如ReLU的正值特性，所以一样可以缓解梯度消失问题，而ELU还有负值，可以让激活单元输出的均值更接近0，从而达到正则化的效果。且ELU的负值计算是指数函数，不会发生突变，所以对输入变化或噪声更鲁棒。（SELU输出的均值不但更接近0，其方差也更接近单位方差1，进一步达到正则化效果，提升收敛速度等）

在这里插入图片描述

三种卷积层

1.普通的卷积操作

在这里插入图片描述

对于输入为553的数据，经过卷积层中3*3的卷积核处理，如果卷积层的步长为1，padding方式是valid那么输出尺寸变为3×3。（这里假设输出通道为4，所以有四个卷积层。）

卷积层共4个filter，每个filter有1个bias参数，每个filter包含了3个kernel，每个kernel的大小为3×3。

卷积层的参数数量计算：Parameters = 4 × 3 × 3 × 3 + 4 = 112

2.Depthwise Convolution—逐通道的卷积层

在这里插入图片描述
卷积层共3个filter，每个filter有1个bias参数，每个filter包含了1个kernel，每个kernel的大小为3×3。

卷积层的参数数量计算：Parameters = 3× 1 × 3 × 3 + 3 = 30

nn.Conv2d(
               in_channels=8,  # input shape (8, C, T)
               out_channels=16,  # num_filters
               kernel_size=(22, 1),  # filter size
               groups=8,
               bias=False
           ),  # output shape (16, 1, T)

通过group参数来实现该操作，将输入数据分组，如实例代码所示，将8个通道分为8组，然后输出通道也分为8组，这样就是输入的第一个通道分别和卷积层1，2卷积操作，第二个通道和卷积层3，4卷积操作… 最终得到16个特征图。
评价：虽然这样显著减少了卷积层的参数数量，但是这种方法没有有效利用不同通道在相同空间位置上的feature信息。未很好的利用空间特征！

3.Pointwise Convolution—逐点的卷积层

在这里插入图片描述
卷积层共4个filter，每个filter有1个bias参数，每个filter包含了3个kernel，每个kernel的大小为1×1。

卷积层的参数数量计算：Parameters = 4× 3 × 1 × 1 + 4 = 16

评价：pointwise convolution能将上一步生成的feature map在空间维度进行加权组合，正好弥补了Depthwise Convolution的缺点。

总结

EEGnet由1个普通卷积 + 1个Depthwise conv + 1个separable conv组成，其中， separable Convolution（深度分离卷积层）由一个Depthwise Convolution和一个Pointwise convolution组成。总之模型减少卷积层的参数数量（减少过拟合的可能性；加快模型的运算速度）

二、TCN： An Empirical Evaluation of Generic Convolutional and Recurrent Networks for Sequence Modeling

参考

RNN在处理序列问题上表现很好，但是RNN 在内部设计上存在一个严重的问题：由于网络一次只能处理一个时间步长，后一步必须等前一步处理完才能进行运算。为了能使RNN向CNN一样大规模并行处理，设计出了TCN 模型，以 CNN 模型为基础，并做了如下改进：

适用序列模型：因果卷积（Causal Convolution）
记忆历史：空洞卷积/膨胀/扩张卷积（Dilated Convolution）
残差模块（Residual block）

因果卷积(Causal Convolutions)

特点：1.输入输出尺寸相同、2.不考虑未来的数据、3.追溯历史信息越久远，隐藏层越多。

在因果卷积中，使用一维卷积，kernel_size=2，为满足特点1,2，设置padding=1，同时要dilation=1，保证未来的一个数据没考虑，如下图：
在这里插入图片描述
Pytorch实现代码：

net =nn.Conv1d(in_channels=1, out_channels=1, kernel_size=2, stride=1, padding=1, dilation=1)

按照代码所示，如果要求视野域是4，要堆积三个卷积核为2的一维卷积，如图中的红色部分：（也能看出来随着视野域增大，中间层增多。）
在这里插入图片描述

膨胀因果卷积(Dilated Causal Convolution)

仅靠因果卷积存在着传统CNN的问题：对时间的建模长度是受限于卷积核大小的，如果要想抓去更长的依赖关系，就需要线性的堆叠很多的层。
标准CNN可以通过增加 pooling 层来获得更大的感受野，而经过 pooling 层后肯定存在信息损失的问题。

膨胀卷积在标准CNN中注入空洞，由此增加感受野。通过设置采样率（dilatation rate）来控制卷积时的输入的间隔采样。

上图即为dilation=2的情况，看淡绿色数据：因为dilation变大了，所以相应的padding的数量从1变成了2，所以为了保证输入输出的特征维度相同，padding的数值(在卷积核是2的情况下)等于dalition的数值

可以看到，第一次卷积使用dilation=1的卷积，然后第二次使用dilation=2的卷积，这样通过两次卷积就可以实现视野域是4.

残差模块（Residual block）

简单的增加深度，会导致==梯度消失或爆炸、网络退化问题。==分别使用权重参数初始化和采用正则化层、残差网络方法解决。

残差模块用于卷积层。加法变为对应 channel 间的两个 feature map 逐元素相加。

总述及代码

TCN的基本模块TemporalBlock()

卷积并进行weight_norm结束后会因为padding导致卷积之后的新数据的尺寸B>输入数据的尺寸A，所以只保留输出数据中前面A个数据；
卷积之后加上个ReLU和Dropout层。
然后TCN中并不是每一次卷积都会扩大一倍的dilation，而是每两次扩大一倍的dilation
总之，TCN中的基本组件：TemporalBlock()是两个dilation相同的卷积层，卷积+修改数据尺寸+relu+dropout+卷积+修改数据尺寸+relu+dropout
之后弄一个Resnet残差连接来避免梯度消失，结束！

代码

# 导入库
import torch
import torch.nn as nn
#Applies weight normalization to a parameter in the given module.
from torch.nn.utils import weight_norm
 
# 这个函数是用来修剪卷积之后的数据的尺寸，让其与输入数据尺寸相同。
class Chomp1d(nn.Module):
    def __init__(self, chomp_size):
        super(Chomp1d, self).__init__()
        self.chomp_size = chomp_size#这个chomp_size就是padding的值
 # torch.contiguous()方法首先拷贝了一份张量在内存中的地址，然后将地址按照形状改变后的张量的语义进行排列。
    def forward(self, x):
        return x[:, :, :-self.chomp_size].contiguous()
 
 
# 这个就是TCN的基本模块，包含8个部分，两个（卷积+修剪+relu+dropout）
# 里面提到的downsample就是下采样，其实就是实现残差链接的部分。不理解的可以无视这个
class TemporalBlock(nn.Module):
    def __init__(self, n_inputs, n_outputs, kernel_size, stride, dilation, padding, dropout=0.2):
        super(TemporalBlock, self).__init__()
         
        self.conv1 = weight_norm(nn.Conv1d(n_inputs, n_outputs, kernel_size,
                                           stride=stride, padding=padding, dilation=dilation))
        self.chomp1 = Chomp1d(padding)
        self.relu1 = nn.ReLU()
        self.dropout1 = nn.Dropout(dropout)
 
 
        self.conv2 = weight_norm(nn.Conv1d(n_outputs, n_outputs, kernel_size,
                                           stride=stride, padding=padding, dilation=dilation))
        self.chomp2 = Chomp1d(padding)
        self.relu2 = nn.ReLU()
        self.dropout2 = nn.Dropout(dropout)
 
 
        self.net = nn.Sequential(self.conv1, self.chomp1, self.relu1, self.dropout1,
                                 self.conv2, self.chomp2, self.relu2, self.dropout2)
        self.downsample = nn.Conv1d(n_inputs, n_outputs, 1) if n_inputs != n_outputs else None
        self.relu = nn.ReLU()
        self.init_weights()
 
    def init_weights(self):
        self.conv1.weight.data.normal_(0, 0.01)
        self.conv2.weight.data.normal_(0, 0.01)
        if self.downsample is not None:
            self.downsample.weight.data.normal_(0, 0.01)
 
    def forward(self, x):
        out = self.net(x)
        res = x if self.downsample is None else self.downsample(x)
        return self.relu(out + res)
 
 
#最后就是TCN的主网络了
class TemporalConvNet(nn.Module):
    def __init__(self, num_inputs, num_channels, kernel_size=2, dropout=0.2):
        super(TemporalConvNet, self).__init__()
        layers = []
        num_levels = len(num_channels)
        for i in range(num_levels):
            dilation_size = 2 ** i
            in_channels = num_inputs if i == 0 else num_channels[i-1]
            out_channels = num_channels[i]
            layers += [TemporalBlock(in_channels, out_channels, kernel_size, stride=1, dilation=dilation_size,
                                     padding=(kernel_size-1) * dilation_size, dropout=dropout)]
 
        self.network = nn.Sequential(*layers)
 
    def forward(self, x):
        return self.network(x)