CNN、RNN学习笔记（自用）_ncnn学习笔记

作者：不正经 | 2024-03-22 03:18:23

踩

ncnn学习笔记

应用场景

CNN：卷积神经网络，专门用于图像处理的神经网络，能够自动学习图像中的特征数据，在图像识别、对象检测和自动驾驶中表现出色；
RNN：循环神经网络，具有时间序列处理能力，捕捉序列中的长期依赖关系，在NLP、语音识别、机器翻译中表现出色；
DNN：深度神经网络，可以处理各种数据，包括图像、文本、时间序列，能够学习复杂的表示，在图像识别、自然语言处理、推荐系统等场景中都可使用。

算法原理

CNN

在CNN中，卷积层用于学习图像的局部特征，然后这些特征被传递到全连接层，以进行分类或其他任务。具体来说，CNN的算法步骤如下：

初始化权重矩阵。【数据输入层/input layer】
对于每个卷积核，对输入图像进行卷积操作。【卷积计算层/CONV layer】
对卷积结果进行激活函数处理。【ReLU激励层/ReLU layer】
对卷积结果进行池化操作。【池化层/Pooling layer】
将池化结果传递到全连接层。【全连接层/FC layer】
在全连接层，对输入数据进行处理，然后将其传递到输出层。【输出层/output layer】
在输出层，计算分类结果。

整体过程

提取人眼睛特征过程

RNN

RNN的算法原理是基于循环连接的。在RNN中，每个隐藏单元都有一个状态，这个状态在每个时间步被更新。这使得RNN能够捕捉到序列中的长期依赖关系。具体来说，RNN的算法步骤如下：

初始化隐藏状态为零向量。
对于每个时间步，对输入数据进行处理，然后将其传递到隐藏层。
在隐藏层，每个隐藏单元根据其前一个状态和输入数据计算新的状态。
对于每个输出单元，计算输出值。
更新隐藏状态。
重复步骤2-5，直到所有输入数据被处理。

算法实现

CNN


import torch # 需要的各种包
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as data
import matplotlib.pyplot as plt
import torchvision # 数据库模块
 
 
# 数据预处理
# 将training data转化成torch能够使用的DataLoader，这样可以方便使用batch进行训练
torch.manual_seed(1) # reproducible 将随机数生成器的种子设置为固定值，这样，当调用时torch.rand(x)，结果将可重现
 
# Hyper Parameters
EPOCH = 1 # 训练迭代次数
BATCH_SIZE = 50 # 分块送入训练器
LR = 0.001 # 学习率 learning rate
 
train_data = torchvision.datasets.MNIST(
    root='./mnist/', # 保存位置 若没有就新建
    train=True, # training set
    transform=torchvision.transforms.ToTensor(), # 
    # converts a PIL.Image or numpy.ndarray to torch.FloatTensor(C*H*W) in range(0.0,1.0)
    download=True
)
 
test_data = torchvision.datasets.MNIST(root='./MNIST/')
 
# 如果是普通的Tensor数据，想使用 torch_dataset = data.TensorDataset(data_tensor=x, target_tensor=y)
# 将Tensor转换成torch能识别的dataset
# 批训练， 50 samples, 1 channel, 28*28, (50, 1, 28 ,28)
train_loader = data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
 
test_x = Variable(torch.unsqueeze(test_data.test_data, dim=1), volatile=True).type(torch.FloatTensor)[:2000]/255.
# torch.unsqueeze 返回一个新的张量，对输入的既定位置插入维度 1
 
test_y = test_data.test_lables[:2000]
# 数据预处理
 
 
# 定义网络结构
# 1）class CNN需要·继承·Module 
# 2）需要·调用·父类的构造方法：super(CNN, self).__init__()
# 3）在Pytorch中激活函数Relu也算是一层layer
# 4）需要·实现·forward()方法，用于网络的前向传播，而反向传播只需要·调用·Variable.backward()即可。
# 输入的四维张量[N, C, H, W]
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # nn.Sequential一个有序的容器，神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行，
        # 同时以神经网络模块为元素的有序字典也可以作为传入参数
        # nn.Conv2d 二维卷积 先实例化再使用 在Pytorch的nn模块中，它是不需要你手动定义网络层的权重和偏置的
        self.conv1 = nn.Sequential( #input shape (1,28,28)
            nn.Conv2d(in_channels=1, #input height 必须手动提供 输入张量的channels数
                      out_channels=16, #n_filter 必须手动提供 输出张量的channels数
                      kernel_size=5, #filter size 必须手动提供 卷积核的大小 
                      # 如果左右两个数不同，比如3x5的卷积核，那么写作kernel_size = (3, 5)，注意需要写一个tuple，而不能写一个列表（list）
                      stride=1, #filter step 卷积核在图像窗口上每次平移的间隔，即所谓的步长
                      padding=2 #con2d出来的图片大小不变 Pytorch与Tensorflow在卷积层实现上最大的差别就在于padding上
            ), # output shape (16,28,28) 输出图像尺寸计算公式是唯一的 # O = （I - K + 2P）/ S +1
            nn.ReLU(), # 分段线性函数，把所有的负值都变为0，而正值不变，即单侧抑制
            nn.MaxPool2d(kernel_size=2) #2x2采样，28/2=14，output shape (16,14,14) maxpooling有局部不变性而且可以提取显著特征的同时降低模型的参数，从而降低模型的过拟合
        ) 
        self.conv2 = nn.Sequential(nn.Conv2d(16, 32, 5, 1, 2), #output shape (32,7,7)
                                  nn.ReLU(),
                                  nn.MaxPool2d(2))
        # 因上述几层网络处理后的output为[32,7,7]的tensor，展开即为7*7*32的一维向量，接上一层全连接层，最终output_size应为10，即识别出来的数字总类别数
        # 在二维图像处理的任务中，全连接层的输入与输出一般都设置为二维张量，形状通常为[batch_size, size]
        self.out = nn.Linear(32*7*7, 10) # 全连接层 7*7*32, num_classes
        
    def forward(self, x):
        x = self.conv1(x) # 卷一次
        x = self.conv2(x) # 卷两次
        x = x.view(x.size(0), -1) #flat (batch_size, 32*7*7) 
        # 将前面多维度的tensor展平成一维 x.size(0)指batchsize的值
        # view()函数的功能根reshape类似，用来转换size大小
        output = self.out(x) # fc out全连接层 分类器
        return output
# 定义网络结构
 
 
# 查看网络结构
cnn = CNN()
print(cnn) # 使用print(cnn)可以看到网络的结构详细信息，可以看到ReLU()也是一层layer
# 查看网络结构
 
 
# 训练 需要特别指出的是记得每次反向传播前都要清空上一次的梯度，optimizer.zero_grad()
# optimizer 可以指定程序优化特定的选项，例如学习速率，权重衰减等
optimizer = torch.optim.Adam(cnn.parameters(), lr=LR) # torch.optim是一个实现了多种优化算法的包
 
# loss_fun CrossEntropyLoss 交叉熵损失
# 信息量：它是用来衡量一个事件的不确定性的；一个事件发生的概率越大，不确定性越小，则它所携带的信息量就越小。
# 熵：它是用来衡量一个系统的混乱程度的，代表一个系统中信息量的总和；信息量总和越大，表明这个系统不确定性就越大。
# 交叉熵：它主要刻画的是实际输出（概率）与期望输出（概率）的距离，也就是交叉熵的值越小，两个概率分布就越接近
loss_func = nn.CrossEntropyLoss() # 该损失函数结合了nn.LogSoftmax()和nn.NLLLoss()两个函数 适用于分类
 
# training loop
for epoch in range(EPOCH):
    for i, (x, y) in enumerate(train_loader):
        batch_x = Variable(x)
        batch_y = Variable(y)
        output = cnn(batch_x) # 输入训练数据
        loss = loss_func(output, batch_y) # 计算误差 #　实际输出，　期望输出
        optimizer.zero_grad() # 清空上一次梯度
        loss.backward() # 误差反向传递 只需要调用.backward()即可
        optimizer.step() # cnn的优化器参数更新
# 训练
 
 
# 预测结果
# cnn.eval()
test_output = cnn(test_x[:10])
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
# torch.max(input, dim)函数  
# torch.max(test_output, 1)[1]  取出来indices 每行最大值的索引
# 输入 input是softmax函数输出的一个tensor  
# 输入 dim是max函数索引的维度0/1，0是每列的最大值，1是每行的最大值
# 输出 函数会返回两个tensor，第一个tensor是每行的最大值；第二个tensor是每行最大值的索引。
# squeeze()函数的功能是：从矩阵shape中，去掉维度为1的。例如一个矩阵是的shape是（5， 1），使用过这个函数后，结果为（5，）。
print(pred_y, 'prediction number')
print(test_y[:10], 'real number')
# 预测结果

RNN


#pytorch调用RNN代码
class RNN(nn.Module):
    def __init__(self, input_size, output_size, hidden_dim, n_layers):
        super(RNN, self).__init__()
        #隐藏层特征数量
        self.hidden_dim=hidden_dim
        '''
        input_size    – 输入x中预期特征的数量
		hidden_size   – 隐藏状态h的特征数量
		num_layers    - 循环层数。例如，设置 num_layers=2意味着将两个RNN 堆叠在一起形成一个堆叠的RNN，第二个RNN接收						    第一个RNN的输出并计算最终结果。默认值：1
		nonlinearity  — 隐藏层函数，可以是“tanh”或“relu”。默认值：'tanh'
		bias 		  - 如果为 False，则该层不使用偏差权重。默认值：真
		batch_first   - 输入特征是不是批量输入。默认值False
		dropout 	  - 是否要引入Dropout层，dropout概率等于dropout。默认值：0
		bidirectional —如果为真，则成为双向 RNN。默认值：假
		'''
        self.rnn = nn.RNN(input_size, hidden_dim, n_layers, batch_first=True)
        #全连接层
        self.fc = nn.Linear(hidden_dim, output_size)
 
    def forward(self, x, hidden):
        #批量输入大小
        batch_size = x.size(0)
        #批量输入input，隐藏层参数
        r_out, hidden = self.rnn(x, hidden)
        #维度转化
        r_out = r_out.view(-1, self.hidden_dim)  
        #全连接
        output = self.fc(r_out)
        return output, hidden