卷积神经网络-学习笔记

Ol1ver0413

于 2024-06-23 01:21:44 发布

阅读量301

点赞数 8

文章标签： cnn 学习笔记

本文链接：https://blog.csdn.net/OliverFunction/article/details/139890985

版权

引言：

卷积神经网络（Convolutional Neural Network, CNN）是一种深度学习模型，广泛应用于图像和视频处理、自然语言处理等领域。CNN通过卷积层和池化层有效地提取和学习数据的特征，能够自动捕捉空间层次结构，使其在图像识别和分类任务中表现优异。

本篇博客是对唐宇迪ai的学习笔记。

环境介绍：

cuda 12.3

python 3.9.2

pytorch 2.3.1 stable

1. 导入各类库函数和包

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torchvision import datasets,transforms 
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

#nn.functional包含了各类深度学习的函数，包括Conv和relu等
#dataset提供了一系列的内置数据集和对数据集的操作
#transforms提供了对数据预处理的操作

2. 读取数据集

# 定义超参数 

input_size = 28 
#图像的总尺寸28*28

num_classes = 10
#标签的种类数

num_epochs = 3
#训练的总循环周期

batch_size = 64  
#一个撮（批次）的大小，64张图片，分小批次训练

# 训练集
train_dataset = datasets.MNIST(root='./data',  
                            train=True,   
                            transform=transforms.ToTensor(),  
                            download=True) 
#datasets.Mnist()加载使用MNIST数据集
#root='./data'，下载到./data模具录下
#train=True，MNIST分为训练集和测试集，这表示我们希望加载训练集
#transform=transforms.ToTensor()，将图像转化为Tensor格式
#download=True表示如果指定目录下没有找到数据集，则会从互联网上下载该数据集


# 测试集
test_dataset = datasets.MNIST(root='./data', 
                           train=False, 
                           transform=transforms.ToTensor())
#train=False 表示加载MNIST数据集中的测试集

# 构建batch数据
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, 
                                           batch_size=batch_size, 
                                           shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
                                           batch_size=batch_size, 
                                           shuffle=True)
#torch.utils.data.DataLoader：构建数据加载器，用于在训练和测试过程中加载数据
#batch_size=batch_size，将数据集分为小批次来训练，提升训练速度
#shuffle=True表示打乱数据，提升训练质量

3. 搭建卷积神经网络模型

#卷积神经网络模型的搭建
#一般卷积层，relu层，池化层可以写成一个套餐
#注意卷积最后结果还是一个特征图，需要把图转换成向量才能做分类或者回归任务

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 调用 CNN 类的父类(即 nn.Module 类)的 __init__() 初始化方法
        # 这样可以确保 CNN 类在初始化时会执行父类 nn.Module 中定义的初始化逻辑
        
        self.conv1 = nn.Sequential(         # 输入大小 (1, 28, 28)
            nn.Conv2d(                      # 通常图像2D用的是Conv2d，视频3D用的是Conv3d
                in_channels=1,              # 卷积核通道数
                                            # 灰度图，这里要对应输入数据的通道channel，如果图象是3*28*28，那么卷积核也需要3个channel
                                            # 同时pytorch中，channel first，1*28*28
                                            # 通常情况下,彩色图像有 3 个通道,分别代表红(R)、绿(G)和蓝(B)三种颜色
                                            # 这三个通道，决定这一像素点的最终颜色                           
                 
                out_channels=16,            # 要得到几多少个特征图，也就是卷积核个数
                kernel_size=5,              # 卷积核大小为5*5
                stride=1,                   # 步长
                padding=2,                  # 如果希望卷积后大小跟原来一样，需要设置padding=(kernel_size-1)/2 if stride=1
            ),                              # 输出的特征图为 (16, 28, 28)，16为特征图的个数
                                            # 当一块区域的卷积完之后，相加再加上偏置，得到的值就是那一块的特征值
            nn.ReLU(),                      # relu层
            nn.MaxPool2d(kernel_size=2),    # 进行池化操作（2x2 区域）, 输出结果为： (16, 14, 14)，通常池化操作是为了筛选出好的特征
        )
        self.conv2 = nn.Sequential(         # 下一个套餐的输入 (16, 14, 14)
            nn.Conv2d(16, 32, 5, 1, 2),     # 输出 (32, 14, 14)
            nn.ReLU(),                      # relu层
            nn.MaxPool2d(2),                # 输出 (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   # 在进入全连接层之前，我们需要将三维的特征图展平为一维向量

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)           # flatten操作，结果为：(batch_size, 7 * 7)
                                            # 使用 view 方法将多维张量展平为二维张量（batch_size, 7 * 7），类似于reshape
                                            # -1 表示 PyTorch 应该自动计算第二个维度的大小
        output = self.out(x)
        return output

#通常全连接层认为特征与特征之间是没有关系的，因此更加适合处理结构化数据
#卷积层通常会综合考虑一个区域内的关系，适合处理图像，视频等数据
#经过卷积层后的特征图大小计算 H2=[(H1-FH+2*P)/S]+1，H1为输入的高，FH为卷积核的高，P为padding填充，S为stride步长

#x.view()函数的用法

a=torch.rand(32,7,7)
print(a.size(0))
#a.size(0)返回该张量的第一个维度的大小,例如,如果 a 的形状是 (batch_size, channels, height, width), 那么 a.size(0) 就是 batch_size
a=a.view(a.size(0), -1)
print(a.shape)
a=torch.rand(32,7,7)
a=a.view(-1,a.size(0))
print(a.shape)

b=torch.randn(2,3)
print(b)
print(b.view(1,6))
print(b.view(6,1))
print(b.view(-1,6))
print(b.view(6,-1))

print(b.view(2,1,3))
#由此可见，是按行顺序进行排列元素的

def accuracy(predictions, labels):
    pred = torch.max(predictions.data, 1)[1] 
    # 返回输入张量第一维的最大值，并返回最大值的索引，[1]代表需要最大值的索引
    
    rights = pred.eq(labels.data.view_as(pred)).sum() 
    # pred.eq(labels.data.view_as(pred)) 逐元素地比较预测值和标签是否相等
    # .sum() 统计 True 值（正确预测）的数量
    
    return rights, len(labels)

4. 模型训练+结果展示

net = CNN() 
# 实例化

criterion = nn.CrossEntropyLoss() 
#损失函数,计算交叉熵损失（Cross-Entropy Loss）的损失函数

optimizer = optim.Adam(net.parameters(), lr=0.001) #定义优化器，普通的随机梯度下降算法
#优化器

#开始训练循环
for epoch in range(num_epochs):
    #当前epoch的结果保存下来
    train_rights = [] 
    
    for batch_idx, (data, target) in enumerate(train_loader):  #针对容器中的每一个批进行循环
    # enumerate返回值有两个,一个是序号，一个是数据（包含训练数据和标签）    
        
        net.train()                             
        output = net(data) 
        loss = criterion(output, target) 
        optimizer.zero_grad() 
        loss.backward() 
        optimizer.step() 
        right = accuracy(output, target) 
        # right记录这每个批次正确分类的个数和总样本数
        
        train_rights.append(right)
        # train_right是一个元组列表，第一个元素是每个批次被正确分类的个数，第二个元素是每个批次训练样本的总数

    
        if batch_idx % 100 == 0: 
            
            net.eval() 
            val_rights = [] 
            
            for (data, target) in test_loader:
                output = net(data) 
                right = accuracy(output, target) 
                val_rights.append(right)
                
            #准确率计算
            train_r = (sum([tup[0] for tup in train_rights]), sum([tup[1] for tup in train_rights]))
            # [tup[0] for tup in train_rights]：生成一个包含所有元组第一个值（预测正确的样本数）的列表
            # sum([tup[0] for tup in train_rights])：计算该列表中所有预测正确样本数的总和
            
            val_r = (sum([tup[0] for tup in val_rights]), sum([tup[1] for tup in val_rights]))
            
            # [表达式 for 项 in 可迭代对象 if 条件]
            # 表达式：这是对每个项目进行操作的部分
            # for 项 in 可迭代对象：这是一个迭代部分，用于遍历可迭代对象（如列表、元组、字符串等）

            print('当前epoch: {} [{}/{} ({:.0f}%)]\t损失: {:.6f}\t训练集准确率: {:.2f}%\t测试集正确率: {:.2f}%'.format(
                epoch, batch_idx * batch_size, len(train_loader.dataset),
                100. * batch_idx / len(train_loader), 
                loss.data, 
                100. * train_r[0].numpy() / train_r[1], 
                100. * val_r[0].numpy() / val_r[1]))
            
            # batch_idx * batch_size：已经处理的样本数

结语：

通过对卷积神经网络（CNN）的学习，我们深入了解了其基本原理、层次结构和实际应用。CNN凭借其高效的特征提取能力，在图像识别和自然语言处理等领域取得了卓越的成果。展望未来，随着技术的不断进步和应用场景的扩展，CNN有望在更多领域实现突破，进一步推动人工智能的发展。

本人也是在学习AI的道路上，欢迎大家提出问题和分享答案。

Ol1ver0413

关注

8
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
卷积神经网络-学习笔记

cuda 12.3通过对卷积神经网络（CNN）的学习，我们深入了解了其基本原理、层次结构和实际应用。CNN凭借其高效的特征提取能力，在图像识别和自然语言处理等领域取得了卓越的成果。展望未来，随着技术的不断进步和应用场景的扩展，CNN有望在更多领域实现突破，进一步推动人工智能的发展。本人也是在学习AI的道路上，欢迎大家提出问题和分享答案。
复制链接

扫一扫