经典的卷积神经网络模型 - AlexNet

news2024/11/17 9:31:30

经典的卷积神经网络模型 - AlexNet

flyfish
AlexNet 是由 Alex Krizhevsky、Ilya Sutskever 和 Geoffrey Hinton 在 2012 年提出的一个深度卷积神经网络模型，在 ILSVRC-2012（ImageNet Large Scale Visual Recognition Challenge 2012）竞赛中取得了显著的成果，标志着深度学习在计算机视觉领域的一个重要里程碑。

ILSVRC 是一个大型视觉识别挑战赛，基于 ImageNet 数据集，每年吸引众多研究团队参加。 ILSVRC-2012 包含超过 1000 个类别和约 1500 万张带有注释的图片，是一个非常庞大的数据集。 AlexNet 在 ILSVRC-2012 竞赛中获得了 top-5 测试错误率为 15.3%，远低于当时其他参赛模型的错误率，通常在 26% 左右。top-5 错误率指的是模型预测中包含正确答案的前五个预测中至少有一个正确的比例。

import torchvision.models as models

# Load the pretrained AlexNet model
alexnet = models.alexnet(pretrained=True)

# Print the structure of the AlexNet model
print(alexnet)

AlexNet(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(inplace=True)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(inplace=True)
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(inplace=True)
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(inplace=True)
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
  (classifier): Sequential(
    (0): Dropout(p=0.5, inplace=False)
    (1): Linear(in_features=9216, out_features=4096, bias=True)
    (2): ReLU(inplace=True)
    (3): Dropout(p=0.5, inplace=False)
    (4): Linear(in_features=4096, out_features=4096, bias=True)
    (5): ReLU(inplace=True)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

在 AlexNet 模型中，输入和输出在以下位置：

  1. 输入 ：
  • 输入是通过模型的第一层 Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))。输入数据通常是形状为 (N, 3, H, W) 的张量，其中 N 是批次大小，3 是通道数（例如，RGB 图像），H 和 W 是图像的高度和宽度。
  1. 输出 ：
  • 输出是通过模型的最后一层 Linear(in_features=4096, out_features=1000, bias=True)。输出数据是形状为 (N, 1000) 的张量，其中 N 是批次大小，1000 是类别数量（即，模型预测的每个类别的概率）。
import torch
import torchvision.models as models

# 加载预训练的 AlexNet 模型
alexnet = models.alexnet(pretrained=True)

# 创建一个示例输入，形状为 (1, 3, 224, 224)
input_data = torch.randn(1, 3, 224, 224)

# 通过模型进行前向传播，获取输出
output = alexnet(input_data)

# 输出结果的形状
print("输入形状:", input_data.shape)
print("输出形状:", output.shape)

输入形状: torch.Size([1, 3, 224, 224])
输出形状: torch.Size([1, 1000])

AlexNet 模型的描述

  1. 原始图片 ：3x224x224 三通道彩色图片

  2. 卷积层 1 ：64核，11x11卷积核，stride=4，padding=2，输出64x55x55
    激活层 1 ：ReLU
    池化层 1 ：3x3池化核，stride=2，padding=0，输出64x27x27

  3. 卷积层 2 ：192核，5x5卷积核，stride=1，padding=2，输出192x27x27
    激活层 2 ：ReLU
    池化层 2 ：3x3池化核，stride=2，padding=0，输出192x13x13

  4. 卷积层 3 ：384核，3x3卷积核，stride=1，padding=1，输出384x13x13
    激活层 3 ：ReLU

  5. 卷积层 4 ：256核，3x3卷积核，stride=1，padding=1，输出256x13x13
    激活层 4 ：ReLU

  6. 卷积层 5 ：256核，3x3卷积核，stride=1，padding=1，输出256x13x13
    激活层 5 ：ReLU
    池化层 3 ：3x3池化核，stride=2，padding=0，输出256x6x6

  7. 全连接层 1 ：4096个神经元，接Dropout(p=0.5)和ReLU
    全连接层 2 ：4096个神经元，接Dropout(p=0.5)和ReLU
    全连接层 3 ：1000个神经元做分类

自定义一个与PyTorch提供的AlexNet一样结构的模型

import torch
import torch.nn as nn

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(64, 192, kernel_size=5, stride=1, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(192, 384, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2)
        )
        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
        self.classifier = nn.Sequential(
            nn.Dropout(),
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

# 创建 AlexNet 实例
model = AlexNet(num_classes=1000)

# 打印模型结构
print(model)

nn.MaxPool2d 计算过程和可视化

import torch
import torch.nn as nn

# 创建一个示例输入，形状为 (1, 1, 4, 4)
input_data = torch.tensor([[[[1, 2, 3, 4],
                             [5, 6, 7, 8],
                             [9, 10, 11, 12],
                             [13, 14, 15, 16]]]], dtype=torch.float32)

# 创建最大池化层
maxpool = nn.MaxPool2d(kernel_size=2, stride=2)

# 计算最大池化层的输出
output = maxpool(input_data)
print(output)

在这里插入图片描述可视化代码

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import imageio

def visualize_maxpool2d():
    input_data = torch.tensor([[[[1, 2, 3, 4],
                                 [5, 6, 7, 8],
                                 [9, 10, 11, 12],
                                 [13, 14, 15, 16]]]], dtype=torch.float32)
    maxpool = nn.MaxPool2d(kernel_size=2, stride=2)

    original_data = input_data[0, 0].numpy()
    pooled_data = maxpool(input_data).numpy()[0, 0]

    frames = []

    fig, axes = plt.subplots(1, 2, figsize=(10, 4))

    # 绘制原始数据
    cax1 = axes[0].matshow(original_data, cmap='Blues')
    for (i, j), val in np.ndenumerate(original_data):
        axes[0].text(j, i, f'{val:.0f}', ha='center', va='center', color='red')
    axes[0].set_title('Original Data')
    fig.colorbar(cax1, ax=axes[0])

    # 初始化池化后的数据图
    cax2 = axes[1].matshow(np.zeros_like(pooled_data), cmap='Blues', vmin=0, vmax=pooled_data.max())
    axes[1].set_xticks([])
    axes[1].set_yticks([])
    axes[1].set_title(f'Max Pooled Data')
    fig.colorbar(cax2, ax=axes[1])

    # 更新函数
    def update_frame(i, j):
        sub_matrix = original_data[i*2:i*2+2, j*2:j*2+2]
        pooled_value = pooled_data[i, j]

        # 更新原始数据窗口的矩形框
        rect = plt.Rectangle((j*2-0.5, i*2-0.5), 2, 2, linewidth=2, edgecolor='yellow', facecolor='none')
        axes[0].add_patch(rect)
        
        # 更新池化后的数据
        new_pooled_data = np.zeros_like(pooled_data)
        new_pooled_data[i, j] = pooled_value
        cax2.set_array(new_pooled_data)

        for (ii, jj), val in np.ndenumerate(new_pooled_data):
            if val > 0:
                axes[1].text(jj, ii, f'{val:.0f}', ha='center', va='center', color='red')

        plt.savefig(f'maxpool_{i}_{j}.png')
        frames.append(imageio.imread(f'maxpool_{i}_{j}.png'))
        rect.remove()  # 移除矩形框以便下一个帧绘制

    for i in range(2):
        for j in range(2):
            update_frame(i, j)

    # 保存为 GIF 动画
    imageio.mimsave('maxpool.gif', frames, fps=1,loop=0)

# 可视化并保存 GIF 动画
visualize_maxpool2d()

nn.AdaptiveAvgPool2d 计算过程和可视化

import torch
import torch.nn as nn

# 创建一个示例输入，形状为 (1, 1, 4, 4)
input_data = torch.tensor([[[[1, 2, 3, 4],
                             [5, 6, 7, 8],
                             [9, 10, 11, 12],
                             [13, 14, 15, 16]]]], dtype=torch.float32)

# 创建自适应平均池化层
adaptive_avgpool = nn.AdaptiveAvgPool2d((2, 2))

# 计算自适应平均池化层的输出
output = adaptive_avgpool(input_data)
print(output)

tensor([[[[ 3.5000,  5.5000],
          [11.5000, 13.5000]]]])

在这里插入图片描述
可视化代码

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import imageio

def visualize_adaptiveavgpool2d():
    input_data = torch.tensor([[[[1, 2, 3, 4],
                                 [5, 6, 7, 8],
                                 [9, 10, 11, 12],
                                 [13, 14, 15, 16]]]], dtype=torch.float32)
    adaptive_avgpool = nn.AdaptiveAvgPool2d((2, 2))

    original_data = input_data[0, 0].numpy()
    pooled_data = adaptive_avgpool(input_data).numpy()[0, 0]

    frames = []

    fig, axes = plt.subplots(1, 2, figsize=(10, 4))

    # 绘制原始数据
    cax1 = axes[0].matshow(original_data, cmap='Blues')
    for (i, j), val in np.ndenumerate(original_data):
        axes[0].text(j, i, f'{val:.0f}', ha='center', va='center', color='red')
    axes[0].set_title('Original Data')
    fig.colorbar(cax1, ax=axes[0])

    # 初始化池化后的数据图
    cax2 = axes[1].matshow(np.zeros_like(pooled_data), cmap='Blues', vmin=0, vmax=pooled_data.max())
    axes[1].set_xticks([])
    axes[1].set_yticks([])
    axes[1].set_title(f'Adaptive Avg Pooled Data')
    fig.colorbar(cax2, ax=axes[1])

    # 更新函数
    def update_frame(i, j):
        h_step = original_data.shape[0] // 2
        w_step = original_data.shape[1] // 2
        sub_matrix = original_data[i*h_step:(i+1)*h_step, j*w_step:(j+1)*w_step]
        pooled_value = pooled_data[i, j]

        # 更新原始数据窗口的矩形框
        rect = plt.Rectangle((j*w_step-0.5, i*h_step-0.5), w_step, h_step, linewidth=2, edgecolor='yellow', facecolor='none')
        axes[0].add_patch(rect)
        
        # 更新池化后的数据
        new_pooled_data = np.zeros_like(pooled_data)
        new_pooled_data[i, j] = pooled_value
        cax2.set_array(new_pooled_data)

        for (ii, jj), val in np.ndenumerate(new_pooled_data):
            if val > 0:
                axes[1].text(jj, ii, f'{val:.1f}', ha='center', va='center', color='red')

        plt.savefig(f'adaptiveavgpool_{i}_{j}.png')
        frames.append(imageio.imread(f'adaptiveavgpool_{i}_{j}.png'))
        rect.remove()  # 移除矩形框以便下一个帧绘制

    for i in range(2):
        for j in range(2):
            update_frame(i, j)

    # 保存为 GIF 动画
    imageio.mimsave('adaptiveavgpool.gif', frames, fps=1,loop=0)

# 可视化并保存 GIF 动画
visualize_adaptiveavgpool2d()

ReLU（Rectified Linear Unit）

ReLU ( x ) = ( x ) + = max ⁡ ( 0 , x ) \text{ReLU}(x) = (x)^+ = \max(0, x) ReLU(x)=(x)+=max(0,x)
在这里插入图片描述

import numpy as np
import matplotlib.pyplot as plt

def relu(x):
    return np.maximum(0, x)

# 生成输入数据
x = np.linspace(-10, 10, 400)
y = relu(x)

# 创建图形
plt.figure(figsize=(8, 6))
plt.plot(x, y, label='ReLU(x)', color='b')
plt.title('ReLU Activation Function')
plt.xlabel('Input')
plt.ylabel('Output')
plt.axhline(0, color='gray', lw=0.5)
plt.axvline(0, color='gray', lw=0.5)
plt.grid(True)
plt.legend()
plt.show()

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Domino应用中的HTML5

Domino应用中的HTML5

大家好，才是真的好。 在xpages多年不见有效更新，前景不明的时候，Domino传统Web应用开发方式还是受到了应有的青睐。毕竟，在Nomad Web时代，连最传统的Notes CS原生应用也突然焕发了勃勃生机一样。 但，对有…
阅读更多...
51单片机嵌入式开发：STC89C52环境配置到点亮LED

51单片机嵌入式开发：STC89C52环境配置到点亮LED

STC89C52环境配置到点亮LED 1 环境配置1.1 硬件环境1.2 编译环境1.3 烧录环境 2 工程配置2.1 工程框架2.2 工程创建2.3 参数配置 3 点亮一个LED3.1 原理图解读3.2 代码配置3.3 演示 4 总结 1 环境配置 1.1 硬件环境 硬件环境采用“华晴电子”的MINIEL-89C开发板，这…
阅读更多...
你还不会买智能猫砂盆吗？跟你们详细讲解今年最火的智能猫砂盆！

你还不会买智能猫砂盆吗？跟你们详细讲解今年最火的智能猫砂盆！

智能猫砂盆的坑，想必有很多养猫家庭都踩过吧。自己买回来的机器，不是空间不够大，导致猫咪拉到外面去，就是铲不干净，还得自己进行二次清理，搞得这个智能猫砂盆白买了。那如果我们想要购买合适自己家猫咪的智…
阅读更多...
MyBatisPlus 基础数据表的增删改查 入门 简单查询

MyBatisPlus 基础数据表的增删改查 入门 简单查询

MyBatisPlus MyBatisPlus（简称MP）是一个基于MyBatis的增强工具库，简化了MyBatis的开发，提供了很多实用的功能和特性，如自动生成SQL、通用CRUD操作、分页插件、条件构造器、代码生成器等。它不仅简化了开发过程&#x…
阅读更多...
Objective-C语法基础

Objective-C语法基础

新建一个XCode项目 新建一个类 1、成员变量、属性 1.1、类内使用成员变量&#xff0c;类外使用属性 Role.h #import <Foundation/Foundation.h>NS_ASSUME_NONNULL_BEGINinterface Role : NSObject {//成员变量&#xff1a;只能类内使用NSString *_name;int _age; }//属…
阅读更多...
二次封装 el-dialog 实现 全屏和最小化 功能

二次封装 el-dialog 实现 全屏和最小化 功能

效果 封装后的组件 <template><el-dialog v-model"dialogVisible" :show-close"false" :fullscreen"fullscreen" draggable overflow><template #header"{ close }"><div><span style"font-weight: b…
阅读更多...
ts语法---数据类型，interface和type的用法

ts语法---数据类型，interface和type的用法

ts的数据类型 ts的数据类型自上而下的分级有 第一层 any-任意类型和unknow类型&#xff0c; 第二层 原型链的Object类型&#xff0c; 第三层 js类的类型 第四层 标准的typescript类型 第五层 对应的实例数据类型 第六层 never类型&#xff0c;never表示不合理&#xff0c…
阅读更多...
【支撑文档】系统安全保证措施（word原件）

【支撑文档】系统安全保证措施（word原件）

软件安全保证措施word 软件所有全套资料获取进主页或者本文末个人名片直接。
阅读更多...
CesiumJS【Basic】- #037 绘制轮廓线（Entity方式）

CesiumJS【Basic】- #037 绘制轮廓线（Entity方式）

文章目录 绘制轮廓线（Entity方式）1 目标2 代码2.1 main.ts绘制轮廓线（Entity方式） 1 目标 使用Entity方式绘制轮廓线 2 代码 2.1 main.ts import * as Cesium from cesium;const viewer = new Cesium.Viewer(<
阅读更多...
DP V2.1a标准学习

DP V2.1a标准学习

一、说明 DP是DisplayPort的简写，是视频电子标准协会（VESA）标准化的数字式视频接口标准，可用于板内芯片之间的连接，也可用于输出接口连接外部设备。DisplayPort是一种基于数据包的可扩展协议，用于传输视频和音频数据。DisplayPort 具有高度可扩展性，并具有保持向后兼容…
阅读更多...
vue+js实现鼠标右键页面时在鼠标位置出现弹窗

vue+js实现鼠标右键页面时在鼠标位置出现弹窗

首先是弹窗元素 <div class"tanchuang move-win1"id"tanchuang1"><el-button>111</el-button></div>然后在需要弹窗的地方监听点击事件&#xff0c;可以将这个方法写在页面载入事件中 // 获取弹窗元素 var tanchuang document.…
阅读更多...
MySQL之高可用性(四)

MySQL之高可用性(四)

高可用性 故障转移和故障恢复 冗余是很好的技术&#xff0c;但实际上只有在遇到故障需要恢复时才会用到。(见鬼&#xff0c;这可以用备份来实现)。冗余一点儿也不会增加可用性或减少宕机。在故障转移的过程中&#xff0c;高可用性是建立在冗余的基础上。当有一个组件失效&…
阅读更多...
STM32系列-时钟系统

STM32系列-时钟系统

&#x1f308;个人主页&#xff1a;羽晨同学 &#x1f4ab;个人格言:“成为自己未来的主人~” 时钟的时钟源 HSI振荡器时钟HSE振荡器时钟PLL 时钟 STM32中的系统时钟可被内部高速时钟&#xff08;HSI&#xff09;&#xff0c;外部高速时钟&#xff08;HSE&#xff09;和PL…
阅读更多...
模型部署：C++libtorch实现全连接模型10分类和卷积模型ResNet18的四分类的模型部署推理

模型部署：C++libtorch实现全连接模型10分类和卷积模型ResNet18的四分类的模型部署推理

Clibtorch实现模型部署推理 模型 全连接模型&#xff1a;公开mnist手写识别数字的十分类卷积模型&#xff1a;自行采集的鲜花四分类 部署 语言环境&#xff1a;C 对比Python python是解释性语言&#xff0c;效率很慢&#xff0c;安全性很低 系统开发一般是java、C/C&…
阅读更多...
示例:WPF中推荐一个Diagram开源流程图控件

示例:WPF中推荐一个Diagram开源流程图控件

一、目的&#xff1a;分享一个自研的开源流程图控件 二、使用方法 1、引用Nuget包&#xff1a; 2、添加节点列表和绘图控件 <DockPanel><ItemsControl DockPanel.Dock"Left"><h:GeometryNodeData Text"节点"/></ItemsControl><…
阅读更多...
Magic aura skill VFX（魔法光环技能）

Magic aura skill VFX（魔法光环技能）

-----魔法光环技能VFX PACK----- 我们为您提供了一种新的高质量资产。MOBA和RPG的理想选择！享受 ------------------------ --------功能---------- 18个粒子预制件 1024*1024 + 512*512效果纹理 适用于VR、PC和移动设备 包括场景 包括后处理 AAA-质量 适用于Unity 2018.3 ===…
阅读更多...
Nature 正刊！全球200多位研究人员基于17738个森林样地数据集发现生物多样性可以防止非本地树种的入侵

Nature 正刊！全球200多位研究人员基于17738个森林样地数据集发现生物多样性可以防止非本地树种的入侵

本文首发于“生态学者”微信公众号&#xff01; 2023年8月23日&#xff0c;由苏黎世联邦理工学院领衔的全球超过200多位研究人员的团队首次探索了地球上哪些地区最容易受到非本地树木的入侵。这项研究以题为“Native diversity buffers against severity of non-native tree i…
阅读更多...
安防监控视频平台LntonCVS视频监控汇聚平台视频监控系统组成部分介绍

安防监控视频平台LntonCVS视频监控汇聚平台视频监控系统组成部分介绍

安防视频监控平台LntonCVS以其强大的拓展性、灵活的视频能力和轻便的部署方式著称。它支持多种主流标准协议&#xff0c;如国标GB28181、RTSP/Onvif、RTMP等&#xff0c;同时也能接入厂家的私有协议和SDK&#xff0c;如海康Ehome、海大宇等设备的SDK。除了传统的安防视频监控功…
阅读更多...
【开放词汇分割】Side Adapter Network for Open-Vocabulary Semantic Segmentation

【开放词汇分割】Side Adapter Network for Open-Vocabulary Semantic Segmentation

论文链接&#xff1a;Side Adapter Network for Open-Vocabulary Semantic Segmentation 代码链接&#xff1a;https://github.com/MendelXu/SAN 作者&#xff1a;Mengde Xu,Zheng Zhang,Fangyun Wei,Han Hu,Xiang Bai 发表单位&#xff1a;华中科技大学、微软亚洲研究院 会…
阅读更多...
CesiumJS【Basic】- #039 绘制渐变线（Entity方式）- 需要自定义着色器

CesiumJS【Basic】- #039 绘制渐变线（Entity方式）- 需要自定义着色器

文章目录 绘制渐变线（Entity方式）- 需要自定义着色器1 目标2 代码2.1 main.ts绘制渐变线（Entity方式）- 需要自定义着色器 1 目标 使用Entity方式绘制渐变线 2 代码 2.1 main.ts import * as Cesium from cesium;const viewer = new Cesium.Viewer
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023