卷积神经网络CNN

多通道卷积计算

如下图所示:

当使用多个卷积核时 , 应该怎么进行特征提取呢 ?

特征图大小

输出特征图的大小与以下参数息息相关 :

1. size: 卷积核/过滤器大小，一般会选择为奇数，比如有 1*1 、3*3、5*5 
2. Padding: 零填充的方式
3. Stride: 步长

那计算方法如下图所示 :

1. 输入图像大小: W x W
2. 卷积核大小: F x F
3. Stride: S
4. Padding: P
5. 输出图像大小: N x N

特征图大小计算方法

# 3.训练模型
def train(model,train_dataset):
     criterion = nn.CrossEntropyLoss() # 构建损失函数
     optimizer = optim.Adam(model.parameters(), lr=1e-3) # 构建优化方法
     epoch = 100 # 训练轮数
     for epoch_idx in range(epoch):
         # 构建数据加载器
         dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
         sam_num = 0 # 样本数量
         total_loss = 0.0 # 损失总和
         start = time.time() # 开始时间
            # 遍历数据进行网络训练
         for x, y in dataloader:
             output = model(x)
             loss = criterion(output, y) # 计算损失
             optimizer.zero_grad() # 梯度清零
             loss.backward() # 反向传播
             optimizer.step() # 参数更新
             total_loss += loss.item() # 统计损失和
             sam_num += 1
         print('epoch:%2s loss:%.5f time:%.2fs' %(epoch_idx + 1,total_loss / sam_num,time.time() - start))
     # 模型保存
     torch.save(model.state_dict(), 'data/image_classification.pth')

def test(valid_dataset):
 # 构建数据加载器
 dataloader = DataLoader(valid_dataset, batch_size=BATCH_SIZE, shuffle=True)
 # 加载模型并加载训练好的权重
 model = ImageClassification()
 model.load_state_dict(torch.load('data/image_classification.pth'))
 model.eval()
 # 计算精度
 total_correct = 0
 total_samples = 0
 # 遍历每个batch的数据，获取预测结果，计算精度
 for x, y in dataloader:
    output = model(x)
    total_correct += (torch.argmax(output, dim=-1) == y).sum()
    total_samples += len(y)
 # 打印精度
 print('Acc: %.2f' % (total_correct / total_samples))

总体代码

import torch
import torch.nn as nn
from torchvision.datasets import CIFAR10
from torchvision.transforms import ToTensor
from torchvision.transforms import Compose
import torch.optim as optim
from torch.utils.data import DataLoader
import time
import matplotlib.pyplot as plt
from torchsummary import summary
BATCH_SIZE = 8

# 1. 数据集基本信息
def create_dataset():
    # 加载数据集:训练集数据和测试数据
    train = CIFAR10(root='data', train=True, transform=Compose([ToTensor()]), download=True)
    valid = CIFAR10(root='data', train=False, transform=Compose([ToTensor()]), download=True)
    # 返回数据集结果
    return train, valid
# if __name__ == '__main__':
#     # 数据集加载
#     train_dataset, valid_dataset = create_dataset()
#     # 数据集类别
#     print("数据集类别:", train_dataset.class_to_idx)
#     # 数据集中的图像数据
#     print("训练集数据集:", train_dataset.data.shape)
#     print("测试集数据集:", valid_dataset.data.shape)
#     # 图像展示
#     plt.figure(figsize=(2, 2))
#     plt.imshow(train_dataset.data[1])
#     plt.title(train_dataset.targets[1])
#     plt.show()

# 2.模型构建
class ImageClassification(nn.Module):
    # 定义网络结构
    def __init__(self):
        super(ImageClassification, self).__init__()
        # 定义网络层：卷积层+池化层
        self.conv1 = nn.Conv2d(3, 6, stride=1, kernel_size=3)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(6, 16, stride=1, kernel_size=3)
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        # 全连接层
        self.linear1 = nn.Linear(576, 120)
        self.linear2 = nn.Linear(120, 84)
        self.out = nn.Linear(84, 10)

    # 定义前向传播
    def forward(self, x):
        # 卷积+relu+池化
        x = torch.relu(self.conv1(x))
        x = self.pool1(x)
        # 卷积+relu+池化
        x = torch.relu(self.conv2(x))
        x = self.pool2(x)
        # 将特征图做成以为向量的形式：相当于特征向量
        x = x.reshape(x.size(0), -1)
        # 全连接层
        x = torch.relu(self.linear1(x))
        x = torch.relu(self.linear2(x))
        # 返回输出结果
        return self.out(x)



# 3.训练模型
def train(model,train_dataset):
     criterion = nn.CrossEntropyLoss() # 构建损失函数
     optimizer = optim.Adam(model.parameters(), lr=1e-3) # 构建优化方法
     epoch = 100 # 训练轮数
     for epoch_idx in range(epoch):
         # 构建数据加载器
         dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
         sam_num = 0 # 样本数量
         total_loss = 0.0 # 损失总和
         start = time.time() # 开始时间
            # 遍历数据进行网络训练
         for x, y in dataloader:
             output = model(x)
             loss = criterion(output, y) # 计算损失
             optimizer.zero_grad() # 梯度清零
             loss.backward() # 反向传播
             optimizer.step() # 参数更新
             total_loss += loss.item() # 统计损失和
             sam_num += 1
         print('epoch:%2s loss:%.5f time:%.2fs' %(epoch_idx + 1,total_loss / sam_num,time.time() - start))
     # 模型保存
     torch.save(model.state_dict(), 'data/image_classification.pth')



# 4.预测模型
def test(valid_dataset):
     # 构建数据加载器
     dataloader = DataLoader(valid_dataset, batch_size=BATCH_SIZE, shuffle=True)
     # 加载模型并加载训练好的权重
     model = ImageClassification()
     model.load_state_dict(torch.load('data/image_classification.pth'))
     model.eval()
     # 计算精度
     total_correct = 0
     total_samples = 0
     # 遍历每个batch的数据，获取预测结果，计算精度
     for x, y in dataloader:
        output = model(x)
        total_correct += (torch.argmax(output, dim=-1) == y).sum()
        total_samples += len(y)
     # 打印精度
     print('Acc: %.2f' % (total_correct / total_samples))

if __name__ == '__main__':
    #1.数据集加载
    train_dataset, valid_dataset = create_dataset()
    #2.模型实例化
    model = ImageClassification()
    #3.模型训练
    train(model, train_dataset)
    #4.预测模型
    test(valid_dataset)