GoogLeNet卷积神经网络-笔记

GoogLeNet卷积神经网络-笔记

GoogLeNet是2014年ImageNet比赛的冠军，
它的主要特点是网络不仅有深度，
还在横向上具有“宽度”。
由于图像信息在空间尺寸上的巨大差异，
如何选择合适的卷积核来提取特征就显得比较困难了。
空间分布范围更广的图像信息适合用较大的卷积核来提取其特征；
而空间分布范围较小的图像信息则适合用较小的卷积核来提取其特征。
为了解决这个问题，
GoogLeNet提出了一种被称为Inception模块的方案。

Inception模块结构图
在这里插入图片描述
GoogleNet模型网络结构图
在这里插入图片描述

测试结果为：
通过运行结果可以发现，使用GoogLeNet在眼疾筛查数据集iChallenge-PM上，loss能有效的下降，经过5个epoch的训练，在验证集上的准确率可以达到95%左右。

实测准确率为0.95左右
[validation] accuracy/loss: 0.9575/0.1915
[validation] accuracy/loss: 0.9500/0.2322

#输出结果：
PS E:\project\python> & D:/ProgramData/Anaconda3/python.exe e:/project/python/PM/GoogLeNet_PM.py
W0803 18:25:55.522811  8308 gpu_resources.cc:61] Please NOTE: device: 0, GPU Compute Capability: 6.1, Driver API Version: 12.2, Runtime API Version: 10.2
W0803 18:25:55.532805  8308 gpu_resources.cc:91] device: 0, cuDNN Version: 7.6.
116
start training ...
epoch: 0, batch_id: 0, loss is: 0.6920
epoch: 0, batch_id: 20, loss is: 0.8546
[validation] accuracy/loss: 0.7100/0.5381
epoch: 1, batch_id: 0, loss is: 0.6177
epoch: 1, batch_id: 20, loss is: 0.4581
[validation] accuracy/loss: 0.9400/0.3120
epoch: 2, batch_id: 0, loss is: 0.2858
epoch: 2, batch_id: 20, loss is: 0.5234
[validation] accuracy/loss: 0.5975/0.5757
epoch: 3, batch_id: 0, loss is: 0.6338
epoch: 3, batch_id: 20, loss is: 0.3180
[validation] accuracy/loss: 0.9575/0.1915
epoch: 4, batch_id: 0, loss is: 0.1087
epoch: 4, batch_id: 20, loss is: 0.3728
[validation] accuracy/loss: 0.9500/0.2322
PS E:\project\python>
'''

GoogleNet网模型中子图层Shape[N,C,H,W],w参数,b参数[Cout]

PS E:\project\python> & D:/ProgramData/Anaconda3/python.exe e:/project/python/PM/GoogLeNet_PM.py
W0803 20:27:47.303915 15396 gpu_resources.cc:61] Please NOTE: device: 0, GPU Compute Capability: 6.1, Driver API Version: 12.2, Runtime API Version: 10.2
W0803 20:27:47.311910 15396 gpu_resources.cc:91] device: 0, cuDNN Version: 7.6.
116
(10, 3, 224, 224)
[10, 3, 224, 224]
conv2d_0 [10, 64, 224, 224] [64, 3, 7, 7] [64]
max_pool2d_0 [10, 64, 112, 112]
conv2d_1 [10, 64, 112, 112] [64, 64, 1, 1] [64]
conv2d_2 [10, 192, 112, 112] [192, 64, 3, 3] [192]
max_pool2d_1 [10, 192, 56, 56]
print block3-1:
conv2d_3 [10, 64, 56, 56] [64, 192, 1, 1] [64]
conv2d_4 [10, 96, 56, 56] [96, 192, 1, 1] [96]
conv2d_5 [10, 128, 56, 56] [128, 96, 3, 3] [128]
conv2d_6 [10, 16, 56, 56] [16, 192, 1, 1] [16]
conv2d_7 [10, 32, 56, 56] [32, 16, 5, 5] [32]
max_pool2d_2 [10, 192, 56, 56]
conv2d_8 [10, 32, 56, 56] [32, 192, 1, 1] [32]
print block3-2:
conv2d_9 [10, 128, 56, 56] [128, 256, 1, 1] [128]
conv2d_10 [10, 128, 56, 56] [128, 256, 1, 1] [128]
conv2d_11 [10, 192, 56, 56] [192, 128, 3, 3] [192]
conv2d_12 [10, 32, 56, 56] [32, 256, 1, 1] [32]
conv2d_13 [10, 96, 56, 56] [96, 32, 5, 5] [96]
max_pool2d_3 [10, 256, 56, 56]
conv2d_14 [10, 64, 56, 56] [64, 256, 1, 1] [64]
max_pool2d_4 [10, 480, 28, 28]
print block4_1:
conv2d_15 [10, 192, 28, 28] [192, 480, 1, 1] [192]
conv2d_16 [10, 96, 28, 28] [96, 480, 1, 1] [96]
conv2d_17 [10, 208, 28, 28] [208, 96, 3, 3] [208]
conv2d_18 [10, 16, 28, 28] [16, 480, 1, 1] [16]
conv2d_19 [10, 48, 28, 28] [48, 16, 5, 5] [48]
max_pool2d_5 [10, 480, 28, 28]
conv2d_20 [10, 64, 28, 28] [64, 480, 1, 1] [64]
print block4_2:
conv2d_21 [10, 160, 28, 28] [160, 512, 1, 1] [160]
conv2d_22 [10, 112, 28, 28] [112, 512, 1, 1] [112]
conv2d_23 [10, 224, 28, 28] [224, 112, 3, 3] [224]
conv2d_24 [10, 24, 28, 28] [24, 512, 1, 1] [24]
conv2d_25 [10, 64, 28, 28] [64, 24, 5, 5] [64]
max_pool2d_6 [10, 512, 28, 28]
conv2d_26 [10, 64, 28, 28] [64, 512, 1, 1] [64]
print block4_3:
conv2d_27 [10, 128, 28, 28] [128, 512, 1, 1] [128]
conv2d_28 [10, 128, 28, 28] [128, 512, 1, 1] [128]
conv2d_29 [10, 256, 28, 28] [256, 128, 3, 3] [256]
conv2d_30 [10, 24, 28, 28] [24, 512, 1, 1] [24]
conv2d_31 [10, 64, 28, 28] [64, 24, 5, 5] [64]
max_pool2d_7 [10, 512, 28, 28]
conv2d_32 [10, 64, 28, 28] [64, 512, 1, 1] [64]
print block4_4:
conv2d_33 [10, 112, 28, 28] [112, 512, 1, 1] [112]
conv2d_34 [10, 144, 28, 28] [144, 512, 1, 1] [144]
conv2d_35 [10, 288, 28, 28] [288, 144, 3, 3] [288]
conv2d_36 [10, 32, 28, 28] [32, 512, 1, 1] [32]
conv2d_37 [10, 64, 28, 28] [64, 32, 5, 5] [64]
max_pool2d_8 [10, 512, 28, 28]
conv2d_38 [10, 64, 28, 28] [64, 512, 1, 1] [64]
print block4_5:
conv2d_39 [10, 256, 28, 28] [256, 528, 1, 1] [256]
conv2d_40 [10, 160, 28, 28] [160, 528, 1, 1] [160]
conv2d_41 [10, 320, 28, 28] [320, 160, 3, 3] [320]
conv2d_42 [10, 32, 28, 28] [32, 528, 1, 1] [32]
conv2d_43 [10, 128, 28, 28] [128, 32, 5, 5] [128]
max_pool2d_9 [10, 528, 28, 28]
conv2d_44 [10, 128, 28, 28] [128, 528, 1, 1] [128]
max_pool2d_10 [10, 832, 14, 14]
print block5_1:
conv2d_45 [10, 256, 14, 14] [256, 832, 1, 1] [256]
conv2d_46 [10, 160, 14, 14] [160, 832, 1, 1] [160]
conv2d_47 [10, 320, 14, 14] [320, 160, 3, 3] [320]
conv2d_48 [10, 32, 14, 14] [32, 832, 1, 1] [32]
conv2d_49 [10, 128, 14, 14] [128, 32, 5, 5] [128]
max_pool2d_11 [10, 832, 14, 14]
conv2d_50 [10, 128, 14, 14] [128, 832, 1, 1] [128]
print block5_2:
conv2d_51 [10, 384, 14, 14] [384, 832, 1, 1] [384]
conv2d_52 [10, 192, 14, 14] [192, 832, 1, 1] [192]
conv2d_53 [10, 384, 14, 14] [384, 192, 3, 3] [384]
conv2d_54 [10, 48, 14, 14] [48, 832, 1, 1] [48]
conv2d_55 [10, 128, 14, 14] [128, 48, 5, 5] [128]
max_pool2d_12 [10, 832, 14, 14]
conv2d_56 [10, 128, 14, 14] [128, 832, 1, 1] [128]
adaptive_avg_pool2d_0 [10, 1024, 1, 1]
linear_0 [10, 1] [1024, 1] [1]
PS E:\project\python>

测试源代码如下所示：

# GoogLeNet模型代码
#GoogLeNet卷积神经网络-笔记
import numpy as np
import paddle
from paddle.nn import Conv2D, MaxPool2D, AdaptiveAvgPool2D, Linear
## 组网
import paddle.nn.functional as F

# 定义Inception块
class Inception(paddle.nn.Layer):
    def __init__(self, c0, c1, c2, c3, c4, **kwargs):
        '''
        Inception模块的实现代码，
        
        c1,图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数
        c2,图(b)中第二条支路卷积的输出通道数，数据类型是tuple或list, 
               其中c2[0]是1x1卷积的输出通道数，c2[1]是3x3
        c3,图(b)中第三条支路卷积的输出通道数，数据类型是tuple或list, 
               其中c3[0]是1x1卷积的输出通道数，c3[1]是3x3
        c4,图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数
        '''
        super(Inception, self).__init__()
        # 依次创建Inception块每条支路上使用到的操作
        self.p1_1 = Conv2D(in_channels=c0,out_channels=c1, kernel_size=1, stride=1)
        self.p2_1 = Conv2D(in_channels=c0,out_channels=c2[0], kernel_size=1, stride=1)
        self.p2_2 = Conv2D(in_channels=c2[0],out_channels=c2[1], kernel_size=3, padding=1, stride=1)
        self.p3_1 = Conv2D(in_channels=c0,out_channels=c3[0], kernel_size=1, stride=1)
        self.p3_2 = Conv2D(in_channels=c3[0],out_channels=c3[1], kernel_size=5, padding=2, stride=1)
        self.p4_1 = MaxPool2D(kernel_size=3, stride=1, padding=1)
        self.p4_2 = Conv2D(in_channels=c0,out_channels=c4, kernel_size=1, stride=1)
        
        # # 新加一层batchnorm稳定收敛
        # self.batchnorm = paddle.nn.BatchNorm2D(c1+c2[1]+c3[1]+c4)

    def forward(self, x):
        # 支路1只包含一个1x1卷积
        p1 = F.relu(self.p1_1(x))
        # 支路2包含 1x1卷积 + 3x3卷积
        p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
        # 支路3包含 1x1卷积 + 5x5卷积
        p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
        # 支路4包含 最大池化和1x1卷积
        p4 = F.relu(self.p4_2(self.p4_1(x)))
        # 将每个支路的输出特征图拼接在一起作为最终的输出结果
        return paddle.concat([p1, p2, p3, p4], axis=1)
        # return self.batchnorm()
    
class GoogLeNet(paddle.nn.Layer):
    def __init__(self):
        super(GoogLeNet, self).__init__()
        # GoogLeNet包含五个模块，每个模块后面紧跟一个池化层
        # 第一个模块包含1个卷积层
        self.conv1 = Conv2D(in_channels=3,out_channels=64, kernel_size=7, padding=3, stride=1)
        # 3x3最大池化
        self.pool1 = MaxPool2D(kernel_size=3, stride=2, padding=1)
        # 第二个模块包含2个卷积层
        self.conv2_1 = Conv2D(in_channels=64,out_channels=64, kernel_size=1, stride=1)
        self.conv2_2 = Conv2D(in_channels=64,out_channels=192, kernel_size=3, padding=1, stride=1)
        # 3x3最大池化
        self.pool2 = MaxPool2D(kernel_size=3, stride=2, padding=1)
        # 第三个模块包含2个Inception块
        self.block3_1 = Inception(192, 64, (96, 128), (16, 32), 32)
        self.block3_2 = Inception(256, 128, (128, 192), (32, 96), 64)
        # 3x3最大池化
        self.pool3 = MaxPool2D(kernel_size=3, stride=2, padding=1)
        # 第四个模块包含5个Inception块
        self.block4_1 = Inception(480, 192, (96, 208), (16, 48), 64)
        self.block4_2 = Inception(512, 160, (112, 224), (24, 64), 64)
        self.block4_3 = Inception(512, 128, (128, 256), (24, 64), 64)
        self.block4_4 = Inception(512, 112, (144, 288), (32, 64), 64)
        self.block4_5 = Inception(528, 256, (160, 320), (32, 128), 128)
        # 3x3最大池化
        self.pool4 = MaxPool2D(kernel_size=3, stride=2, padding=1)
        # 第五个模块包含2个Inception块
        self.block5_1 = Inception(832, 256, (160, 320), (32, 128), 128)
        self.block5_2 = Inception(832, 384, (192, 384), (48, 128), 128)
        # 全局池化，用的是global_pooling，不需要设置pool_stride
        self.pool5 = AdaptiveAvgPool2D(output_size=1)
        self.fc = Linear(in_features=1024, out_features=1)

    def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))
        x = self.pool2(F.relu(self.conv2_2(F.relu(self.conv2_1(x)))))
        x = self.pool3(self.block3_2(self.block3_1(x)))
        x = self.block4_3(self.block4_2(self.block4_1(x)))
        x = self.pool4(self.block4_5(self.block4_4(x)))
        x = self.pool5(self.block5_2(self.block5_1(x)))
        x = paddle.reshape(x, [x.shape[0], -1])
        x = self.fc(x)
        return x

#=================================
import PM
# 创建模型
model = GoogLeNet()
print(len(model.parameters()))
opt = paddle.optimizer.Momentum(learning_rate=0.001, momentum=0.9, parameters=model.parameters(), weight_decay=0.001)
# 启动训练过程
PM.train_pm(model, opt)

—the—end—

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

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

相关文章

采集数据筛选-过滤不要数据或只保留指定数据

采集数据筛选-过滤不要数据或只保留指定数据

采集文章数据，有时候会遇到一些不需要采集的数据，或者只想采集一些特定的数据，可以使用简数采集器的内容过滤功能，对采集的数据进行筛选，只有符合的数据才采集保留。 可以用于过滤掉一些广告、专题、网站首页等无效数…
阅读更多...
ESD防静电监控系统在SMT产线中的应用案例

ESD防静电监控系统在SMT产线中的应用案例

作为电子厂的关键制造环节之一，SMT（表面贴装技术）产线的效率和质量对企业的竞争力至关重要。为了提高生产线的管理效率和保障生产环境的质量，许多电子厂开始采用MES生产管理系统和ESD防静电监控系统的综合解决方案。 在SMT产线中安…
阅读更多...
SpringBoot项目增加logback日志文件

SpringBoot项目增加logback日志文件

一、简介 在开发和调试过程中，日志是一项非常重要的工具。它不仅可以帮助我们快速定位和解决问题，还可以记录和监控系统的运行状态。Spring Boot默认提供了一套简单易用且功能强大的日志框架logback，本文将介绍如何在Spring Boot项目中配置和…
阅读更多...
无涯教程-Perl - 循环语句

无涯教程-Perl - 循环语句

在某些情况下，您需要多次执行一个代码块。通常，语句是按顺序执行的:函数中的第一个语句首先执行，然后第二个执行，依此类推。 Perl编程语言提供了以下类型的循环来处理循环需求。 Sr.No.Loop Type & 描述1 while loop在给定条…
阅读更多...
浅谈大数据软件的功能性分析

浅谈大数据软件的功能性分析

在当今时代的潮流中，工作中遇到大数据处理的时候非常多，因此需要一些大数据分析软件帮助人们进行工作。由于这些软件针对的对象不同，因此使用方法也不同，那么为了帮助更多的人了解大数据分析软件，我们就对这些软件的功…
阅读更多...
Spring Cloud+Spring Boot+Mybatis+uniapp+前后端分离实现知识付费平台免费搭建 qt

Spring Cloud+Spring Boot+Mybatis+uniapp+前后端分离实现知识付费平台免费搭建 qt

Java版知识付费源码 Spring CloudSpring BootMybatisuniapp前后端分离实现知识付费平台 提供职业教育、企业培训、知识付费系统搭建服务。系统功能包含：录播课、直播课、题库、营销、公司组织架构、员工入职培训等。 提供私有化部署，免费售…
阅读更多...
【3维视觉】3D空间常用算法（点到直线距离、面法线、二面角）

【3维视觉】3D空间常用算法（点到直线距离、面法线、二面角）

3D空间点到直线的距离 3D空间点到直线的距离 3D空间的曲率 三维空间有三个基本元素，点，线，面。那么曲率是如何定义的呢？ 点的曲率？ 线的曲率？ 面的曲率？ 法曲率 设曲面上的曲线在某一点处的切…
阅读更多...
prometheus+grafana进行服务器资源监控

prometheus+grafana进行服务器资源监控

在性能测试中，服务器资源是值得关注一项内容，目前，市面上已经有很多的服务器资 源监控方法和各种不同的监控工具，方便在各个项目中使用。 但是，在性能测试中，究竟哪些指标值得被关注呢？ 监控有…
阅读更多...
Git下：Git命令使用-详细解读

Git下：Git命令使用-详细解读

今天给大家讲一讲 Git常用命令的使用说明，希望本篇文章对大家有所帮助。 一、Git 安装 Git 的详细安装教程：见上一篇文章《Git上：Git安装教程》： Git上：全网最全最详细的Git安装教程，建议收藏保存 二、…
阅读更多...
TDosCommand 组件来执行 JavaScript 脚本（nodejs）

TDosCommand 组件来执行 JavaScript 脚本（nodejs）

可以在 Delphi 中使用 TDosCommand 组件来执行 JavaScript 脚本。但是，由于 JavaScript 是一种脚本语言，它通常在浏览器中运行，因此您需要使用一种 JavaScript 引擎来执行 JavaScript 脚本。常见的 JavaScript 引擎有 Node.js、Rhino、V8 等等…
阅读更多...
面试题学习以及问题

面试题学习以及问题

redis redis缓存 缓存穿透 布隆过滤器主要是用于检索一个元素是否在一个集合中。我们当时使用的是 redisson实现的布隆过滤器。 它的底层主要是先去初始化一个比较大数组，里面存放的二进制0或1。在一 开始都是0，当一个key来了之后经过3次hash计算&…
阅读更多...
vscode配置c++环境

vscode配置c++环境

第一步：安装vscode编辑器 预先安装： vscode（https://code.visualstudio.com/）在vscode中安装 C/C extension for VS Code（在左侧扩展栏中搜索 “C”） 第二步：安装MinGW-w64工具链 MinGW 提供…
阅读更多...
超详情的开源知识库管理系统- mm-wiki的安装和使用

超详情的开源知识库管理系统- mm-wiki的安装和使用

背景：最近公司需要一款可以记录公司内部文档信息，一些只是累计等，通过之前的经验积累，立马想到了 mm-wiki，然后就给公司搭建了一套，分享一下安装和使用说明： 当前市场上众多的优秀的文档系统百…
阅读更多...
VBA技术资料MF36：VBA_在Excel中排序

VBA技术资料MF36：VBA_在Excel中排序

【分享成果，随喜正能量】一个人的气质，并不在容颜和身材，而是所经历过的往事，是内在留下的印迹，令人深沉而安谧。所以，优雅是一种阅历的凝聚；淡然是一段人生的沉淀。时间会让一颗灵魂&#xff0…
阅读更多...
设置系统编码 Beta

设置系统编码 Beta

在yolov5环境搭建过程中会遇到如下的编码错误警告： 这时，按住“ctrlc”中止进程，然后设置系统编码： 电脑右键属性打开： 重启之后等安装好了，记得回去把bae键取消。
阅读更多...
Ansible自动化运维工具 —— Playbook 剧本

Ansible自动化运维工具 —— Playbook 剧本

playbooks 本身由以下各部分组成 （1）Tasks：任务，即通过 task 调用 ansible 的模板将多个操作组织在一个 playbook 中运行 （2）Variables：变量 （3）Templates：模…
阅读更多...
iOS——Block one

iOS——Block one

块类似于匿名函数或闭包，在许多其他编程语言中也存在类似的概念。 可以访问上下文，运行效率高 Block 以下是块的一些基本知识： 块的定义：块是由一对花括号 {} 包围的代码片段，可以包含一段可执行的代码。块的定义使…
阅读更多...
Stable Diffusion - Stable Diffusion WebUI 支持 SDXL 1.0 模型的环境配置

Stable Diffusion - Stable Diffusion WebUI 支持 SDXL 1.0 模型的环境配置

欢迎关注我的CSDN：https://spike.blog.csdn.net/ 本文地址：https://spike.blog.csdn.net/article/details/132056980 SDXL 1.0 版本 是 Stable Diffusion 的最新版本，是基于潜在扩散模型的文本到图像生成技术，能够根据输入的任何文…
阅读更多...
机器学习知识经验分享之六：决策树

机器学习知识经验分享之六：决策树

python语言用于深度学习较为广泛，R语言用于机器学习领域中的数据预测和数据处理算法较多，后续将更多分享机器学习数据预测相关知识的分享，有需要的朋友可持续关注，有疑问可以关注后私信留言。 目录 一、R语言介绍 二、R语言安装…
阅读更多...
ansible的脚本——playbook剧本

ansible的脚本——playbook剧本

目录 一、playbook的组成 二、 playbook安装httpd服务 1.编写playbook剧本 2.运行playbook 三、定义、引用变量 四、 指定远程主机sudo切换用户 五、when条件判断 六、迭代 七、Templates 模块 1.先准备一个以 .j2 为后缀的 template 模板文件，设置引用的变…
阅读更多...
最新文章

Copyright @ 2022~2023