AlexNet网络结构及其代码复现

最新推荐文章于 2024-04-02 13:35:38 发布
最新推荐文章于 2024-04-02 13:35:38 发布
阅读量1.5k 收藏 11
点赞数 2
分类专栏： 图像分类 文章标签： 深度学习 alexnet模型 pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42735631/article/details/115800315
版权

1. AlexNet论文解析

1.1 Abstract

此神经网络由5个卷积层（其中一些是最大池化层）和3个全连接层组成。为了减少全连接层中的过拟合，采用了dropout方法，此方法在实验中被证明非常有效。在ILSVRC-2012比赛中，top-5 test error rate : 15.3% <第二名 26.2%>。

1.2 Details of learning

1. 数据增强
  • 从256*256的图像随机提取224*224的图像，并进行水平翻转，这使得了训练数据增加的2048【(256-224)*(256-224)*2】倍。在测试时，通过提取图像中的4个角落处和中心区域大小为224*224的图像，并同样进行水平翻转共10张图片，然后利用softmax将其平均求出其属于哪一个类别
  • 改变RGB通道的强度
2. Dropout

使用 dropout 在前两个全连接层，防止过拟合，以某一概率将隐藏层的输出值设置为0，论文中将此概率设置为0.5

3. Relu

在这里插入图片描述

虚线代表使用 Tanh 激活函数；实线代表使用 ReLu 激活函数。其他层结构均相同。

从上图可以看出Relu更好，在达到同样的训练误差25%，Relu 比 Tanh 快6倍

1.3 The Architecture

在这里插入图片描述

  1. Conv_1: （224，224， 3） —> （55， 55， 96）

    卷积层：

    • out_channels：96
    • kernel_size：（11，11）
    • stride：（4，4）

  2. Maxpool_1: （55， 55， 96） —> （27， 27，96）

    池化层：

    • kernel_size：（3，3）
    • stride：（2，2）

  3. Conv_2: （27， 27， 96）—> （27， 27， 256）

    卷积层：

    • out_channels：256
    • kernel_size：（5，5）
    • stride：（1，1）

  4. Maxpool_2: （27，27，256） —> （13，13，256）

    池化层：

    • kernel_size：（3，3）
    • stride：（2，2）

  5. Conv_3: （13，13，256） —> (13，13，384）

    卷积层：

    • out_channels：384
    • kernel_size：（3，3）
    • stride：（1，1）

  6. Conv_4：（13，13，384）—> (13，13，384）

    卷积层：

    • out_channels：384
    • kernel_size：（3，3）
    • stride：（1，1）

  7. Conv_5：（13，13，384）—> （13，13，256）

    卷积层：

    • out_channels：256
    • kernel_size：（3，3）
    • stride：（1，1）

  8. Maxpool_3: （13，13，256）—> （6，6，256）

    池化层：

    • kernel_size：（3，3）

    • stride：（2，2）

  9. FC_1 ： 66256 —> 4096

  10. FC_2： 4096 —> 4096

  11. FC_3：4096 —> 4096

2. 基于Pytorch代码复现

查看pytorch中的alexnet模型

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = models.alexnet(pretrained=True)
model.to(device)
print(model)
summary(model, input_size=(3, 224, 224))

在这里插入图片描述

在这里插入图片描述

2.1 数据预处理

  1. 随机裁剪指定大小(224*224)的图像
  2. 随机水平翻转
  3. 转换成tensor，方便计算
  4. 归一化处理
    • 此处我设置的值是我的数据集三个通道的平均值和方差
    • 如果你不清楚自己数据集三个通道的平均值和方差，可设置成mean=0.5, std=0.5
    • 经过比较，第一种设置方式比第二种设置方式的准确率要高
data_transform = {
        "train": transforms.Compose(
            [
                transforms.RandomResizedCrop(224),
                transforms.RandomHorizontalFlip(),
                transforms.ToTensor(),
                transforms.Normalize(mean=(0.78, 0.75, 0.70), std=(0.29, 0.29, 0.31))
            ]
        ),
        "val": transforms.Compose(
            [
                transforms.Resize((224, 224)),
                transforms.ToTensor(),
                transforms.Normalize(mean=(.78, .75, .70), std=(.29, .29, .31))
            ]
        )
    }

2.2 模型定义

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000, init_weight=False):
        super(AlexNet, self).__init__()
        self.feature_extraction = nn.Sequential(
            # [3, 224, 224] -> [96, 55, 55]
            nn.Conv2d(in_channels=3, out_channels=96, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2)),
            nn.ReLU(inplace=True),
            # [96, 55, 55] -> [96, 27, 27]
            nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2)),

            # [96, 27, 27] -> [256, 27, 27] same padding
            nn.Conv2d(in_channels=96, out_channels=256, kernel_size=(5, 5), padding=(2, 2)),
            nn.ReLU(inplace=True),
            # [256, 27, 27] -> [256, 13, 13]
            nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2)),

            # [256, 13, 13] -> [384, 13, 13] same padding
            nn.Conv2d(in_channels=256, out_channels=384, kernel_size=(3, 3), padding=(1, 1)),
            nn.ReLU(inplace=True),

            # [384, 13, 13] -> [384, 13, 13] same padding
            nn.Conv2d(in_channels=384, out_channels=384, kernel_size=(3, 3), padding=(1, 1)),
            nn.ReLU(inplace=True),

            # [384, 13, 13] -> [256, 13, 13] same padding
            nn.Conv2d(in_channels=384, out_channels=256, kernel_size=(3, 3), padding=(1, 1)),
            nn.ReLU(inplace=True),
            # [256, 13, 13] -> [256, 6, 6]
            nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2)),
        )
        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(in_features=256*6*6, out_features=4096),
            nn.Dropout(p=0.5),
            nn.Linear(in_features=4096, out_features=4096),
            nn.Linear(in_features=4096, out_features=num_classes),
        )

    def forward(self, x):
        x = self.feature_extraction(x)
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)
        return x

    def _initialize_weight(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)

2.3 训练模型

def get_net(flag, lr):
    """
    flag: bool类型，判断是否使用pytroch上的预训练模型
    lr: 学习率
    """
    if flag:
        # 加载预训练模型
        net = alexnet(pretrained=True)
        # 获得最后一层全连接层的输入维数
        num_input = net.classifier[-1].in_features
        cla_model = list(net.classifier.children())
        # 删除最后一层全连接层，并添加自己的全连接层
        cla_model.pop()
        cla_model.append(nn.Linear(num_input, 12))
        net.classifier = nn.Sequential(*cla_model)
        # 只优化自己添加的全连接层参数
        optimizer = optim.Adam(net.classifier[-1].parameters(), lr=lr)
    else:
        net = AlexNet(num_classes=12, init_weight=True)
        optimizer = optim.Adam(net.parameters(), lr=lr)
    return net, optimizer


def train(net, epochs, model_name, train_dataloader, val_dataloader, val_num, optimizer):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    if device == torch.device('cuda'):
        print("Using {} {} device for training.".format(device, torch.cuda.get_device_name(device)))
    else:
        print("Using {} device for training.".format(device))
    net.to(device)
    loss_function = nn.CrossEntropyLoss()
    optimizer = optimizer
    epochs = epochs
    save_path = os.path.join(os.getcwd(), model_name)
    best_acc = 0.0
    train_dataloader_num = len(train_dataloader)
    for epoch in range(epochs):
        net.train()
        total_loss = 0.0
        for step, data in enumerate(tqdm(train_dataloader)):
            images, labels = data
            optimizer.zero_grad()
            outputs = net(images.to(device))
            loss = loss_function(outputs, labels.to(device))
            loss.backward()
            optimizer.step()

            total_loss += loss.item()

        net.eval()
        acc = 0.0
        with torch.no_grad():
            for val_data in tqdm(val_dataloader):
                val_images, val_labels = val_data
                outputs = net(val_images.to(device))
                y_pred = torch.max(outputs, dim=1)[1]
                acc += torch.eq(y_pred, val_labels.to(device)).sum().item()

            val_acc = acc / val_num
            print('[epoch {}/{}] train_loss: {:.3f} val_acc: {:.3f}'.format(epoch + 1, epochs, total_loss / train_dataloader_num, val_acc))

            if val_acc > best_acc:
                best_acc = val_acc
                torch.save(net.state_dict(), save_path)
    print("Best acc: {:.3f}".format(best_acc))
    print('Finished Training')


def main():
    parse = argparse.ArgumentParser(description="AlexNet 命令行参数说明")
    parse.add_argument('--batch_size', type=int, default=16, help='batch大小')
    parse.add_argument('--file_name', type=str, default='garbage_classification', help='文件名')
    parse.add_argument('--model_name', type=str, default='AlexNet.pth', help='模型名称')
    parse.add_argument('--lr', type=float, default=0.0005, help='学习率')
    parse.add_argument('--epoch', type=int, default=10, help='迭代次数')
    parse.add_argument('--flag', action='store_true', help='是否使用ImageNet上的预训练模型')
    args = parse.parse_args()
    train_dataset, train_dataloader, val_dataset, val_dataloader = get_data(args.batch_size, args.file_name)
    train_num, val_num = len(train_dataset), len(val_dataset)
    print('Using {} images for training, {} images for validation'.format(train_num, val_num))
    net, optimizer = get_net(args.flag, args.lr)
    start = time.time()
    train(net=net, epochs=args.epoch, model_name=args.model_name, train_dataloader=train_dataloader,
          val_dataloader=val_dataloader, val_num=val_num, optimizer=optimizer)
    end = time.time()
    print("Train 耗时为：{}s".format(end-start))


if __name__ == '__main__':
    main()

2.4 训练结果

  1. 训练数据集和验证数据集大小及训练参数
Using 3306 images for training, 364 images for validation
Using cuda GeForce RTX 2060 device for training.
lr: 0.0001
batch_size: 16
  1. 使用自己定义的网络训练结果
[epoch 1/10] train_loss: 1.349 val_acc: 0.456
[epoch 2/10] train_loss: 1.157 val_acc: 0.538
[epoch 3/10] train_loss: 1.066 val_acc: 0.577
[epoch 4/10] train_loss: 1.008 val_acc: 0.629
[epoch 5/10] train_loss: 0.988 val_acc: 0.607
[epoch 6/10] train_loss: 0.947 val_acc: 0.629
[epoch 7/10] train_loss: 0.906 val_acc: 0.646
[epoch 8/10] train_loss: 0.890 val_acc: 0.651
[epoch 9/10] train_loss: 0.842 val_acc: 0.684
[epoch 10/10] train_loss: 0.829 val_acc: 0.717

Best acc: 0.717
Finished Training
Train 耗时为：270.9s
  1. 使用预训练模型训练结果
[epoch 1/10] train_loss: 0.605 val_acc: 0.824
[epoch 2/10] train_loss: 0.409 val_acc: 0.830
[epoch 3/10] train_loss: 0.371 val_acc: 0.868
[epoch 4/10] train_loss: 0.328 val_acc: 0.865
[epoch 5/10] train_loss: 0.300 val_acc: 0.865
[epoch 6/10] train_loss: 0.299 val_acc: 0.863
[epoch 7/10] train_loss: 0.279 val_acc: 0.893
[epoch 8/10] train_loss: 0.255 val_acc: 0.879
[epoch 9/10] train_loss: 0.252 val_acc: 0.885
[epoch 10/10] train_loss: 0.254 val_acc: 0.857


Best acc: 0.893
Finished Training
Train 耗时为：194.9s

下一篇：VggNet
完整代码

何如千泷
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
Alexnet模型以及训练代码
01-17
深度学习入门：使用Pytorch框架搭建Alexnet，在CIFAR10数据集上进行训练，可以用tensorboard查看训练过程，论文讲解以及代码讲解在我本人这篇博客中——论文解读与复现：Alexnet-ImageNet Classification with Deep ...
LeNet-AlexNet-ZFNet一维、二维复现pytorch-含视频手敲教程
一个学长的博客
06-01 2921
不管学习什么，基础都是非常重要的，那想对深度学习模型进行创新来说，基础就是所有的经典模型，想要从模型角度进行创新，毫无疑问就需要了解不同类型模型的特点，然后在对每一类模型有一定基础的了解上，再进行创新，目前主要有的经典模型有 LeNet-AlexNet-ZFNet-VGGNets-GooLeNet-ResNet-DenseNet其中前四种属于对卷积层纵向改变，GooLeNet，开始对模型结构进行了横向的变化，接着为了解决网络退化问题，2015年便出现了有名的ResNet残差网络，2017年结GooLeNet
【Pytorch深度学习开发实践学习】【AlexNet】经典算法复现-Pytorch实现AlexNet神经网络（1）model.py
weixin_44184852的博客
02-29 1068
AlexNet是人工智能深度学习在CV领域的开山之作，是最先把深度卷积神经网络应用于图像分类领域的研究成果，对后面的诸多研究起到了巨大的引领作用，因此有必要学习这个算法并能够实现它。
Pytorch代码复现AlexNet
最新发布
qq_62615329的博客
04-02 545
AlexNet整体的网络结构包括：1个输入层、5个卷积层、2个全连接层和1个输出层。
用pytorch构建Alexnet模型（model模块）（个人笔记）
qq_53534258的博客
03-26 4269
import torch.nn as nn import torch class AlexNet(nn.Module): def __init__(self, num_classes=1000, init_weights=False): # 通过初始化函数，定义网络在正向传播过程中所需要使用到的各层结构 super(AlexNet, self).__init__() self.features = nn.Sequential( # nn.Sequen.
AlexNet模型
奋斗才是年轻该有的状态
09-07 2883
一、AlexNet模型简介   上面对LeNet这个网络模型进行了介绍，该模型对手写数字是被具有较高的识别率，但是对于大数据量、复杂的物体图片分类，该模型的效果还是远远达不到要求的。在此背景下，AlexNet模型被提出，该模型在2012年imagenet上的图像分类challenge上赢得了的冠军。AlexNet模型证明了CNN在复杂模型下的有效性，并使用GPU使得大数据训练在可接受的时间范围内得
AlexNet的网络搭建代码与猫狗识别
m0_52153205的博客
03-19 2162
AlexNet网络是经典神经网络之一，诞生于2012年，我经过网上的资料搜集和研究，整理了利用Alexnet网络模型进行了猫狗分类识别。具体操作如下： AlexNet的网络模型如图所示利用这个模型写出了简单的代码： Net.py import torch from torch import nn import torch.nn.functional as F # 定义一个网络模型 class MyAlexNet(nn.Module): # 初始化网络 def __init__(.
CNN经典网络模型（二）：AlexNet简介及代码实现（PyTorch超详细注释版）
热门推荐
qq_43307074的博客
10-01 1万+
CNN经典网络模型之一：AlexNet，本文包含其简介及代码，在PyTorch中实现，进行超详细注释，适合新生小白阅读学习~
AlexNet模型及代码详解
weixin_42457110的博客
06-08 5715
Alex在2012年提出的alexnet网络结构模型引爆了神经网络的应用热潮，并赢得了2012届图像识别大赛的冠军，使得CNN成为在图像分类上的核心算法模型。 该网络的亮点在于： （1）首次使用了GPU进行网络加速训练。 （2）使用了ReLU激活函数，而不是传统的Sigmoid激活函数以及Tanh激活函数。 （3）使用了LRN局部响应归一化。 （4）在全连接层的前两层中使用了Droupout随机失活神经元操作，以减少过拟合。 模型组成 输入层 5个卷积层 3个全链接层 输入层： 输入大小为..
non-iid数据下的深度神经网络的分布式联邦学习  代码复现
09-13
Decentralized federated learning of deep neural networks on non-iid data non-iid数据下的深度神经网络的分布式联邦学习 代码复现  数据集：CIFAR-10 ，Fashion-MNIST  基线方案：① Random，随机八卦协议 ...
各种用于识别复杂网络重要节点的引力模型的代码复现
03-02
使用MATLAB语言复现的多种近些年来发表在一区期刊上的用引力模型识别复杂网络重要节点的论文。
双边滤波器论文代码复现及其改进
01-25
双边滤波器论文“Bilateral filtering for gray and color images”代码复现及其改进代码 matlab代码
使用numpy复现贝叶斯网络
10-16
适合学习机器学习算法入门 学习numpy开发机器学习算法
AlexNet代码讲解（Pytorch）
ing100的博客
03-16 2136
使用Pytorch实现AlexNet神经网络进并行训练，预测
Alextnet网络
Peter_Changyb的博客
08-25 2136
Alextnet网络结构图 从这个图我们可以很清楚地看到Alexnet的整个网络结构是由5个卷积层和3个全连接层组成的，深度总共8层。 图片上已经有一个较清楚的层与层直接转换的过程，那么接下来就对各层做个简单的解读。 Process --cov1 1.输入Input的图像规格： 224X224X3（RGB图像）,实际上会经过预处理变为227X227X3 2.使用的96个大小规格为1...
经典网络：AlexNet
csdn_xmj的博客
05-08 503
来源：Coursera吴恩达深度学习课程 Andrew对几个经典的神经网络结构（classic neural network architectures）的建议阅读顺序为AlexNet、LeNet-5和VGGNet。 下面介绍神经网络AlexNet，是以论文的第一作者Alex Krizhevsky的名字命名的，另外两位合著者是Ilya Sutskever和Geoffery Hinton。 AlexNet首先用一张227×227×3的图片作为输入（实际上原文中使用的图像是224×224×3），但是如
CNN网络：AlexNet（二）
qq_41048761的博客
02-07 1248
AlexNet的网络结构解析。
resnet18代码原理及其代码复现
06-02
ResNet18的主要原理是通过添加残差连接（skip connection）来构建深层神经网络。...要复现ResNet18模型，可以使用以上代码，并对数据集进行适当的预处理和训练。具体实现可以参考PyTorch官方文档和相关教程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值