pytorch（九）卷积神经网络

文章目录

  • 卷积神经网络
    • 全连接神经网络与卷积神经网络的区别
    • 概念性知识
    • mnist数据集(卷积神经网络)
  • GoogLeNet
    • Inception
  • 残差网络ResNet
    • 残差块结构

卷积神经网络

全连接神经网络与卷积神经网络的区别

全连接神经网络是一种最为基础的前馈神经网络，他的每一个神经元都与前一层的所有神经元进行连接，这种连接方式可以使得全连接神经网络能够学习到更加全局的特征。

  • 全连接：在全连接层中，每一个神经元都与前一层的所有神经元相连接，这以为这每一个神经元都收到来自前一层的所有输入的影响
  • 权重独立：全连接神经网络的权重参数不共享，每一个连接都有自己的权重，这就导致需要更新大量的参数，而且可能导致过拟合
  • 输出为以为向量：全连接的输出通常是一维向量

全连接神经网络需要更新的参数数量多，并且在全连接层的输入中，如果是对图像进行处理，比如mnist数据集案例，输入的是（通道1，高28，宽28像素）的图像，但是在全连接层中会被拉成（x=x.view(-1,784)）784的数据进行输入，这种输入可能会导致图像丢失重要的空间信息，比如相邻的像素比较相似等。

卷积神经网络CNN更适合用在图像识别、语音识别等各种场合

卷积神经网络最大的特点是它的卷积层，可以通过共享权重和偏置项，实现对输入数据的局部区域进行操作

  • 局部连接：卷积神经网络采用局部连接的方式，它的每一个神经元仅与输入数据的局部区域相连接
  • 权重共享：卷积层的每一个神经元在整个输入数据上共享相同的权重参数，这就降低了模型参数的数量，也意味着卷积层可以学习到特定的特征，而不会受到位置的影响
  • 特征映射：卷积神经网络的卷积层的输出是二维数组

概念性知识

  • 卷积核的通道数量与输入的通道数量相同
  • 卷积核的数量与输出的通道数量相同

一个卷积核的计算

在这里插入图片描述

m个卷积核的计算

在这里插入图片描述

mnist数据集(卷积神经网络)

在这里插入图片描述

# 使用卷积神经网络

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

batch_size=64
# 对图像进行处理，对原来图像从{0,255}-归一化->{0,1},把图像的维度变成c*w*h的 
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])

train_dataset=datasets.MNIST(root='./dataset/mnist/',train=True,download=True,transform=transform)
train_loader=DataLoader(train_dataset,shuffle=True,batch_size=batch_size)

test_dataset=datasets.MNIST(root='./dataset/mnist/',train=False,download=True,transform=transform)
test_loader=DataLoader(test_dataset,shuffle=False,batch_size=batch_size)

class Model(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.conv1=torch.nn.Conv2d(1,10,kernel_size=5)
        self.pooling=torch.nn.MaxPool2d(2)
        self.conv2=torch.nn.Conv2d(10,20,kernel_size=5)
        self.fc=torch.nn.Linear(320,10)
    
    def forward(self,x):
        # 这里需要重新获取batch_size,因为划分小数据块的时候不一定是整除的，不然可能会出错
        batch_size=x.size(0)
        x=F.relu(self.pooling(self.conv1(x)))
        # print(x.shape)
        x=F.relu(self.pooling(self.conv2(x)))
        # print(x.shape)
        x=x.view(batch_size,-1)
        # print(x.shape)
        x=self.fc(x)
        return x
        
model=Model()
criterion=torch.nn.CrossEntropyLoss()
# 带冲量为0.5
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

# device=torch.device('cudo:0' if torch.cudo.is.available() else 'cpu')
# model.to(device)# 模型迁移到显卡中

def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs,targets=data
        # inputs,targets=inputs.to(device),targets.to(device)
        # forward
        y_pred=model(inputs)
        loss=criterion(y_pred,targets)
        # backward
        optimizer.zero_grad()
        loss.backward()
        # update
        optimizer.step()
        
        running_loss+=loss.item()
        # print('batch_idx:',batch_idx)
        if batch_idx % 300 ==299:
            print('[%d,%5d] loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0

def test():
    correct=0
    total=0
    # 不需要计算梯度
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
            # inputs,labels=inputs.to(device),labels.to(device)
            outputs=model(images)
            # 取最大值的下标 dim表示维度
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
    print('Accuracy on test set:%d %%'%(100*correct/total))
    
    
    

if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

在这里插入图片描述

GoogLeNet

Inception

在这里插入图片描述

在这里插入图片描述

# GooLeNet

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

batch_size=64
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])

train_dataset=datasets.MNIST(root='./dataset/mnist/',train=True,download=True,transform=transform)
train_loader=DataLoader(train_dataset,shuffle=True,batch_size=batch_size)

test_dataset=datasets.MNIST(root='./dataset/mnist/',train=False,download=True,transform=transform)
test_loader=DataLoader(test_dataset,shuffle=False,batch_size=batch_size)

class InceptionA(nn.Module):
    def __init__(self,in_channels):
        super(InceptionA,self).__init__()
        self.branch1x1=nn.Conv2d(in_channels,16,kernel_size=1)
        
        self.branch5x5_1=nn.Conv2d(in_channels,16,kernel_size=1)
        self.branch5x5_2=nn.Conv2d(16,24,kernel_size=5,padding=2)
        
        self.branch3x3_1=nn.Conv2d(in_channels,16,kernel_size=1)
        self.branch3x3_2=nn.Conv2d(16,24,kernel_size=3,padding=1)
        self.branch3x3_3=nn.Conv2d(24,24,kernel_size=3,padding=1)
        
        self.branch_pool=nn.Conv2d(in_channels,24,kernel_size=1)
        
    def forward(self,x):
        branch1x1=self.branch1x1(x)
        
        branch5x5=self.branch5x5_1(x)
        branch5x5=self.branch5x5_2(branch5x5)
        
        branch3x3=self.branch3x3_1(x)
        branch3x3=self.branch3x3_2(branch3x3)
        branch3x3=self.branch3x3_3(branch3x3)
        
        branch_pool=F.avg_pool2d(x,kernel_size=3,stride=1,padding=1)
        branch_pool=self.branch_pool(branch_pool)
        
        outputs=[branch1x1,branch5x5,branch3x3,branch_pool]
        return torch.cat(outputs,dim=1)
    
    
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1=nn.Conv2d(1,10,kernel_size=5)
        self.conv2=nn.Conv2d(88,20,kernel_size=5)
        
        self.incep1=InceptionA(in_channels=10)
        self.incep2=InceptionA(in_channels=20)
        
        self.mp=nn.MaxPool2d(2)
        self.fc=nn.Linear(1408,10)
        
    def forward(self,x):
        in_size=x.size(0)
        x=F.relu(self.mp(self.conv1(x)))
        x=self.incep1(x)
        x=F.relu(self.mp(self.conv2(x)))
        x=self.incep2(x)
        x=x.view(in_size,-1)
        x=self.fc(x)
        return x

model=Net()
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs,targets=data
        y_pred=model(inputs)
        loss=criterion(y_pred,targets)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        running_loss+=loss.item()
        if batch_idx % 300 ==299:
            print('[%d,%5d] loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0
       
    
def test():
    correct=0
    total=0
    # 不需要计算梯度
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
            # inputs,labels=inputs.to(device),labels.to(device)
            outputs=model(images)
            # 取最大值的下标 dim表示维度
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
    print('Accuracy on test set:%d %%'%(100*correct/total))
    

if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

在这里插入图片描述

残差网络ResNet

随着神经网络的层数的增加，可能会出现梯度消失问题，而残差网络使用支线将输入直接连接到后面的层，使得后面的层可以直接学习残差

残差块结构

在这里插入图片描述

# 残差网络
import torch.nn as nn
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

class ResidualBlock(nn.Module):
    def __init__(self,channels):
        super(ResidualBlock,self).__init__()
        self.channels=channels
        # 输入与输出的通道数相同
        self.conv1=nn.Conv2d(channels,channels,kernel_size=3,padding=1)
        self.conv2=nn.Conv2d(channels,channels,kernel_size=3,padding=1)
        
    def forward(self,x):
        y=F.relu(self.conv1(x))
        y=self.conv2(y)
        return F.relu(x+y)
    
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1=nn.Conv2d(1,16,kernel_size=5)
        self.conv2=nn.Conv2d(16,32,kernel_size=5)
        self.mp=nn.MaxPool2d(2)
        
        self.rblock1=ResidualBlock(16)
        self.rblock2=ResidualBlock(32)
        
        self.fc=nn.Linear(512,10)
        
    def forward(self,x):
        in_size=x.size(0)
        x=self.mp(F.relu(self.conv1(x)))
        x=self.rblock1(x)
        x=self.mp(F.relu(self.conv2(x)))
        x=self.rblock2(x)
        x=x.view(in_size,-1)
        x=self.fc(x)
        return x
    
model=Net()
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs,targets=data
        y_pred=model(inputs)
        loss=criterion(y_pred,targets)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        running_loss+=loss.item()
        if batch_idx % 300 ==299:
            print('[%d,%5d] loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0
       
    
def test():
    correct=0
    total=0
    # 不需要计算梯度
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
            # inputs,labels=inputs.to(device),labels.to(device)
            outputs=model(images)
            # 取最大值的下标 dim表示维度
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
    print('Accuracy on test set:%d %%'%(100*correct/total))
    

if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/443815.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

QT----写完的程序打包为APK在自己的手机上运行

QT----写完的程序打包为APK在自己的手机上运行

目录 1、qt安装android组件2、打开qt配置Android 环境3、手机打开开发者模式，打开usb调试，连接电脑4、运行代码 1、qt安装android组件 qtcreater–工具-QTMaintenaceTool-startMaintenaceTool—登陆—添加或修改组件—找到android，安装 若是…
阅读更多...
基于java+springboot+vue实现的学生信息管理系统（文末源码+Lw+ppt）23-54

基于java+springboot+vue实现的学生信息管理系统（文末源码+Lw+ppt）23-54

摘 要 人类现已进入21世纪，科技日新月异，经济、信息等方面都取得了长足的进步，特别是信息网络技术的飞速发展，对政治、经济、军事、文化等方面都产生了很大的影响。 利用计算机网络的便利，开发一套基于java的大学生…
阅读更多...
.NET高级面试指南专题十五【 原型模式介绍，Clone要这样去用】

.NET高级面试指南专题十五【 原型模式介绍，Clone要这样去用】

介绍： 原型模式是一种创建型设计模式，其主要目的是通过克隆现有对象来创建新对象，而不是通过实例化新的对象。这种模式在需要创建相似对象时非常有用，尤其是当对象的创建过程比较昂贵或复杂时。 实现原理： 原型模式通过…
阅读更多...
数据类型与运算符

数据类型与运算符

关键字 C语言自己定义的一些单词 标识符//标志 定义 如变量，方法名，参数名，数组名等 要求 只有字母，数字下划线 不能以数字开头 不能用关键字 区分大小写 常量，变量 常量：不可变的量 变量：在程…
阅读更多...
群辉docker安装sql server

群辉docker安装sql server

安装步骤 开启群辉 SSH，通过 SSH 工具连接到群辉，运行下面的命令拉取mssql 2019 镜像 sudo docker pull mcr.microsoft.com/mssql/server:2019-latest然后在 docker 中就可以看到该镜像： 在群晖 docker 共享文件夹中创建 mssql2009 文件夹 …
阅读更多...
【IEEE列表会议】IEEE第三届信息与通信工程国际会议国际会议(JCICE 2024)

【IEEE列表会议】IEEE第三届信息与通信工程国际会议国际会议(JCICE 2024)

会议简介 Brief Introduction 2024年第三届信息与通信工程国际会议国际会议 (JCICE 2024) 会议时间：2024年5月10日-12日 召开地点：中国福州 大会官网：JCICE 2024-2024 International Joint Conference on Information and Communication Engi…
阅读更多...
LeetCode148题：排序链表（python3）

LeetCode148题：排序链表（python3）

在数组排序中，常见的排序算法有：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序等。 而对于链表排序而言，因为链表不支持随机访问，访问链表后面的节点只能依靠 next 指针从头…
阅读更多...
13. 用户注册功能实现

13. 用户注册功能实现

文章目录 一 、增加路由二、书写流程控制（controller）逻辑三、书写业务逻辑四、与DB交互五、测试 代码地址：https://gitee.com/lymgoforIT/bluebell 一 、增加路由 添加路由，使用分组管理 v1 : r.Group("/api/v1")//…
阅读更多...
springboot254小区团购管理

springboot254小区团购管理

小区团购管理设计与实现 摘 要 传统办法管理信息首先需要花费的时间比较多，其次数据出错率比较高，而且对错误的数据进行更改也比较困难，最后，检索数据费事费力。因此，在计算机上安装小区团购管理软件来发挥其高效地信…
阅读更多...
Discuz论坛网站报错Discuz！Database Error（0）notconnect的解决办法

Discuz论坛网站报错Discuz！Database Error（0）notconnect的解决办法

运营服务器大本营有段时间了，在运营期间遇到两次Discuz！Database Error（0）notconnect报错，和你们分享遇到Discuz报错的解决办法，希望可以帮助到你。 首先网站报错（0）notconnect&…
阅读更多...
【力扣】208.实现Trie

【力扣】208.实现Trie

实不相瞒，我怎么感觉洛谷里面的题目好难呢？虽然说万变不离其宗，但是我就觉得刷洛谷的题让我心情烦躁，刷不下去。于是今天我就刷力扣去了，明天继续挣扎吧！ 这道题目其实挺简单的，但是刚开始我没看…
阅读更多...
算法学习05：离散化、区间合并

算法学习05：离散化、区间合并

算法学习05：离散化、区间合并 文章目录 算法学习05：离散化、区间合并前言需要记忆的模版：一、离散化1.例题：离散化 区间和：拓展: 二、区间合并（贪心）1.例题： 总结 前言 需要记忆的模…
阅读更多...
LeetCode 173.二叉搜索树迭代器

LeetCode 173.二叉搜索树迭代器

实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器： BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在…
阅读更多...
【Delphi 开箱即用 3】随机生成玩家角色名 (支持男女性别选择)

【Delphi 开箱即用 3】随机生成玩家角色名 (支持男女性别选择)

现在玩家越来越懒了，需要一键生成角色名。这里用Delphi实现自动生成玩家角色名，生成的角色名与手动想出的一样，毫无任何违和感。 效果展示 实现原理 872条姓数据3000条男名数据5000条女名数据 的随机组合，理论上可以根据男女性别…
阅读更多...
【Scrapy】京东商品数据可视化

【Scrapy】京东商品数据可视化

【Scrapy】京东商品数据可视化 文章目录 【Scrapy】京东商品数据可视化  👉引言💎一、爬取数据：1.1 scrapy爬虫库简介：1.2 技术实现：1.2.1搭建框架结构1.2.2 分析网页结构 二、数据保存：三、数据读取以及…
阅读更多...
【leetcode】429. N 叉树的层序遍历

【leetcode】429. N 叉树的层序遍历

题目描述 给定一个 N 叉树，返回其节点值的_层序遍历_。（即从左到右，逐层遍历）。 树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。 示例 1： 输入：…
阅读更多...
Synthetic Temporal Anomaly Guided End-to-End Video Anomaly Detection 论文阅读

Synthetic Temporal Anomaly Guided End-to-End Video Anomaly Detection 论文阅读

Synthetic Temporal Anomaly Guided End-to-End Video Anomaly Detection 论文阅读 Abstract1. Introduction2. Related Work3. Methodology3.1. Architecture3.1.1 Autoencoder3.1.2 Temporal Pseudo Anomaly Synthesizer 3.2. Training3.3. Anomaly Score 4. Experiments4.1.…
阅读更多...
R语言更新版本

R语言更新版本

目录 一、更新R语言 1、安装最新的R语言版本 2、移动之前安装的packages 3、将Rstudio连接到最新的R语言 二、Rstudio更新 一、更新R语言 1、安装最新的R语言版本 查看当前R语言版本： R.version.string 下载最新的R语言安装包：R: The R Project…
阅读更多...
王阳明：在心里中一个春天！吃好喝好不等于吃饱喝足，出租屋的第二个周末——早读（逆天打工人爬取热门微信文章解读）

王阳明：在心里中一个春天！吃好喝好不等于吃饱喝足，出租屋的第二个周末——早读（逆天打工人爬取热门微信文章解读）

种一个春天，等下一个天亮 引言Python 代码第一篇 霸王别坤第二篇 （跳）洞见 王阳明：人生若是太苦寒，在心里种一个春天第三篇 人民日报 来了！新闻早班车要闻社会政策 结尾 屋宽不如心宽，物整亦是心…
阅读更多...
什么是微隔离技术？

什么是微隔离技术？

微隔离产生的背景 首先来看下南北向流量以及东西向流量的含义 南北向流量 指通过网关进出数据中心的流量，在云计算数据中心，处于用户业务虚拟机（容器）跟外部网络之间的流量，一般来说防火墙等安全设备部署在数…
阅读更多...
最新文章

Copyright @ 2022~2023