[学肥 AI]CNN的理解

江南西肥肥

已于 2024-07-26 15:57:53 修改

阅读量744

点赞数 12

分类专栏：学肥 AI 深度学习文章标签：人工智能 cnn 深度学习

于 2024-07-26 15:48:05 首次发布

本文链接：https://blog.csdn.net/weixin_49113487/article/details/140717493

版权

学肥 AI 同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

深度学习

1 篇文章 0 订阅

订阅专栏

背景问题

有时候，我们会使用深度神经网络来学习数据。如果效果不理想，常常都会 加深和加宽全连接层 来让效果更加的完善。但是加深加宽网络会引来更加多的问题，比如梯度消失/梯度爆炸等。
特别是面对图像识别问题的时候，比如手写数字识别，一幅图片本来就有大量的信息，width/height/3 color channels 等，加深加宽网络下的模型，结果往往未如理想。
CNN 就是为了解决上述的问题的。CNN 即是 Convolution Neural Network，卷积神经网络。

先讲解不同的子组件，再组合起来，形成手写的模型，这样就更加容易的去理解模型。

卷积和卷积核

卷积
卷积，是 来源矩阵 和 卷积核矩阵 一个个对应位置进行相乘后，再相加的运算。

# 对 【中心点】进行卷积运算
# 来源举证
input_array = np.array([[1, 2, 3],
                        [4, 5, 6],
                        [7, 8, 9]])
# 卷积核
kernel_array = np.array([[1, 0, 0],
                         [0, 1, 0],
                         [0, 0, 1]])
# 卷积操作
# 1*1+2*0+3*0+4*0+5*1+6*0+7*0+8*0+9*1 = 15

# 对应卷积后
Output:
[[15]]

如果加上 padding 和 stride 的话，即卷积核就可以沿着 来源矩阵 滑动，完成整个卷积操作。

# padding = 1 ，stride = 1
# 来源矩阵
input_array = np.array([[1, 2, 3],
                        [4, 5, 6],
                        [7, 8, 9]])
# 卷积核
kernel_array = np.array([[1, 0, 0],
                         [0, 1, 0],
                         [0, 0, 1]])

# 对应卷积后
Output:
[[ 6  8  3]
 [12 15  8]
 [ 7 12 14]]

卷积核 kernel's size,padding , stride 与输入矩阵 input 和输出矩阵 output 大小的对应关系：

如果是 3*3 的卷积核，padding=1 stride=1，输入和输出的矩阵大小一致。

卷积核
上例中，卷积核，就是 kernel_array，[[1, 0, 0],[0, 1, 0],[0, 0, 1]]，他是 3X3 的卷积核。

从网站知道，不同的卷积核应用到相同的图片上，可以得到不同的结果。比如有一些是可以提取边缘特征，有些是可以模糊的。

💊 卷积核，就是提取特征的矩阵。有多少个卷积核，就是代表提取多少个特征。不同的卷积核可以提取不同的特征。

下面的代码，就是使用预设的卷积核（提取边缘轮廓特征的卷积核）去获取特征，我们可以看到直接输出的结果。

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

# Create a sample input image (1, 1, 5, 5)
input_image = torch.tensor([[[[1, 2, 3, 0, 1],
                              [0, 1, 2, 3, 1],
                              [3, 0, 1, 2, 0],
                              [1, 2, 3, 0, 1],
                              [0, 1, 2, 3, 0]]]], dtype=torch.float32)

# Define a convolutional layer
conv_layer = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=3, stride=1, padding=1)

# Initialize the kernel weights for demonstration purposes (e.g., edge detection kernel)
edge_detection_kernel = torch.tensor([[[[-1, -1, -1],
                                        [-1,  8, -1],
                                        [-1, -1, -1]]]], dtype=torch.float32)
conv_layer.weight = torch.nn.Parameter(edge_detection_kernel)
conv_layer.bias = torch.nn.Parameter(torch.zeros(1))

# Apply the convolutional layer to the input image
output_image = conv_layer(input_image)

# Convert the output to a NumPy array for visualization
output_image_np = output_image.detach().numpy().squeeze()

# Visualize the input and output images
def visualize_images(input_img, output_img):
    fig, axes = plt.subplots(1, 2, figsize=(10, 5))
    axes[0].imshow(input_img.squeeze(), cmap='gray')
    axes[0].set_title('Input Image')
    axes[0].axis('off')
    
    axes[1].imshow(output_img, cmap='gray')
    axes[1].set_title('Output Image')
    axes[1].axis('off')
    
    plt.show()

# Display the images
visualize_images(input_image, output_image_np)

# Print the input and output values for comparison
print("Input Image:\n", input_image.squeeze().numpy())
print("\nOutput Image:\n", output_image_np)

Input Image:
 [[1. 2. 3. 0. 1.]
 [0. 1. 2. 3. 1.]
 [3. 0. 1. 2. 0.]
 [1. 2. 3. 0. 1.]
 [0. 1. 2. 3. 0.]]

Output Image:
 [[  5.   9.  16. -10.   4.]
 [ -7.  -4.   4.  14.   2.]
 [ 20. -13.  -5.   5.  -7.]
 [  2.   5.  13. -12.   3.]
 [ -4.   0.   7.  18.  -4.]]

从结果知道（从灰度图看不出问题，但是从数字矩阵可以看出），这个卷积核令到黑的更加的黑，白的更加的白，突出了特征。

卷积的好处

共享参数

卷积核，就是滑过数据的共享参数，那么他能够提取对应的特征数据。所以一个卷积核对应着一个特征。需要提取的特征，不论是在图片的哪个位置，都可以提取出来。

参数减少

比如 100 * 100 的图像，要去识别苹果，但是这个苹果有可能出现在上下左右，随机的位置。
如果使用 NN 神经网络就要使用 (100 * 100, n, n) 网络，网络的输入是每个坐标像素。但是苹果的出现的位置是随机的，即坐标是随机的，所以对应的神经元也是需要学习，导致非常难收敛。同时，参数量就是巨大的，达到 10000 * n * n。
但是使用 CNN，可以针对苹果轮廓训练对应卷积核，达到识别的效果，就大大减少参数量。参数量就是卷积核上的数值和后续的高维度的全链接网络的参数。

位置信息的共享

如果上例子中，苹果轮廓信息是共享的。

池化

有平均池化和最大值池化，他 没有参数学习，完全是按照默认的逻辑去运行的。

平均池化，取平均值，会模糊特征，他可以考虑到所有像素的关系；
最大值池化，取最大值，就突出了特征了，完全是忽视了最小值。

Input_array:
[[ 1.  2.  3.  4.]
 [ 5.  6.  7.  8.]
 [ 9. 10. 11. 12.]
 [13. 14. 15. 16.]]

应用 kernel_size=2, stride=2 的 池化

Average Pooled Image:
 [[ 3.5  5.5]
 [11.5 13.5]]

Max Pooled Image:
 [[ 6.  8.]
 [14. 16.]]

从结果知道，如果池化后，计算量是加上了 3/4，同时可以保留原来图像的特征。

池化好处
就是为了减少运算量，而且没有参数，不用学习。换一句话，有很多的数据是没有意义的，计算他们投入产出比太低，不如直接放弃。

手写简单 CNN 网络

组装卷积和 _池化 _的一个网络，就是一个简单的 CNN 网络，比如以下的代码就是一个简单的卷积和池化操作相结合。

# 部分代码的演示
# conv 定义卷积
conv = .Conv2d(1, 32, kernel_size=3, padding=1
# pool 定义池化
pool = nn.MaxPool2d(kernel_size=2, stride=2)

# 结合激活函数
x = pool(relu(conv(x)))

所有模型（包括 NN，CNN，AlexNet，ResNet，RNN 等），都是一个个的子组件的组装，就好像积木一样。所以理解好不同的子组件的原理和用法，就更加容易理解由他们组装而成的大模型。

完整代码检测手写数字的图片

导入手写数字的图片库，同时使用一个简单的 CNN 来训练

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import torch.nn.functional as F

# Define the CNN model
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 64)
        self.fc2 = nn.Linear(64, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Load and preprocess the MNIST dataset
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

trainset = torchvision.datasets.MNIST(root='../data/mnist', train=True, download=True, transform=transform)
trainloader = DataLoader(trainset, batch_size=64, shuffle=True)

testset = torchvision.datasets.MNIST(root='../data/mnist', train=False, download=True, transform=transform)
testloader = DataLoader(testset, batch_size=64, shuffle=False)

# Instantiate the model, define the loss function and the optimizer
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# Training loop
num_epochs = 5
for epoch in range(num_epochs):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        
        optimizer.zero_grad()
        
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
        if i % 100 == 99:
            print(f'[Epoch {epoch + 1}, Batch {i + 1}] loss: {running_loss / 100:.3f}')
            running_loss = 0.0

print('Finished Training')

# Test the model
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the network on the 10000 test images: {100 * correct / total:.2f}%')

'''
# 部分打印
[Epoch 5, Batch 600] loss: 0.075
[Epoch 5, Batch 700] loss: 0.093
[Epoch 5, Batch 800] loss: 0.074
[Epoch 5, Batch 900] loss: 0.081
Finished Training
Accuracy of the network on the 10000 test images: 98.08%
'''

模型训练的结果是另人满意的。

说明

上面的例子，已经说明了 CNN 的整体的框架。

结构图

面对分类任务，主体上分成两层： Feature Extraction 特征提取和 Classification 分类
Feature Extraction： input 就是输入的数据，Convolution 就是卷积，Pooling 就是池化，到这步为止，就是从低维度特征的提取。
Classification：之后对提取后的特征进行高维全网络学习和 softmax 进行分类。