【入门】5分钟了解卷积神经网络CNN是什么

本文来自《老饼讲解-BP神经网络》https://www.bbbdata.com/

目录

CNN神经网络常用于图片识别,是深度学习中常用的模型。

本文简单快速了解卷积神经网络是什么东西,并展示一个简单的示例。

一、卷积神经网络的结构

一个经典的卷积神经网络的结构如下:

C代表卷积层,P代表池化层,F代表全连接层。

卷积神经网络主要的、朴素的用途是图片识别。即输入图片,然后识别图片的类别,例如输入一张图片,识别该图片是猫还是狗。

1.1.卷积与池化的作用

卷积层与池化层共同是卷积神经网络的核心,它用于将输入图片进行压缩,例如一张224x224的图片,经过卷积+池化后,可能得到的就是55x55的图片,也就是说,卷积与池化的目的就是使得输入图片变小,同时尽量不要损失太多与类别相关的信息。例如一张猫的图片经过卷积与池化之后,尽量减少图片的大小,但要尽可能地保留"猫"的信息。

2.2.全连接层的作用

全连接层主要用于预测图片的类别。全连接层实际可以看作一个BP神经网络模型, 使用"卷积+池化"之后得到的特征来拟合图片的类别。

二、卷积神经网络的运算

2.1.卷积层的运算

卷积层的运算如下:

卷积层中的卷积核就是一个矩阵,直观来看它就是一个窗口,卷积窗口一般为正方形,即长宽一致,

卷积运算通过从左到右,从上往下移动卷积核窗口,将窗口覆盖的每一小块输入进行加权,作为输出

2.2.池化的运算

池化层是通过一个池化窗口,对输入进行逐块扫描,每次将窗口的元素合并为一个元素,

池化层的运算如下:

池化层一般分为均值池化与最大值池化,顾名思义,就是计算时使用均值还是最大值:

2.3.全连接层运算

全连接层就相当于一个BP神经网络模型,即每一层与下一层都是全连接形式。

假设前一层传过来的输入的是X,则当前层的输出是tanh(WX+b)

三、pytorch实现一个CNN例子

下面以手写数字识别为例,展示如何使用pytorch实现一个CNN

3.1.模型的搭建

如下所示,就搭建了一个CNN模型

python 复制代码
# 卷积神经网络的结构
class ConvNet(nn.Module):
    def __init__(self,in_channel,num_classes):
        super(ConvNet, self).__init__()
        self.nn_stack=nn.Sequential(
            #--------------C1层-------------------
            nn.Conv2d(in_channel,6, kernel_size=5,stride=1,padding=2),
            nn.ReLU(inplace=True),  
            nn.AvgPool2d(kernel_size=2,stride=2),
            # 输出14*14
            #--------------C2层-------------------
            nn.Conv2d(6,16, kernel_size=5,stride=1,padding=2),
            nn.ReLU(inplace=True),
            nn.AvgPool2d(kernel_size=2,stride=2),
            # 输出7*7
            #--------------C3层-------------------
            nn.Conv2d(16,80,kernel_size=7,stride=1,padding=0),
            # 输出1*1*80
            #--------------全连接层F4----------
            nn.Flatten(),          # 对C3的结果进行展平
            nn.Linear(80, 120),  
            nn.ReLU(inplace=True),                                   
            #--------------全连接层F5----------                      
            nn.Linear(120, num_classes)                       
            )
    def forward(self, x):
        p = self.nn_stack(x)
        return p

从代码里可以看到,只需按自己所设定的结构进行随意搭建就可以了。

搭建了之后再使用数据进行训练可以了,然后就可以使用模型对样本进行预测。

3.2.CNN完整训练代码

完整的CNN训练代码示例如下:

python 复制代码
import torch
from   torch import nn
from   torch.utils.data   import DataLoader
import torchvision
import numpy as np

#--------------------模型结构--------------------------------------------
# 卷积神经网络的结构
class ConvNet(nn.Module):
    def __init__(self,in_channel,num_classes):
        super(ConvNet, self).__init__()
        self.nn_stack=nn.Sequential(
            #--------------C1层-------------------
            nn.Conv2d(in_channel,6, kernel_size=5,stride=1,padding=2),
            nn.ReLU(inplace=True),  
            nn.AvgPool2d(kernel_size=2,stride=2),
            # 输出14*14
            #--------------C2层-------------------
            nn.Conv2d(6,16, kernel_size=5,stride=1,padding=2),
            nn.ReLU(inplace=True),
            nn.AvgPool2d(kernel_size=2,stride=2),
            # 输出7*7
            #--------------C3层-------------------
            nn.Conv2d(16,80,kernel_size=7,stride=1,padding=0),
            # 输出1*1*80
            #--------------全连接层F4----------
            nn.Flatten(),          # 对C3的结果进行展平
            nn.Linear(80, 120),  
            nn.ReLU(inplace=True),                                   
            #--------------全连接层F5----------                      
            nn.Linear(120, num_classes)                       
            )
    def forward(self, x):
        p = self.nn_stack(x)
        return p

#-----------------------模型训练---------------------------------------
# 参数初始化函数
def init_param(model):
    # 初始化权重阈值                                                                         
    param_list = list(model.named_parameters())                                                # 将模型的参数提取为列表                      
    for i in range(len(param_list)):                                                           # 逐个初始化权重、阈值
        is_weight = i%2==0                                                                     # 如果i是偶数,就是权重参数,i是奇数就是阈值参数
        if is_weight:                                                                          
            torch.nn.init.normal_(param_list[i][1],mean=0,std=0.01)                            # 对于权重,以N(0,0.01)进行随机初始化
        else:                                                                                  
           torch.nn.init.constant_(param_list[i][1],val=0)                                     # 阈值初始化为0
  
# 训练函数                                                                                     
def train(dataloader,valLoader,model,epochs,goal,device):                                      
    for epoch in range(epochs):                                                                
        err_num  = 0                                                                           # 本次epoch评估错误的样本
        eval_num = 0                                                                           # 本次epoch已评估的样本
        print('-----------当前epoch:',str(epoch),'----------------')                           
        for batch, (imgs, labels) in enumerate(dataloader):                                    
		    # -----训练模型-----                                                               
            x, y = imgs.to(device), labels.to(device)                                          # 将数据发送到设备
            optimizer.zero_grad()                                                              # 将优化器里的参数梯度清空
            py   = model(x)                                                                    # 计算模型的预测值   
            loss = lossFun(py, y)                                                              # 计算损失函数值
            loss.backward()                                                                    # 更新参数的梯度
            optimizer.step()                                                                   # 更新参数
			# ----计算错误率----                                                               
            idx      = torch.argmax(py,axis=1)                                                 # 模型的预测类别
            eval_num = eval_num + len(idx)                                                     # 更新本次epoch已评估的样本
            err_num  = err_num +sum(y != idx)                                                  # 更新本次epoch评估错误的样本
            if(batch%10==0):                                                                   # 每10批打印一次结果
                print('err_rate:',err_num/eval_num)                                            # 打印错误率
        # -----------验证数据误差---------------------------                                   
        model.eval()                                                                           # 将模型调整为评估状态
        val_acc_rate = calAcc(model,valLoader,device)                                          # 计算验证数据集的准确率
        model.train()                                                                          # 将模型调整回训练状态
        print("验证数据的准确率:",val_acc_rate)                                                # 打印准确率    
        if((err_num/eval_num)<=goal):                                                          # 检查退出条件
            break                                                                              
    print('训练步数',str(epoch),',最终训练误差',str(err_num/eval_num))                         

# 计算数据集的准确率                                                                           
def calAcc(model,dataLoader,device):                                                           
    py = np.empty(0)                                                                           # 初始化预测结果
    y  = np.empty(0)                                                                           # 初始化真实结果
    for batch, (imgs, labels) in enumerate(dataLoader):                                        # 逐批预测
        cur_py =  model(imgs.to(device))                                                       # 计算网络的输出
        cur_py = torch.argmax(cur_py,axis=1)                                                   # 将最大者作为预测结果
        py     = np.hstack((py,cur_py.detach().cpu().numpy()))                                 # 记录本批预测的y
        y      = np.hstack((y,labels))                                                         # 记录本批真实的y
    acc_rate = sum(y==py)/len(y)                                                               # 计算测试样本的准确率
    return acc_rate                                                                               

#--------------------------主流程脚本----------------------------------------------       
#-------------------加载数据--------------------------------
train_data = torchvision.datasets.MNIST(
    root       = 'D:\pytorch\data'                                                             # 路径,如果路径有,就直接从路径中加载,如果没有,就联网获取
    ,train     = True                                                                          # 获取训练数据
    ,transform = torchvision.transforms.ToTensor()                                             # 转换为tensor数据
    ,download  = True                                                                          # 是否下载,选为True,就下载到root下面
    ,target_transform= None)                                                                   
val_data = torchvision.datasets.MNIST(
    root       = 'D:\pytorch\data'                                                             # 路径,如果路径有,就直接从路径中加载,如果没有,就联网获取
    ,train     = False                                                                         # 获取测试数据
    ,transform = torchvision.transforms.ToTensor()                                             # 转换为tensor数据
    ,download  = True                                                                          # 是否下载,选为True,就下载到root下面
    ,target_transform= None)                                                                   
                                                                                               
#-------------------模型训练--------------------------------                                   
trainLoader = DataLoader(train_data, batch_size=1000, shuffle=True)                            # 将数据装载到DataLoader
valLoader   = DataLoader(val_data  , batch_size=100)                                           # 将验证数据装载到DataLoader 
device      = torch.device('cuda' if torch.cuda.is_available() else 'cpu')                     # 设置训练设备  
model       = ConvNet(in_channel =1,num_classes=10).to(device)                                 # 初始化模型,并发送到设备  
lossFun     = torch.nn.CrossEntropyLoss()                                                      # 定义损失函数为交叉熵损失函数
optimizer   = torch.optim.SGD(model.parameters(), lr=0.01,momentum =0.9,dampening=0.0005)      # 初始化优化器
train(trainLoader,valLoader,model,1000,0.01,device)                                            # 训练模型,训练100步,错误低于1%时停止训练

# -----------模型效果评估--------------------------- 
model.eval()                                                                                   # 将模型切换到评估状态(屏蔽Dropout)
train_acc_rate = calAcc(model,trainLoader,device)                                              # 计算训练数据集的准确率
print("训练数据的准确率:",train_acc_rate)                                                      # 打印准确率
val_acc_rate = calAcc(model,valLoader,device)                                                  # 计算验证数据集的准确率
print("验证数据的准确率:",val_acc_rate)                                                        # 打印准确率

运行结果如下:

-----------当前epoch: 0 ---------------- 
err_rate: tensor(0.7000)                 
验证数据的准确率: 0.3350877192982456     
-----------当前epoch: 1 ---------------- 
err_rate: tensor(0.6400)                 
验证数据的准确率: 0.3350877192982456     
-----------当前epoch: 2 ---------------- 
.......
.......
-----------当前epoch: 77 ----------------
err_rate: tensor(0.0100)                 
验证数据的准确率: 1.0                    
-----------当前epoch: 78 ----------------
err_rate: tensor(0.)                     
验证数据的准确率: 1.0                    
-----------当前epoch: 79 ----------------
err_rate: tensor(0.0200)                 
验证数据的准确率: 1.0                    
-----------当前epoch: 80 ----------------
err_rate: tensor(0.0100)                 
验证数据的准确率: 0.9982456140350877     
-----------------------------------------
训练步数 80 ,最终训练误差 tensor(0.0088) 
训练数据的准确率: 0.9982456140350877     
验证数据的准确率: 0.9982456140350877 

可以看到,识别效果达到了99.8%。CNN模型对图片的识别是非常有效的。


相关链接:

《老饼讲解-机器学习》:老饼讲解-机器学习教程-通俗易懂

《老饼讲解-神经网络》:老饼讲解-matlab神经网络-通俗易懂

《老饼讲解-神经网络》:老饼讲解-深度学习-通俗易懂

相关推荐
昨日之日20062 小时前
Moonshine - 新型开源ASR(语音识别)模型,体积小,速度快,比OpenAI Whisper快五倍 本地一键整合包下载
人工智能·whisper·语音识别
浮生如梦_2 小时前
Halcon基于laws纹理特征的SVM分类
图像处理·人工智能·算法·支持向量机·计算机视觉·分类·视觉检测
深度学习lover2 小时前
<项目代码>YOLOv8 苹果腐烂识别<目标检测>
人工智能·python·yolo·目标检测·计算机视觉·苹果腐烂识别
热爱跑步的恒川3 小时前
【论文复现】基于图卷积网络的轻量化推荐模型
网络·人工智能·开源·aigc·ai编程
阡之尘埃5 小时前
Python数据分析案例61——信贷风控评分卡模型(A卡)(scorecardpy 全面解析)
人工智能·python·机器学习·数据分析·智能风控·信贷风控
孙同学要努力7 小时前
全连接神经网络案例——手写数字识别
人工智能·深度学习·神经网络
Eric.Lee20217 小时前
yolo v5 开源项目
人工智能·yolo·目标检测·计算机视觉
其实吧38 小时前
基于Matlab的图像融合研究设计
人工智能·计算机视觉·matlab
丕羽8 小时前
【Pytorch】基本语法
人工智能·pytorch·python
ctrey_8 小时前
2024-11-1 学习人工智能的Day20 openCV(2)
人工智能·opencv·学习