基于CNN的XO识别

一、用自己的语言解释以下概念

1、局部感知、权值共享

局部感知：卷积神经网络中的每个神经元只关注输入数据的一小部分，即“局部感受野”。卷积神经网络中，每个卷积层都有多个卷积核，每个卷积核又都可以絮叨一种特定特征。每个卷积核在输入数据上滑动以进行卷积运算，从而提取输入数据中的局部特征。局部感知的方式使网络可以专注于局部特征而非全局信息，大大减少了模型需要学习的参数数量，降低了模型的复杂性。

权值共享：在传统的神经网络中，每个神经元都有自己独特的权重。但在卷积神经网络中，同一层中的每个卷积核都使用相同的权重，这种策略称为权值共享。这意味着整个网络中，同一个特征被重复学习了多次，每次都在不同的局部感受野中进行。权值共享让网络能够更有效地利用数据，降低了模型的参数数量，增强了模型的泛化能力。

2、池化（子采样、降采样、汇聚）。会带来哪些好处和坏处？

池化是一种降采样技术，也被称为子采样、降采样或汇聚。池化通常在卷积之后进行，它通过对卷积层的输出进行下采样，以减少下一层的输入大小，从而降低模型的计算复杂度。

好处：减少参数数量、提高泛化能力（池化可以有效地减少过拟合现象）、降低模型对噪声的敏感性

坏处：信息丢失（作为下采样技术，它会丢失一部分信息，从而可能导致模型的性能下降）、无法恢复原始输入（池化是不可逆的操作，因此无法从池化后的特征图恢复原始的输入图像）、可能引入平滑效应（池化操作可能导致相邻像素之间的信息丢失，使得模型在处理边缘信息时出现困难）

3、全卷积网络（课上讲的这个概念不准确，同学们查资料纠正一下）

全卷积网络（FCN）将传统CNN后面的全连接层换成了卷积层，由此网络的输出将是热力图而非类别；同时为解决卷积和池化导致的图像尺寸变小，它使用了上采样方式对图像尺寸进行恢复。FCN组成：全卷积部分（经典CNN网络）+反卷积部分（上采样）

特点：1.不含全连接层的全卷积网络，可适应任意尺寸输入。传统CNN输入数据时图象时，通常是高、长、通道方向上的3维形状，但在向全连接层输入时，需要将数据拉平为一维数据，正因全连接层会忽视形状，所以无法利用与形状相关的信息。而卷积层可以保持形状不变，当输入数据是图象时，卷积层会以3维数据的形式接收输入数据，并同样以3维数据的形式输出至下一层。

2.反卷积层增大图像尺寸，输出精细结果。采用反卷积层对最后一个卷积层的feature map进行上采样, 使它恢复到输入图像相同的尺寸，从而可以对每个像素都产生了一个预测, 同时保留了原始输入图像中的空间信息, 最后在上采样的特征图上进行逐像素分类。

最后逐个像素计算softmax分类的损失, 相当于每一个像素对应一个训练样本。下图是Longjon用于语义分割所采用的全卷积网络(FCN)的结构示意图：

3.结合不同深度层结果的跳级结构，确保鲁棒性和精确性。

4、低级特征、中级特征、高级特征

低级特征通常指的是图像的基本元素，例如边缘、角点等。这些特征通常由图像处理算法提取，用于描述图像的基本属性。低级特征的优点是计算效率高，可以在短时间内处理大量图像数据。但是，低级特征缺乏对图像整体结构和语义信息的考虑，因此难以在复杂场景中取得良好的表现。

中级特征则是在低级特征的基础上，通过组合和融合，形成更加复杂的特征表达。这些特征通常包括局部区域内的纹理、颜色、形状等特征，可以更好地描述图像的局部信息。中级特征的优点是可以提供更丰富的信息，适用于更多的场景和任务。但是，中级特征的计算复杂度相对较高，需要更多的计算资源和时间。

高级特征则是指通过对图像的整体结构和语义信息的分析和理解，提取出的具有更高层次特征的表达。这些特征通常包括图像的主题、概念、场景等，可以更好地描述图像的整体信息和语义含义。高级特征的优点是可以提供更准确的图像理解和分类能力，适用于复杂的图像分类和识别任务。但是，高级特征的计算复杂度最高，需要更多的计算资源和时间。

 5、多通道。N输入，M输出是如何实现的？

多通道输入意味着输入数据包含多个通道的信息。例如，在处理彩色图像时会使用RGB三个通道的数据，而灰度就只有一个通道。

在CNN中，多通道输入通过将多个卷积核应用到输入数据的不同通道上来实现。每个卷积核都从输入数据的一个特定通道中提取出一种特征。通过这种方式，我们可以同时从输入数据中提取出多种特征。

N输入和M输出是指CNN中有N个输入通道和M个输出通道。N输入通道接收来自不同源的数据，例如彩色图像的三个通道（R、G、B）。M输出通道则将CNN的输出传递给下一层或输出层。

多通道输出的实现方式与多通道输入类似。在CNN中，我们通常是使用多个卷积核来生成输出层的多个通道。每个卷积核都会根据输入数据的特征生成一个特定的输出通道。

6、1×1的卷积核有什么作用

1×1的卷积大概有两个方面的作用吧：1、实现跨通道的交互和信息整合；2、进行卷积核通道数的降维和升维

以GoogLeNet的3a模块为例，输入的feature map是28×28×192，3a模块中1×1卷积通道为64，3×3卷积通道为128,5×5卷积通道为32，如果是左图结构，那么卷积核参数为1×1×192×64+3×3×192×128+5×5×192×32，而右图对3×3和5×5卷积层前分别加入了通道数为96和16的1×1卷积层，这样卷积核参数就变成了1×1×192×64+（1×1×192×96+3×3×96×128）+（1×1×192×16+5×5×16×32），参数大约减少到原来的三分之一。

同时在并行pooling层后面加入1×1卷积层后也可以降低输出的feature map数量，左图pooling后feature map是不变的，再加卷积层得到的feature map，会使输出的feature map扩大到416，如果每个模块都这样，网络的输出会越来越大。而右图在pooling后面加了通道为32的1×1卷积，使得输出的feature map数降到了256。GoogLeNet利用1×1的卷积降维后，得到了更为紧凑的网络结构，虽然总共有22层，但是参数数量却只是8层的AlexNet的十二分之一。

二、使用CNN进行XO识别

1.复现参考资料中的代码

（1）数据集

文件夹train_data：放置训练集1700张图片，为850张X和850张O

文件夹test_data:放置测试集300张图片，为150张X和150张O

（2）模型构建：

class Net(nn.Module):  # 卷积神经网络的整个过程，卷积神经网络函数
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 9, 3)  # in_channel , out_channel , kennel_size , stride
        self.maxpool = nn.MaxPool2d(2, 2)  # kernel_size,stride
        self.conv2 = nn.Conv2d(9, 5, 3)  # in_channel , out_channel , kennel_size , stride

        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(27 * 27 * 5, 1200)  # full connect 1
        self.fc2 = nn.Linear(1200, 64)  # full connect 2
        self.fc3 = nn.Linear(64, 2)  # full connect 3

    def forward(self, x):  # 进行最大池化和前馈神经网络的部分
        x = self.maxpool(self.relu(self.conv1(x)))
        x = self.maxpool(self.relu(self.conv2(x)))
        x = x.view(-1, 27 * 27 * 5)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

（3）模型训练

model = Net()

criterion = torch.nn.CrossEntropyLoss()  # 损失函数 交叉熵损失函数
optimizer = optim.SGD(model.parameters(), lr=0.1)  # 优化函数：随机梯度下降

epochs = 10
for epoch in range(epochs):
    running_loss = 0.0
    for i, data in enumerate(data_loader):
        images, label = data  # 从数据加载器获取图像和标签数据
        out = model(images)
        loss = criterion(out, label)  # 计算出损失

        optimizer.zero_grad()  # 清空梯度缓存
        loss.backward()  # 调用backward()函数实现反向传播
        optimizer.step()  # 更新模型参数

        running_loss += loss.item()
        if (i + 1) % 10 == 0:  # 每10次训练进行一次输出
            print('[%d  %5d]   loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0  # 为计算下一轮10个batch的平均损失做准备

print('finished train')

# 保存模型 torch.save(model.state_dict(), model_path)
torch.save(model.state_dict(), 'model_name1.pth')  # 保存的是模型， 不止是w和b权重值

# 读取模型
model = torch.load('model_name1.pth')

（4）模型测试

import matplotlib.pyplot as plt
 
# 读取模型
model_load = torch.load('model.pth')
# 读取一张图片 images[0]，测试
print("labels[0] truth:\t", labels[0])
x = images[0].unsqueeze(0)
predicted = torch.max(model_load(x), 1)
print("labels[0] predict:\t", predicted.indices)
 
img = images[0].data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.show()

（5）计算模型准确率

# 读取模型
model_load = torch.load('model.pth')
 
correct = 0
total = 0
with torch.no_grad():  # 进行评测的时候网络不更新梯度
    for data in test_loader:  # 读取测试集
        images, labels = data
        outputs = model_load(images)
        _, predicted = torch.max(outputs.data, 1)  # 取出 最大值的索引 作为 分类结果
        total += labels.size(0)  # labels 的长度
        correct += (predicted == labels).sum().item()  # 预测正确的数目
print('Accuracy of the network on the  test images: %f %%' % (100. * correct / total))

 

2.重新设计网络结构

• 至少增加一个卷积层，卷积层达到三层以上
• 去掉池化层，对比“有无池化”的效果
• 修改“通道数”等超参数，观察变化

（1）增加一个卷积层，卷积层达到三层以上

class Net(nn.Module):  # 卷积神经网络的整个过程，卷积神经网络函数
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 9, 3)  # in_channel , out_channel , kennel_size , stride
        self.maxpool = nn.MaxPool2d(2, 2)  # kernel_size,stride
        self.conv2 = nn.Conv2d(9, 5, 3)  # in_channel , out_channel , kennel_size , stride
        self.conv3 = nn.Conv2d(5, 5, 3)

        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(12 * 12 * 5, 480)  # full connect 1
        self.fc2 = nn.Linear(480, 320)  # full connect 2
        self.fc3 = nn.Linear(320, 2)  # full connect 3

    def forward(self, x):  # 进行最大池化和前馈神经网络的部分
        x = self.maxpool(self.relu(self.conv1(x)))
        x = self.maxpool(self.relu(self.conv2(x)))
        x = self.maxpool(self.relu(self.conv3(x)))
        x = x.view(-1, 12 * 12 * 5)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

 

误差增大，准确率下降

（2）去掉池化层，对比“有无池化”的效果

class CNN(nn.Module):  # 卷积神经网络的整个过程，卷积神经网络函数
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 9, 3)
        self.conv2 = nn.Conv2d(9, 5, 3)

        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(12 * 12 * 5, 480)  # full connect 1
        self.fc2 = nn.Linear(480, 320)  # full connect 2
        self.fc3 = nn.Linear(320, 2)  # full connect 3

    def forward(self, x):  # 进行最大池化和前馈神经网络的部分
        x = self.relu(self.conv1(x))
        x = self.relu(self.conv2(x))
        x = x.view(-1, 12 * 12 * 5)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

训练速度明显变慢，准确率下降

（3）修改“通道数”等参数，观察变化

通道数改为15：

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 15, 3)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(15, 5, 3)
        self.relu = nn.ReLU()

        self.fc1 = nn.Linear(27 * 27 * 5, 1200)
        self.fc2 = nn.Linear(1200, 64)
        self.fc3 = nn.Linear(64, 2)

    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = x.view(-1, 27 * 27 * 5)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

3.可视化

• 选择自己的最优模型
• 可视化部分卷积核和特征图
• 探索低级特征、中级特征、高级特征 

 (1）查看训练好的模型特征图

import torch.optim
from torch.utils.data import DataLoader
from torchvision import transforms, datasets
 
transforms = transforms.Compose([
    transforms.ToTensor(),  # 把图片进行归一化，并把数据转换成Tensor类型
    transforms.Grayscale(1)  # 把图片 转为灰度图
])
 
data_train = datasets.ImageFolder('train_data', transforms)
data_test = datasets.ImageFolder('test_data', transforms)
 
train_loader = DataLoader(data_train, batch_size=64, shuffle=True)
test_loader = DataLoader(data_test, batch_size=64, shuffle=True)
for i, data in enumerate(train_loader):
    images, labels = data
    print(images.shape)
    print(labels.shape)
    break
 
for i, data in enumerate(test_loader):
    images, labels = data
    print(images.shape)
    print(labels.shape)
    break
 
import torch.nn as nn
 
 
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 9, 3)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(9, 5, 3)
        self.relu = nn.ReLU()
 
        self.fc1 = nn.Linear(27 * 27 * 5, 1200)
        self.fc2 = nn.Linear(1200, 64)
        self.fc3 = nn.Linear(64, 2)
 
    def forward(self, x):
        outputs = []
        x = self.conv1(x)
        outputs.append(x)
        x = self.relu(x)
        outputs.append(x)
        x = self.pool(x)
        outputs.append(x)
        x = self.conv2(x)
 
        x = self.relu(x)
 
        x = self.pool(x)
 
        x = x.view(-1, 27 * 27 * 5)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return outputs
 
 
 
 
 
import matplotlib.pyplot as plt
import numpy as np
# 读取模型
model = torch.load('model.pth')
print(model)
x = images[0].unsqueeze(0)
 
# forward正向传播过程
out_put = model(x)
for feature_map in out_put:
    # [N, C, H, W] -> [C, H, W]    维度变换
    im = np.squeeze(feature_map.detach().numpy())
    print(im.shape)
    # [C, H, W] -> [H, W, C]
    im = np.transpose(im, [1, 2, 0])
    print(im.shape)
 
    # show 9 feature maps
    plt.figure()
    for i in range(9):
        ax = plt.subplot(3, 3, i + 1)  # 参数意义：3：图片绘制行数，5：绘制图片列数，i+1：图的索引
        # [H, W, C]
        # 特征矩阵每一个channel对应的是一个二维的特征矩阵，就像灰度图像一样，channel=1
        # plt.imshow(im[:, :, i])
        plt.imshow(im[:, :, i], cmap='gray')
    plt.show()
 

 

三个图分别是高级特征，中级特征和低级特征

（2）查看训练好的模型卷积核

import matplotlib.pyplot as plt
 
# 读取模型
model = torch.load('model.pth')
print(model)
x = images[0].unsqueeze(0)
 
# forward正向传播过程
out_put = model(x)
weights_keys = model.state_dict().keys()
for key in weights_keys:
    print("key :", key)
    # 卷积核通道排列顺序 [kernel_number, kernel_channel, kernel_height, kernel_width]
    if key == "conv1.weight":
        weight_t = model.state_dict()[key].numpy()
        print("weight_t.shape", weight_t.shape)
        k = weight_t[:, 0, :, :]  # 获取第一个卷积核的信息参数
        # show 9 kernel ,1 channel
        plt.figure()
 
        for i in range(9):
            ax = plt.subplot(3, 3, i + 1)  # 参数意义：3：图片绘制行数，5：绘制图片列数，i+1：图的索引
            plt.imshow(k[i, :, :], cmap='gray')
            title_name = 'kernel' + str(i) + ',channel1'
            plt.title(title_name)
        plt.show()
 
    if key == "conv2.weight":
        weight_t = model.state_dict()[key].numpy()
        print("weight_t.shape", weight_t.shape)
        k = weight_t[:, :, :, :]  # 获取第一个卷积核的信息参数
        print(k.shape)
        print(k)
 
        plt.figure()
        for c in range(9):
            channel = k[:, c, :, :]
            for i in range(5):
                ax = plt.subplot(2, 3, i + 1)  # 参数意义：3：图片绘制行数，5：绘制图片列数，i+1：图的索引
                plt.imshow(channel[i, :, :], cmap='gray')
                title_name = 'kernel' + str(i) + ',channel' + str(c)
                plt.title(title_name)
            plt.show()

第一个特征图有九个输出，对应着第一层卷积层的输出是9

后面的特征图是五个输出，对应着第二层卷积层输出是5，一共九组，对应着第二层的输入是9，这里的9又与第一层卷积层相对应

参考：

全卷积网络 FCN 详解 - 代码学习者coding - 博客园 (cnblogs.com)

1*1卷积核的理解和作用 - 西野果子 - 博客园 (cnblogs.com)

【精选】NNDL 作业6：基于CNN的XO识别-CSDN博客

深度学习作业7-CSDN博客

【2021-2022 春学期】人工智能-作业6：CNN实现XO识别_x = self.conv2(x)#请问经过conv2(x)之后,x的维度是多少-CSDN博客