深度学习之卷积神经网络框架模型搭建

卷积神经网络框架模型搭建

1 卷积神经网络模型

---

1.1 卷积神经网络

卷积神经网络（Convolutional Neural Network，CNN）是一种专门用于处理具有网格结构数据（如图像、视频）的深度学习模型卷积神经网络通过卷积层、池化层和全连接层的组合，能够高效地提取图像特征，并在计算机视觉任务中表现出色。

1.2 卷积层（Convolutional Layer）

卷积操作是 CNN 的核心，通过卷积核（Filter）提取局部特征，卷积核是一个小的权重矩阵，在输入数据上滑动并计算点积，每个卷积核会生成一个输出通道，多个卷积核可以提取多种特征。。

1.2.1 输出特征图

输出特征图尺寸由输入尺寸（h，w）、卷积核尺寸(k,k)、步长(s)、填充§决定：
输出长度：H1 = (h - k + 2p) / s + 1
输出宽度：W1 = (w - k + 2p) / s + 1
其中当k,s,p为512时输出的特征图尺寸与原图相同

1.3 激活函数

在卷积操作后，通常会使用激活函数引入非线性，进行非线性映射。
常用的激活函数包括：
ReLU：f(x) = max(0, x)
Sigmoid：f(x) = 1 / (1 + e^(-x))

1.4 池化层（Pooling Layer）

池化操作用于降采样，减少特征图的尺寸，减小数据的空间大小，因此参数的数量和计算量也会下降，这在一定程度上也控制了过拟合，同时保留重要信息，池化层通常不引入额外的参数。

• 常用的池化方法包括：
  • 最大池化（Max Pooling）：取局部区域的最大值。
  • 平均池化（Average Pooling）：取局部区域的平均值。

1.5 全连接层（Fully Connected Layer）

在卷积和池化操作后，特征图会被展平并输入到全连接层，全连接层用于将提取的特征映射到最终的输出（如分类结果）,
卷积和池化操作可以多次操作。

2 框架模型搭建

---

2.1 框架确定

包含 3 个卷积块和 1 个全连接层，用于 MNIST 手写数字分类任务。卷积块包括卷积、激活以及池化操作。
卷积块1：卷积、激活、池化
卷积块2：卷积、激活、卷积、激活、池化
卷积块3：卷积、激活

2.2 框架函数定义

• 卷积块：nn.Sequential(),括号内可以进行卷积、激活以及池化操作。
• 卷积：nn.Conv2d(in_channels=1,out_channels=16,kernel_size=5,stride=1,padding=2)
  • in_channels=1,输入通道数灰度图像为 1，rgb为3
  • out_channels=16,输出通道数
  • kernel_size=5,卷积核大小（5x5）
  • stride=1,步幅
  • padding=2 ，边缘填充数，为 2，保证输出尺寸与输入尺寸相同
• 激活函数：nn.ReLU()，ReLU 激活函数
• 池化：nn.MaxPool2d(kernel_size=2), 最大池化层
  • kernel_size=2，池化核大小为 2x2
• 全连接：nn.Linear(64 * 7 * 7, 10)，（输入个数，输出个数）
• 展平操作： x.view(x.size(0), -1)，将特征图展平，为一维向量
  • x.size(0)：批次大小。
  • -1：自动计算展平后的维度。

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1,
                out_channels=16,
                kernel_size=5,
                stride=1,
                padding=2,
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16,32,5,1,2),
            nn.ReLU(),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.conv3 = nn.Sequential(
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.ReLU(),
        )
        self.out = nn.Linear(64*7*7,10)

    def forward(self,x):
        x =self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        x = x.view(x.size(0),-1)
        output = self.out(x)
        return output

3 代码测试

代码展示：

import torch

print(torch.__version__)
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

train_data = datasets.MNIST(
    root = 'data',
    train = True,
    download = True,
    transform = ToTensor()
)
test_data = datasets.MNIST(
    root = 'data',
    train = False,
    download = True,
    transform = ToTensor()
)
print(len(train_data))
print(len(test_data))

train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader= DataLoader(test_data, batch_size=64)
device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'
print(f'Using {device} device')

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1,
                out_channels=16,
                kernel_size=5,
                stride=1,
                padding=2,
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16,32,5,1,2),
            nn.ReLU(),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.conv3 = nn.Sequential(
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.ReLU(),
        )
        self.out = nn.Linear(64*7*7,10)

    def forward(self,x):
        x =self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        x = x.view(x.size(0),-1)
        output = self.out(x)
        return output

model = CNN().to(device)
print(model)
optimizer = torch.optim.Adam(model.parameters(),lr=0.001)
loss_fn = nn.CrossEntropyLoss()
def train(dataloader,model,loss_fn,optimizer):
    model.train()
    batch_size_num = 1
    for x,y in dataloader:
        x,y = x.to(device),y.to(device)
        pred = model.forward(x)
        loss = loss_fn(pred,y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        loss_value = loss.item()
        if batch_size_num %100 ==0:
            print(f'loss: {loss_value:>7f}  [number: {batch_size_num}]')
        batch_size_num +=1

def test(dataloader,model,loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss,correct = 0,0
    with torch.no_grad():
        for x,y in dataloader:
            x,y = x.to(device),y.to(device)
            pred = model.forward(x)
            test_loss += loss_fn(pred,y).item()
            correct +=(pred.argmax(1) == y).type(torch.float).sum().item()
            a = (pred.argmax(1)==y)
            b = (pred.argmax(1)==y).type(torch.float)
    test_loss /=num_batches
    correct /= size
    print(f'test result: \n Accuracy: {(100*correct)}%, Avg loss:{test_loss}')
e = 8
for i in range(e):
    print(f'e: {i+1}\n------------------')
    train(train_dataloader, model, loss_fn, optimizer)
print('done')

test(test_dataloader, model, loss_fn)

运行结果：