AlexNet 和 VGGNet

Geeks.

于 2024-10-01 23:55:28 发布

阅读量327

点赞数 6

分类专栏：深度学习文章标签：人工智能

本文链接：https://blog.csdn.net/Darling912/article/details/142676069

版权

深度学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

AlexNet

但是我们也可以知道

在我们去正常的实现一个AlexNet这个网络的时候

我们先去模型进行初始化，之后在对模型进行一个相关的训练等一系列操作

这个操作的过程是非常的花费时间的

我们所得到的相关的结果所用的时间是很长的

过程也是非常的缓慢的

但是我们也不可区否认这个AlexNet在分类的相关的领域也有着不可撼动的地位

对于Alexnet的模型细节我们不难看出

这个模型的卷积层和全连接层的数量相对较多，所以我们训练的时候

花费的时候也是比较长的

对于Dropout的实现就是在模型训练的过程中，对于神经网络进行一个取舍的操作

Dropout 是一种常用的正则化技术，旨在提高深度学习模型的泛化能力。它的主要作用是通过随机丢弃一定比例的神经元，在训练过程中减少模型对特定神经元的依赖，从而防止过拟合。以下是 Dropout 的具体作用和机制：

1. 减少过拟合

过拟合现象：在训练集上表现良好，但在测试集或新数据上表现不佳。
Dropout 的作用：通过在训练过程中随机丢弃一部分神经元（通常以一定的概率），使得模型在每次前向传播时都只利用一部分特征。这种方式使模型无法依赖某些特定的神经元，从而提高了对未见数据的泛化能力。

2. 提高模型的鲁棒性

鲁棒性定义：模型对输入数据的变化或噪声的抵抗能力。
机制：Dropout 强迫网络学习到更为稳健的特征，因为即使某些特征被随机丢弃，网络仍需根据剩余的特征进行预测。

3. 模型集成效果

集成学习：多个模型的组合通常能取得比单一模型更好的性能。
Dropout 的效果：在训练期间每次都丢弃不同的神经元，可以看作是在训练多个不同的子网络（或子模型），这使得最终的模型具有集成学习的效果，从而提升整体性能。

4. 简单易用

实现简便：在现代深度学习框架（如 TensorFlow 和 PyTorch）中，Dropout 的实现非常简单，只需在需要的层中添加 Dropout 层，指定丢弃率（通常为 0.2 到 0.5 之间）。

5. 控制网络复杂性

复杂性控制：通过调节 Dropout 的丢弃率，可以有效控制网络的复杂性。较高的丢弃率会使网络更加简单，适用于较小的数据集；较低的丢弃率则适合较大的数据集。

总结

Dropout 是一种有效的正则化技术，通过在训练期间随机丢弃神经元，提升模型的泛化能力和鲁棒性，减少过拟合。它的实现简单且效果显著，因此在深度学习的应用中被广泛使用。

对于现在的激活函数

不管是Relu还是sigmiod函数

我们都可以去使用

没有说明我们一定要去使用这个RELU函数

这个函数的泛化能力确实比较不错

但是我们也不能说其他的激活函数没有用武之地

VGGNet

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
 
 
class VGG(nn.Module):
    def __init__(self):
        super(VGG, self).__init__()
        self.conv1_1 = nn.Conv2d(3, 64, 3, 1, 1)
        self.conv1_2 = nn.Conv2d(64, 64, 3, 1, 1)
        self.pool1 = nn.MaxPool2d(2)
 
        self.conv2_1 = nn.Conv2d(64, 128, 3, 1, 1)
        self.conv2_2 = nn.Conv2d(128, 128, 3, 1, 1)
        self.pool2 = nn.MaxPool2d(2)
 
        self.conv3_1 = nn.Conv2d(128, 256, 3, 1, 1)
        self.conv3_2 = nn.Conv2d(256, 256, 3, 1, 1)
        self.conv3_3 = nn.Conv2d(256, 256, 3, 1, 1)
        self.pool3 = nn.MaxPool2d(2)
 
        self.conv4_1 = nn.Conv2d(256, 512, 3, 1, 1)
        self.conv4_2 = nn.Conv2d(512, 512, 3, 1, 1)
        self.conv4_3 = nn.Conv2d(512, 512, 3, 1, 1)
        self.pool4 = nn.MaxPool2d(2)
 
        self.conv5_1 = nn.Conv2d(512, 512, 3, 1, 1)
        self.conv5_2 = nn.Conv2d(512, 512, 3, 1, 1)
        self.conv5_3 = nn.Conv2d(512, 512, 3, 1, 1)
        self.pool5 = nn.MaxPool2d(2)
 
        self.fc1 = nn.Linear(7 * 7 * 512, 4096)
        self.fc2 = nn.Linear(4096, 4096)
        self.classifier = nn.Linear(4096, 1000)
 
    def forward(self, x):
        x = F.relu(self.conv1_1(x))
        x = F.relu(self.conv1_2(x))
        x = self.pool1(x)
 
        x = F.relu(self.conv2_1(x))
        x = F.relu(self.conv2_2(x))
        x = self.pool2(x)
 
        x = F.relu(self.conv3_1(x))
        x = F.relu(self.conv3_2(x))
        x = F.relu(self.conv3_3(x))
        x = self.pool3(x)
 
        x = F.relu(self.conv4_1(x))
        x = F.relu(self.conv4_2(x))
        x = F.relu(self.conv4_3(x))
        x = self.pool4(x)
 
        x = F.relu(self.conv5_1(x))
        x = F.relu(self.conv5_2(x))
        x = F.relu(self.conv5_3(x))
        x = self.pool5(x)
 
        # print('conv5.shape',x.shape) #n*7*7*512
        x = x.reshape(-1, 7 * 7 * 512)
        # print('conv5.shape',x.shape) #n*7*7*512
 
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.classifier(x)
 
        return x
 
 
x = torch.randn((1, 3, 224, 224))
vgg = VGG()
y = vgg(x)
print(y.shape)
 
torch.save(vgg, 'vgg.pth')
torch.onnx.export(vgg, x, 'vgg.onnx')