第一章：计算机视觉中图像的基础认知
第二章：计算机视觉：卷积神经网络(CNN)基本概念(一)
第三章：计算机视觉：卷积神经网络(CNN)基本概念(二)
第四章：搭建一个经典的LeNet5神经网络

接上一篇《计算机视觉：卷积神经网络(CNN)基本概念(一)》

二、图像特征

三、什么是卷积神经网络？

四、什么是灰度图像、灰度值？

灰度图像是只包含亮度信息的图像，没有颜色信息。灰度值（Gray Value）是指图像中每个像素点的亮度值，用于表示该像素的明暗程度。在灰度图像中，每个像素的灰度值通常是一个介于 0 和 255 之间的整数，其中：

• 0 表示黑色（最暗）
• 255 表示白色（最亮）
• 中间值 表示不同程度的灰色

灰度值的计算

对于彩色图像（通常表示为 RGB 格式），可以通过将红、绿、蓝三个通道的值转换为单个灰度值来生成灰度图像。常见的灰度值计算公式包括：

• 加权平均法：Gray=0.299×R+0.587×G+0.114×B，这个公式考虑了人眼对不同颜色的敏感度，其中红色的权重最低，绿色的权重最高。
• 平均法：Gray=(R+G+B) / 3，这个公式简单地取三个通道值的平均值。
• 最大值法：Gray=max(R,G,B)，这个公式取三个通道值中的最大值作为灰度值。

五、特征抽取的具体过程

卷积操作

• 定义：输入图像与卷积核进行卷积运算，生成特征图。
• 示例：一个 3x3 的卷积核在 64x64 的图像上滑动，计算每个位置的加权和，生成一个新的 62x62 的特征图。
• 公式：高度 H = (图片高度 - 卷积核的高度 + 2 * 填充圈数) / 卷积核移动步长 + 1

激活函数

• 定义：通过激活函数（如 ReLU）引入非线性，使网络能够学习更复杂的模式。
• 示例：ReLU 激活函数将负值变为 0，正值保持不变。

池化操作

• 定义：通过池化操作（如最大池化）减少特征图的尺寸，保留最重要的信息。
• 示例：2x2 的最大池化操作将 62x62 的特征图降采样为 31x31 的特征图。

多层卷积和池化

• 定义：通过多层卷积和池化操作，逐步提取更高层次的特征。
• 示例：第二个卷积层会生成 64 个新的特征图，每个特征图捕捉了更复杂的局部特征。

展平

• 定义：最终，将多维的特征图展平成一维向量，输入到全连接层进行分类。假设经过卷积和池化操作后，得到的特征图的尺寸为 H×W×C，其中 H 是高度，W 是宽度，C 是通道数。展平操作将特征图展平成一个一维向量，尺寸为 H×W×C。
• 为什么要展平？，也就是为什么要改变形状，
  - 展平不会改变像素值！
  - 展平不会改变数据本身的信息！
  - 展平为了对口型！
  - 展平为了科学计算！
  - 展平为了矩阵相乘！
• 示例：假设经过卷积和池化操作后，得到的特征图的尺寸为 31x31x64，展平成 61184 维的向量。

全连接

1. 全连接层的定义
   • 在全连接层中，每个神经元都接收前一层所有神经元的输出，并通过加权求和和激活函数来计算自己的输出。

2. 全连接层的结构
   

3. 全连接层的作用

   1. 特征整合
      全连接层可以整合前一层的特征，将局部特征组合成全局特征。这对于分类任务尤为重要，因为它需要综合考虑输入数据的所有信息来做出最终的决策。
      卷积层和池化层提取的是图像的局部特征，而全连接层可以将这些局部特征整合成全局特征。这对于分类任务非常重要，因为最终的分类决策需要综合考虑图像的所有信息。
   2. 分类和回归
      全连接层通常用于神经网络的最后几层，用于输出最终的分类结果或回归值。例如，在图像分类任务中，全连接层可以将卷积层提取的特征图展平成一维向量，然后通过多层全连接层进行分类。
      全连接层的输出层通常用于分类任务，将前一层的特征映射到类别标签。在手写数字识别任务中，全连接层的输出层将特征映射到 10 个类别（0 到 9）。
   3. 非线性变换
      全连接层通过激活函数引入非线性，使神经网络能够学习更复杂的模式和关系。常见的激活函数包括 ReLU、Sigmoid、Tanh 等。
   4. 参数学习
      全连接层的权重和偏置是通过反向传播算法进行学习的。在训练过程中，损失函数的梯度会通过全连接层传递，更新权重和偏置，从而使模型逐渐优化。

六、CNN的简单案例

这段代码实现一个简单的神经网络模型，用于拟合正弦函数 sin(x)， 有4 层全连接层，CNN学习非线性关系。我们可以用一个简单的神经网络来学习这个关系。假设神经网络的结构如下：
输入层：1 个节点
隐藏层：3个隐藏层，第一个隐藏层50个节点，第二个隐藏层80 个节点，第三个隐藏层50 个节点，使用 ReLU 激活函数
输出层：1 个节点，使用线性激活函数

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# 数据准备
# 使用 numpy 库生成从 −2π 到 2π 的等间距数字序列 x，共有1000个点。
x = np.linspace(-2 * np.pi, 2 * np.pi, 1000)
# 计算每个 x 值对应的 sin(x) 值，并存储在 y 中。
y = np.sin(x)
# 然后将这些数据转换为 PyTorch 张量并调整形状以适应后续的神经网络输入要求：
x_tensor = torch.tensor(x, dtype=torch.float32).view(-1, 1)
y_tensor = torch.tensor(y, dtype=torch.float32).view(-1, 1)

# 定义神经网络模型
# 定义了一个名为 SimpleNN 的类，继承自 torch.nn.Module，它是一个简单的全连接神经网络模型，包含4层线性变换（全连接层），每层之间使用ReLU激活函数。
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(1, 50)
        self.fc2 = nn.Linear(50, 80)
        self.fc3 = nn.Linear(80, 50)
        self.fc4 = nn.Linear(50, 1)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.relu(self.fc3(x))
        x = self.fc4(x)
        return x

# 训练模型
# 初始化一个 SimpleNN 模型实例、均方误差(MSE)损失函数以及Adam优化器。
model = SimpleNN()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
# 在每个训练周期中，先清除之前的梯度(optimizer.zero_grad())，
# 然后通过模型前向传播得到预测输出(outputs)，计算损失值(loss)，
# 执行反向传播更新模型权重(loss.backward() 和 optimizer.step())。
for epoch in range(2000):
    optimizer.zero_grad()
    outputs = model(x_tensor)
    loss = criterion(outputs, y_tensor)
    loss.backward()
    optimizer.step()
    # 每200个周期打印一次当前的损失值，观察训练过程中的收敛情况。
    if (epoch + 1) % 200 == 0:
        print(f'Epoch [{epoch+1}/2000], Loss: {loss.item():.4f}')

# 测试模型并绘图
# 将模型设置为评估模式(model.eval())
model.eval()
with torch.no_grad():
	# 在不启用自动求导的情况下(torch.no_grad())，用训练好的模型对输入数据 x_tensor 进行预测。
    predictions = model(x_tensor)

# 使用 matplotlib 绘制原始的正弦曲线和模型的预测曲线，比较两者的拟合效果。这有助于直观地了解模型的拟合程度。
plt.scatter(x, y, label='True Data')
plt.plot(x, predictions.numpy(), color='red', label='Predictions')
plt.legend()
plt.show()

输出结果，从拟合曲线上看，CNN 学习得很好，在这个例子中，神经网络通过隐藏层的 ReLU 激活函数学会了输入 x 和输出 y=sin(x) 之间的非线性关系。通过训练，模型能够很好地拟合这个非线性函数。

Epoch [200/2000], Loss: 0.0002
Epoch [400/2000], Loss: 0.0005
Epoch [600/2000], Loss: 0.0000
Epoch [800/2000], Loss: 0.0003
Epoch [1000/2000], Loss: 0.0000
Epoch [1200/2000], Loss: 0.0003
Epoch [1400/2000], Loss: 0.0006
Epoch [1600/2000], Loss: 0.0007
Epoch [1800/2000], Loss: 0.0002
Epoch [2000/2000], Loss: 0.0002

现在把 上面 4 层全链接，改层 2 层，
神经网络的结构如下：
输入层：1 个节点
隐藏层：1个隐藏层，50 个节点，使用 ReLU 激活函数
输出层：1 个节点，使用线性激活函数
看看是什么效果：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# 数据准备
x = np.linspace(-2 * np.pi, 2 * np.pi, 1000)
y = np.sin(x)
x_tensor = torch.tensor(x, dtype=torch.float32).view(-1, 1)
y_tensor = torch.tensor(y, dtype=torch.float32).view(-1, 1)

# 定义神经网络模型
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(1, 50)
        self.fc4 = nn.Linear(50, 1)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.fc4(x)
        return x

# 训练模型
model = SimpleNN()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

for epoch in range(2000):
    optimizer.zero_grad()
    outputs = model(x_tensor)
    loss = criterion(outputs, y_tensor)
    loss.backward()
    optimizer.step()
    if (epoch + 1) % 200 == 0:
        print(f'Epoch [{epoch+1}/2000], Loss: {loss.item():.4f}')

# 测试模型并绘图
model.eval()
with torch.no_grad():
    predictions = model(x_tensor)

plt.scatter(x, y, label='True Data')
plt.plot(x, predictions.numpy(), color='red', label='Predictions')
plt.legend()
plt.show()

输出结果，很明显，只有 2 层的情况下，CNN 只学习到x和 y 的一部分非线性关系。

Epoch [200/2000], Loss: 0.1304
Epoch [400/2000], Loss: 0.0929
Epoch [600/2000], Loss: 0.0745
Epoch [800/2000], Loss: 0.0720
Epoch [1000/2000], Loss: 0.0718
Epoch [1200/2000], Loss: 0.0713
Epoch [1400/2000], Loss: 0.0708
Epoch [1600/2000], Loss: 0.0707
Epoch [1800/2000], Loss: 0.0706
Epoch [2000/2000], Loss: 0.0706

浅层网络（2层）损失：0.0706 → 拟合不足
深层网络（4层）损失：0.0002 → 近乎完美拟合

为什么CNN需要多层卷积？
浅层学习局部特征（边缘、纹理）
深层学习全局语义（物体部件、整体结构）