神经网络小记-cnn

卷积神经网络（Convolutional Neural Network, CNN）是一种深度学习模型，主要用于处理具有网格结构的数据，如图像和语音。CNN以其在计算机视觉任务中的出色表现而闻名，并在许多领域取得了重大突破。下面是CNN的原理详解：

1. 卷积操作（Convolution）：CNN的核心操作是卷积操作。卷积操作通过使用卷积核（也称为滤波器）在输入数据上滑动，计算输入数据与卷积核之间的点积。卷积操作可以有效地提取输入数据的局部特征，并保留其空间结构。卷积核的参数是通过训练过程学习得到的。

2. 激活函数（Activation Function）：在卷积操作后，通常会应用一个非线性的激活函数，如ReLU（Rectified Linear Unit）。激活函数的作用是引入非线性性质，使网络能够学习和表示更复杂的特征。

3. 池化操作（Pooling）：在卷积层之间，通常会添加池化层。池化操作通过对输入数据的某个区域进行聚合，例如取最大值（Max Pooling）或计算平均值（Average Pooling），以减小特征图的尺寸并减少参数数量。池化操作能够保留主要的特征信息，并使网络具有平移不变性和部分空间不变性。

4. 多层堆叠：CNN通常由多个卷积层和池化层堆叠而成。通过堆叠多个卷积层和池化层，网络可以逐渐提取更高级别的特征，并形成更抽象的表示。较低层的卷积层可以捕捉低级别的特征，例如边缘和纹理，而较高层的卷积层可以捕捉更高级别的特征，例如形状和对象。

5. 全连接层（Fully Connected Layer）：在CNN的最后几层，通常会添加全连接层，也称为密集连接层。全连接层将上一层的所有神经元与当前层的每个神经元相连，用于将高级别特征映射到目标类别上。全连接层通常在输出层之前，通过一些激活函数（如softmax）产生最终的预测结果。

6. 反向传播（Backpropagation）与优化：CNN通过反向传播算法来学习网络中的参数。反向传播使用损失函数和训练数据之间的差异来计算梯度，并将梯度传递回网络的每一层，以更新参数。常用的优化算法包括随机梯度下降（SGD）、Adam、RMSprop等，用于根据梯度信息更新网络参数，使网络能够逐步优化和调整，以提高预测准确性。

总结起来，CNN通过卷积操作、激活函数、池化操作和全连接层等组件构建起来的深度学习模型。它能够有效地提取输入数据的局部特征并保留其空间结构，通过多层堆叠逐渐提取更高级别的特征。通过反向传播和优化算法，CNN能够学习适合特定任务的参数，并在图像分类、目标检测、语音识别等领域中取得优秀的性能。

卷积操作

卷积操作是卷积神经网络（CNN）中的核心操作之一，用于提取输入数据的特征。下面是CNN中的卷积操作的详细说明。

假设我们有一个输入数据（图像）$X$，它是一个三维张量，具有形状（通道数，高度，宽度）。我们还有一组卷积核（滤波器）$W$，它也是一个三维张量，具有形状（输出通道数，输入通道数，卷积核高度，卷积核宽度）。卷积操作将输入数据和卷积核进行卷积运算，得到输出特征图。

卷积操作的具体步骤如下：

1. 输入数据$X$的每个通道与卷积核$W$进行逐元素相乘，并将结果相加。
2. 将得到的结果加上一个偏置$b$。
3. 将偏置添加到每个通道的结果中。
4. 重复以上步骤，对每个输出通道的卷积核进行操作。

可以用以下公式表示卷积操作：

$Y_{i,j,k}={\sum }_{m=1}^{C_{in}}{\sum }_{p=1}^{H_k}{\sum }_{q=1}^{W_k}{X}_{m,i+p-1,j+q-1}\cdot W_{k,m,p,q}+b_k$

其中，

• $Y$是输出特征图，具有形状（输出通道数，输出高度，输出宽度）。
• $C_{in}$是输入通道数。
• $H_k$和$W_k$是卷积核的高度和宽度。
• $X_{m,i,j}$是输入数据的元素，表示输入数据的第$m$个通道、第$i$行、第$j$列的值。
• $W_{k,m,p,q}$是卷积核的元素，表示第$k$个输出通道、第$m$个输入通道、第$p$行、第$q$列的值。
• $b_k$是第$k$个输出通道的偏置项。

上述公式中的索引$i,j$表示输出特征图上的位置，$k$表示输出通道。通过遍历输出特征图的每个位置和输出通道，可以计算出整个输出特征图。

在实际应用中，通常还会使用激活函数（如ReLU）对输出特征图进行非线性变换，以增加模型的表达能力。此外，卷积操作中还可以使用步幅（stride）和填充（padding）来控制输出特征图的尺寸。

以上是卷积操作的基本原理和公式。卷积操作是在每个通道上独立进行的，每个卷积核都有自己的权重，因此卷积层中的每个卷积核可以学习到不同的特征。在实际的卷积神经网络中，还有其他高级的卷积操作，如批归一化、残差连接等，以提高模型性能和训练稳定性。

一维卷积与二维卷积计算

1. 一维卷积核计算：

假设有一个一维输入序列x，长度为n，和一个一维卷积核w，长度为m。一维卷积的计算过程可以表示为：

输出序列 y[i] = sum(x[i:i+m] * w)

其中，y[i]是输出序列的第i个元素，x[i:i+m]表示从输入序列x中取出连续的m个元素，* 表示逐元素乘法，sum表示对所有乘积结果进行求和。

示例：
假设输入序列x为 [1, 2, 3, 4, 5, 6, 7, 8, 9]，卷积核w为 [1, -1, 1]，则输出序列y的计算过程如下：

y[0] = sum([1, 2, 3] * [1, -1, 1]) = sum([1, -2, 3]) = 2
y[1] = sum([2, 3, 4] * [1, -1, 1]) = sum([2, -3, 4]) = 3
y[2] = sum([3, 4, 5] * [1, -1, 1]) = sum([3, -4, 5]) = 4
...
y[6] = sum([7, 8, 9] * [1, -1, 1]) = sum([7, -8, 9]) = 8

输出序列y为 [2, 3, 4, 4, 4, 4, 4, 8]。

2. 二维卷积核计算：

假设有一个二维输入图像X，大小为HxW，和一个二维卷积核K，大小为KhxKw。二维卷积的计算过程可以表示为：

输出特征图 Y[i, j] = sum(X[i:i+Kh, j:j+Kw] * K)

其中，Y[i, j]是输出特征图的第i行第j列的元素，X[i:i+Kh, j:j+Kw]表示从输入图像X中取出大小为KhxKw的子区域，* 表示逐元素乘法，sum表示对所有乘积结果进行求和。

示例：
假设输入图像X为以下3x3的矩阵：

[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

卷积核K为以下2x2的矩阵：

[1, 0]
[0, -1]

则输出特征图Y的计算过程如下：

Y[0, 0] = sum([[1, 2], [4, 5]] * [[1, 0], [0, -1]]) = sum([[1, 0], [0, -5]]) = -4
Y[0, 1] = sum([[2, 3], [5, 6]] * [[1, 0], [0, -1]]) = sum([[2, 0], [0, -6]]) = -4
Y[1, 0] = sum([[4, 5], [7, 8]] * [[1, 0], [0, -1]]) = sum([[4, 0], [0, -8]]) = -8
Y[1, 1] = sum([[5, 6], [8, 9]] * [[1, 0], [0, -1]]) = sum([[5, 0], [0, -9]]) = -4

输出特征图Y为以下2x2的矩阵：

[-4, -4]
[-8, -4]

以上就是一维卷积核和二维卷积核的计算过程的详细说明。在实际卷积神经网络中，这些计算会在多个通道和多个卷积核之间进行，并通过权重共享和反向传播来训练卷积核参数，以实现特征提取和模型优化。

池化操作

池化操作是卷积神经网络（CNN）中常用的一种操作，用于减小特征图的尺寸、减少计算量并增强特征的平移不变性。池化操作通常应用于卷积层之后，将特征图进行下采样。

常见的池化操作有最大池化（Max Pooling）和平均池化（Average Pooling）两种形式。

1. 最大池化（Max Pooling）：

   • 最大池化操作是从输入特征图的局部区域中选择最大值作为池化后的输出。
   • 最大池化可以减小特征图的尺寸，并保留最显著的特征。
   • 最大池化的公式为：
     $$\text{输出}(i,j)=\max (\text{输入}(i\cdot \text{步幅}:i\cdot \text{步幅}+\text{池化核大小},j\cdot \text{步幅}:j\cdot \text{步幅}+\text{池化核大小}))$$
   • 其中，$i$和$j$分别表示池化操作的行和列索引，$\text{输入}$和$\text{输出}$表示输入和输出特征图，$\text{步幅}$表示池化操作的步幅，$\text{池化核大小}$表示池化操作的核大小。

2. 平均池化（Average Pooling）：

   • 平均池化操作是从输入特征图的局部区域计算平均值作为池化后的输出。
   • 平均池化可以减小特征图的尺寸，并平滑特征。
   • 平均池化的公式为：
     $$\text{输出}(i,j)=\frac{1}{{\text{池化核大小}}^2}\sum _{m=i\cdot \text{步幅}}^{i\cdot \text{步幅}+\text{池化核大小}-1}\sum _{n=j\cdot \text{步幅}}^{j\cdot \text{步幅}+\text{池化核大小}-1}\text{输入}(m,n)$$
   • 其中，$i$和$j$分别表示池化操作的行和列索引，$\text{输入}$和$\text{输出}$表示输入和输出特征图，$\text{步幅}$表示池化操作的步幅，$\text{池化核大小}$表示池化操作的核大小。

池化操作通过降低特征图的维度，减少了计算量和参数数量，提高了模型的计算效率。同时，池化操作还具有一定的平移不变性和局部不变性，对于平移和缩放的输入具有一定的鲁棒性。

需要注意的是，池化操作是一种无参操作，不需要训练参数。在设计网络时，应根据任务需求和数据特点选择适当的池化操作和参数设置。
假设有一个输入特征图大小为 4x4 的张量：

输入特征图：
[[1, 2, 1, 3],
 [4, 2, 1, 3],
 [2, 1, 3, 4],
 [1, 2, 4, 3]]

1. 最大池化（Max Pooling）：
   • 假设采用 2x2 的池化核和步幅为 2，即每隔 2 个元素进行一次池化操作。
   • 最大池化操作将每个 2x2 的局部区域中的最大值作为输出。
   • 池化后的特征图大小为 2x2。

最大池化后的特征图：
[[4, 3],
 [2, 4]]

2. 平均池化（Average Pooling）：
   • 假设采用 2x2 的池化核和步幅为 2，即每隔 2 个元素进行一次池化操作。
   • 平均池化操作将每个 2x2 的局部区域中的平均值作为输出。
   • 池化后的特征图大小为 2x2。

平均池化后的特征图：
[[2.25, 2.25],
 [1.75, 3.25]]

以上是对于一个简单的输入特征图的池化操作示例。在实际应用中，输入特征图的尺寸和池化操作的参数会根据具体的任务需求和网络架构进行调整。

• 其他池化方式
  除了最大池化和平均池化，还有一些其他常见的池化方式，包括：

1. L2范数池化（L2-Norm Pooling）：

   • L2范数池化操作将输入特征图的每个局部区域的L2范数作为输出。
   • L2范数池化可以强调输入特征图的强度或能量，并提取具有较大幅度的特征。
   • L2范数池化的公式为：
     $$\text{输出}(i,j)=\sqrt{\sum _{m=i\cdot \text{步幅}}^{i\cdot \text{步幅}+\text{池化核大小}-1}\sum _{n=j\cdot \text{步幅}}^{j\cdot \text{步幅}+\text{池化核大小}-1}\text{输入}(m,n{)}^2}$$

2. 最小池化（Min Pooling）：

   • 最小池化操作将输入特征图的每个局部区域的最小值作为输出。
   • 最小池化可以捕捉输入特征图中的最小特征，并在一定程度上保留边缘信息。
   • 最小池化的公式为：
     $$\text{输出}(i,j)=\min (\text{输入}(i\cdot \text{步幅}:i\cdot \text{步幅}+\text{池化核大小},j\cdot \text{步幅}:j\cdot \text{步幅}+\text{池化核大小}))$$

3. 均值均差池化（Mean Deviation Pooling）：

   • 均值均差池化操作将输入特征图的每个局部区域的平均值与标准差作为输出。
   • 均值均差池化可以提取输入特征图中的平均水平和变化程度。
   • 均值均差池化的公式为：
     $$\text{均值}=\frac{1}{{\text{池化核大小}}^2}\sum _{m=i\cdot \text{步幅}}^{i\cdot \text{步幅}+\text{池化核大小}-1}\sum _{n=j\cdot \text{步幅}}^{j\cdot \text{步幅}+\text{池化核大小}-1}\text{输入}(m,n)$$
     $$\text{标准差}=\sqrt{\frac{1}{{\text{池化核大小}}^2}\sum _{m=i\cdot \text{步幅}}^{i\cdot \text{步幅}+\text{池化核大小}-1}\sum _{n=j\cdot \text{步幅}}^{j\cdot \text{步幅}+\text{池化核大小}-1}(\text{输入}(m,n)-\text{均值}{)}^2}$$
     $$\text{输出}(i,j)=[\text{均值},\text{标准差}]$$

这些池化方式可以根据任务需求和网络设计的特点进行选择和应用。具体的池化操作和参数设置应根据实际情况进行调整和优化。

参数量计算

下面是常见的卷积神经网络（CNN）各层的计算公式：

1. 卷积层：

   • 输入尺寸：$H_{in}\times W_{in}\times C_{in}$
   • 卷积核尺寸：$K\times K\times C_{in}\times C_{out}$
   • 步幅（stride）：$S$
   • 填充（padding）：$P$
   • 输出尺寸：$H_{out}\times W_{out}\times C_{out}$
   • 公式：
     $$H_{out}=\lfloor \frac{H_{in}+2P-K}{S}+1\rfloor$$
     $$W_{out}=\lfloor \frac{W_{in}+2P-K}{S}+1\rfloor$$

2. 池化层：

   • 输入尺寸：$H_{in}\times W_{in}\times C$
   • 池化核尺寸：$K\times K$
   • 步幅（stride）：$S$
   • 填充（padding）：$P$
   • 输出尺寸：$H_{out}\times W_{out}\times C$
   • 公式：
     $$H_{out}=\lfloor \frac{H_{in}+2P-K}{S}+1\rfloor$$
     $$W_{out}=\lfloor \frac{W_{in}+2P-K}{S}+1\rfloor$$

3. 全连接层：

   • 输入尺寸：$N\times M$
   • 权重矩阵尺寸：$M\times O$
   • 偏置尺寸：$O$
   • 输出尺寸：$N\times O$
   • 公式：
     $$\text{输出}=\text{输入}\times \text{权重矩阵}+\text{偏置}$$

以上是一般情况下的计算公式，具体的网络结构和参数设置会影响公式的细节。请根据具体的网络架构和参数设置来调整公式中的变量和参数。

• 例一

卷积操作的参数量计算涉及卷积核的大小、输入通道数、输出通道数等因素。假设输入的特征图大小为$H\times W$，输入通道数为$C_{\text{in}}$，输出通道数为$C_{\text{out}}$，卷积核的大小为$K\times K$。

对于每个输出通道，卷积操作需要学习一个独立的卷积核，该卷积核的大小为$C_{\text{in}}\times K\times K$。因此，每个输出通道的参数量为$C_{\text{in}}\times K\times K$。

由此可知，总的参数量为$C_{\text{out}}\times (C_{\text{in}}\times K\times K)$。需要注意的是，每个输出通道都有一个独立的卷积核，因此参数量与输出通道数成正比。

另外，还需要考虑卷积操作的偏置项。对于每个输出通道，都需要一个偏置项。因此，偏置项的参数量为$C_{\text{out}}$。

总的参数量（包括权重和偏置项）为：
$C_{\text{out}}\times (C_{\text{in}}\times K\times K+1)$

需要注意的是，这个参数量计算仅考虑了单个卷积层的情况。在实际的卷积神经网络中，可能有多个卷积层堆叠在一起，或者包含其他组件（如池化层、全连接层等）。在这种情况下，需要将每个组件的参数量相加，得到整个网络的总参数量。

• 例二

假设我们有一个输入特征图的大小为 $32\times 32$，输入通道数为 3，输出通道数为 64，卷积核的大小为 $3\times 3$。

对于每个输出通道，卷积操作需要学习一个独立的卷积核。每个卷积核的大小为 $3\times 3\times 3$，其中 3 是输入通道数。因此，每个输出通道的参数量为 $3\times 3\times 3=27$。

考虑到输出通道数为 64，因此总的参数量为 $64\times 27=1728$。这些参数是卷积核的权重。

此外，对于每个输出通道，还需要一个偏置项。由于输出通道数为 64，偏置项的参数量为 64。

因此，总的参数量（包括权重和偏置项）为 $1728+64=1792$。

这个示例说明了在一个卷积层中，输入特征图大小、输入通道数、输出通道数和卷积核大小对于参数量的计算的影响。实际上，在更复杂的卷积神经网络中，每个卷积层的参数量会更大，并且还需要考虑其他组件（如池化层、全连接层等）的参数量。因此，随着网络的加深和复杂度的增加，参数量也会相应增加。

要计算卷积操作后的数量，需要考虑输入特征图的大小、卷积核的大小、步长（stride）以及填充（padding）的情况。以下是计算卷积后特征图大小的一般公式：

输出特征图大小 = (输入特征图大小 - 卷积核大小 + 2 * 填充) / 步长 + 1

假设输入特征图的大小为 H × W，卷积核的大小为 K × K，步长为 S，填充为 P，则输出特征图的大小为：

输出高度 = (输入高度 - 卷积核高度 + 2 * 填充) / 步长 + 1
输出宽度 = (输入宽度 - 卷积核宽度 + 2 * 填充) / 步长 + 1

请注意，上述公式中的除法是指整数除法，结果向下取整。

例如，如果输入特征图的大小为 32 × 32，卷积核的大小为 3 × 3，步长为 1，填充为 0，则输出特征图的大小为：

输出高度 = (32 - 3 + 2 * 0) / 1 + 1 = 30
输出宽度 = (32 - 3 + 2 * 0) / 1 + 1 = 30

因此，卷积操作后的特征图大小为 30 × 30。这表示输出特征图的高度和宽度都减小了，因为卷积核在沿着输入特征图滑动时会导致边缘像素被忽略。输出特征图的深度（通道数）取决于卷积层中使用的卷积核数量。

需要注意的是，填充和步长的选择会影响输出特征图的大小和感受野（receptive field），并且可以根据任务和网络设计进行调整。

示例代码 CIFAR10数据集

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 定义CNN模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(32 * 8 * 8, 128)
        self.relu3 = nn.ReLU()
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.pool2(x)
        x = x.view(-1, 32 * 8 * 8)
        x = self.fc1(x)
        x = self.relu3(x)
        x = self.fc2(x)
        return x

# 定义训练函数
def train(model, device, train_loader, criterion, optimizer):
    model.train()
    for images, labels in train_loader:
        images = images.to(device)
        labels = labels.to(device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

# 定义测试函数
def test(model, device, test_loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in test_loader:
            images = images.to(device)
            labels = labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    accuracy = 100 * correct / total
    return accuracy

# 设置训练参数
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
num_epochs = 10
batch_size = 32
learning_rate = 0.001

# 加载数据集
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 初始化模型和优化器
model = Net().to(device)
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
criterion = nn.CrossEntropyLoss()

# 训练和测试模型
for epoch in range(num_epochs):
    train(model, device, train_loader, criterion, optimizer)
    accuracy = test(model, device, test_loader)
    print('Epoch [{}/{}], Accuracy: {:.2f}%'.format(epoch + 1, num_epochs, accuracy))

什么时候可以不用池化层

池化层在卷积神经网络（CNN）中通常用于减小特征图的尺寸、降低计算量并增强特征的平移不变性。然而，并不是所有的情况下都需要使用池化层。以下是一些情况下可以不使用池化层的例子：

1. 小尺寸输入：如果输入的图像尺寸较小，池化操作可能会导致信息的丢失或过度降采样。在这种情况下，可以考虑跳过池化层并直接进行卷积操作。

2. 特征映射稀疏性：如果输入的特征映射已经相对稀疏，并且存在大量的零值或低活性区域，那么池化操作可能会进一步稀疏化特征映射，导致信息丢失。在这种情况下，可以考虑不使用池化层，以保留更多的稀疏特征。

3. 目标定位任务：对于需要准确目标定位的任务（如目标检测或图像分割），池化层可能会降低定位精度。在这种情况下，可以选择不使用池化层或使用更具定位能力的替代方法，如空洞卷积（dilated convolution）。

需要注意的是，池化层的使用与具体的任务、数据和网络架构密切相关。在设计和选择模型时，应根据具体情况综合考虑是否使用池化层，并进行实验和验证以确定最佳的网络结构和参数设置。