本专栏介绍基于深度学习进行图像识别的经典和前沿模型，将持续更新，包括不仅限于：AlexNet， ZFNet，VGG，GoogLeNet，ResNet，DenseNet，SENet，MobileNet，ShuffleNet，EifficientNet，Vision Transformer，Swin Transformer，Visual Attention Network，ConvNeXt， MLP-Mixer，As-MLP，ConvMixer，MetaFormer
前言
2012年，Alex Krizhevsky、Ilya Sutskever在多伦多大学Geoff Hinton带领的实验室设计出了一个深层的卷积神经网络，即AlexNet。该网络在2012年的ImageNet LSVRC比赛中获得冠军，准确率远超第二名（错误率为15.3%，第二名为26.2%），引起了巨大轰动。AlexNet模型可以说是一个具有历史意义的网络结构，在此之前，深度学习已经沉寂了将近20年。自2012年AlexNet问世以来，后续的ImageNet冠军都是通过使用卷积神经网络（CNN）获得的，并且网络结构也越来越深，使得CNN成为计算机视觉领域的核心算法模型。在未来的20年中，CNN在计算机视觉领域的地位始终是统治性的，可以说AlexNet引发了深度学习的大爆发。
由于Alex Krizhevsky团队并没有为自己的网络命名，后人为了方便将这个网络模型称为AlexNet。同学们如果不想让别人随意给自己的网络取名字，在写论文时应该为自己的网络取个名字。
论文名称：Imagenet classification with deep convolutional neural networks论文下载链接：https://proceedings.neurips.cc/paper/2012/file/c399862d3b9d6b76c8436e924a68c45b-Paper.pdfpytorch代码实现：https://github.com/Arwin-Yu/Deep-Learning-Classification-Models-Based-CNN-or-Attention
创作不易，引用或转载请标明出处。
一、AlexNet理论
AlexNet其实跟LeNet很像很像(LeNet传送门)，几乎可以说是LeNet的升级版，都是有卷积和全连接组成。AlexNet之所以能够成功，跟这个模型设计的特点有关，主要有：
- 使用了非线性激活函数：ReLU
- 随机失活：Dropout
- 数据扩充：Data augmentation
- 其他：多GPU实现，LRN归一化层的使用
1. 激活函数：ReLU
传统的神经网络普遍使用Sigmoid或者tanh等非线性函数作为激励函数，然而它们容易出现梯度弥散或梯度饱和的情况。以Sigmoid函数为例，如下图所示，当输入的值非常大或者非常小的时候，值域的变化范围非常小，使得这些神经元的梯度值接近于0（梯度饱和现象）。由于神经网络的计算本质上是矩阵的连乘，一些近乎于0的值在连乘计算中会越来越小，导致网络训练中梯度更新的弥散现象，即梯度消失。
但是relu不存在这个缺陷，它在第一象限近似函数：y=x，不会出现值域变化小的问题。relu函数直到现在也是学术界和工业界公认的最好用的激活函数之一，在各个不同领域不同模型下的使用非常之多。
其实，对于relu函数的设计思想我们可以寻求一个生物学解释，大家回忆一下初中的一个生物实验：生物学家们用电流刺激青蛙的大腿肌肉，当电流强度不够强时，肌肉组织不反应（即relu函数在x<0时，输出恒等于0的表现）；当电流强度到达一定的阈值，肌肉组织开始抽搐，且电流强度越大，抽搐反应越强（即relu函数在x>0时，输出为y=x的表现）。本质上，这是一种非线性的体现。
2. 随机失活：Dropout
引入Dropout主要是为了防止网络在训练过程中出现的过拟合现象。过拟合现象出现的原因有两方面：1.数据集太小。 2.模型太复杂。至于产生过拟合的原因我们可以类别生活中的一个场景去解释：
高三的时候，老师出了一套题库给大家做联系，并说期末考试的题就是从题库中抽出来的。但是，这个题库的题量非常少，且都是选择题，那么这时候想要期末考高分的最快捷方法是什么呢？其实并不是把每道题都理解，都学会，而是单纯的背答案！
所以模型也是一样的，当数据太小时，模型就不会去学习数据中的相关性，不会尝试去理解数据，提取特征。最便捷的一种方式是把数据集中的所有数据强行记忆下来，这就叫过拟合。可以想象，一个过拟合的模型是没有举一反三的能力的，即对数据的泛化能力太差，只能对训练数据集中的数据做很好的处理，一旦换一批新的类似数据，模型的处理能力会很差。
那如何解决呢？两个方案：1.提升数据集容量，让模型难以记忆所有的数据，这时候它就会尝试学习数据，理解数据了，因为相较于记忆所有数据，这是种更容易的解决方案。 2.把模型变的简单些，我们想：之所以高三的学生会选择背答案，其实是因为高三的学生比较聪明，如果换个小学生来，他八成是想不到背答案的。因此模型也是一样的，模型会选择记忆数据一方面是因为模型太复杂，他有能力去记忆所有数据。当我们降低模型的复杂度时，他就不会出现过拟合现象。总之，过拟合的本质是数据集与模型在复杂度上不匹配。
在神经网络中Dropout是通过降低模型复杂度来防止过拟合现象的，对于某一层的神经元，通过一定的概率将某些神经元的计算结果乘0，这个神经元就不参与前向和后向传播，就如同在网络中被删除了一样，同时保持输入层与输出层神经元的个数不变，然后按照神经网络的学习方法进行参数更新。在下一次迭代中，又重新随机删除一些神经元（置为0），直至训练结束。
3. 数据扩充：Data augmentation
由于神经网络算法是基于数据驱动的，因此，有一种观点认为神经网络是靠数据喂出来的，如果能够增加训练数据，提供海量数据进行训练，则能够有效提升算法的准确率，因为这样可以避免过拟合，从而可以进一步增大、加深网络结构。而当训练数据有限时，可以通过一些变换从已有的训练数据集中生成一些新的数据，以快速地扩充训练数据。
其中，最简单、通用的图像数据变形的方式：水平翻转图像，从原始图像中随机裁剪、平移变换，颜色、光照变换，如下图所示：
数据增广确实是提升模型的有效手段，而且最近的增广方式也不仅限于这种随即裁剪，也可以使用生成对抗网络进行图像生成来达到图像增广的目的。
4. 多GPU实现 : Distributed training
AlexNet当时使用了GTX580的GPU进行训练，由于单个GTX 580 GPU只有3GB内存，这限制了在其上训练的网络的最大规模，因此他们将模型拆成两部分，分别放进两个GPU硬件中进行训练，在训练过程中会通过交换feature maps进行两个硬件中子网络的信息交流，大大加快了AlexNet的训练速度。当时其实纯属硬件设备限制的无奈之举，但是，现在看来，这种拆成两组的训练方式跟现代的一种卷积变体非常非常类似：组卷积（group convolution）。个人认为，这也AelxNet效果好的一个主要原因，不过作者当时并没有发现，也算是无心插柳柳成荫了。
5. 局部响应归一化 : LRN
全局响应归一化（Local Response Normalization，LRN）技术主要用于提高深度学习训练的准确性。一般来说，LRN是在激活和池化之后进行的一种处理方法。这个归一化技术最早是在AlexNet模型中被提出的。通过实验确实证明它可以提高模型的泛化能力，但是提升的能力有限。后来这种方法逐渐被弃用，有些人甚至认为它是一个“伪命题”，因此备受争议。如今，Batch Normalization已经成为了局部归一化的主流替代方法。
下面简要介绍一下局部归一化的灵感来源：LRN 的基本思想是模拟侧抑制效应，该效应是生物神经系统的一种现象，即一个活跃的神经元会抑制其邻近神经元的活跃度。在 CNN 中，这通常通过在每个小批量样本上沿深度维度进行归一化实现。也就是说，一个特定的神经元的输出将被它的 “邻居” 神经元的活跃度所规范化。
具体地，LRN 层会考虑每个神经元的 n 个相邻神经元，并计算其平方和。然后，原始神经元的激活值将被规范化，即除以一个值，这个值等于（常数 k 加上原始平方和乘以常数 α）的 β 次幂。在这里，k、n、α 和 β 是 LRN 层的超参数。
实验总结：由于LRN模仿生物神经系统的侧抑制机制，对局部神经元的活动创建竞争机制，从而使响应较大的值更大，提高了模型的泛化能力。在ImageNet实验中，深度学习之父Hinton等人使用LRN技术分别提升了模型1.4%和1.2%的准确率。然而，随后的研究并不太认可这项技术，以至于它至今仍然是一个争议性的技术，很少被使用。
二、 AlexNet代码
2.1 Introduction
完整的项目代码详见我的GitHub： 完整代码链接，完整的项目包含了自AelxNet以来经典的深度学习分类模型，大部分模型是基于卷积神经网络的，也有一部分是基于注意力机制的。 在项目目录中，模型的搭建代码在classic_models文件夹中；所有的模型训练代码是共用的，有三个版本：
- train_sample.py是最简单的实现，必须掌握，以下版本看个人能力和需求。
- train.py是升级版的实现，具体改进的地方见train.py脚本中的注释。
- train_distrubuted.py支持多gpu分布式训练。
最后，test.py是推理脚本，用于使用训练好的模型。dataload中是数据集加载代码；utils是封装的功能包，包括学习策略，训练和验证，分布式初始化，可视化等等。建议先学习掌握classic_models，train_sample.py和test.py这三部分。
2.2 Dataset And Project
本项目是使用python语言基于pytorch深度学习框架编写的。
默认的数据集是花朵数据集，此数据集包含五种不同种类的花朵图像，用于训练的图像有3306张，用于验证的图像有364张。下载链接如下：https://pan.baidu.com/s/1EhPMVLOQlLNN55ndrLbh4Q
提取码：7799 。
下载完成后，记得在训练和推理代码中，将数据集加载的路径修改成自己电脑中下载存储的路径。
数据集图像展示如下：
开启模型的训练只需要在IDE中执行train_sample.py脚本即可；或者在终端执行命令行python train_sample.py 训练的log打印示例如下：
将训练好的模型用于推理，给一张向日葵的图像，模型的输出结果示例结果如下：
2.3 基于pytorch的模型搭建代码
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.Conv2d(3, 96, kernel_size=11, stride=4, padding=2), # input[3, 224, 224] output[96, 55, 55]
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2), # output[96, 27, 27]
nn.Conv2d(96, 256, kernel_size=5, padding=2), # output[256, 27, 27]
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2), # output[256, 13, 13]
nn.Conv2d(256, 384, kernel_size=3, padding=1), # output[384, 13, 13]
nn.ReLU(inplace=True),
nn.Conv2d(384, 384, kernel_size=3, padding=1), # output[384, 13, 13]
nn.ReLU(inplace=True),
nn.Conv2d(384, 256, kernel_size=3, padding=1), # output[256, 13, 13]
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2), # output[256, 6, 6]
)
self.classifier = nn.Sequential(
nn.Dropout(p=0.5),
nn.Linear(256 * 6 * 6, 4096),
nn.ReLU(inplace=True),
nn.Dropout(p=0.5),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Linear(4096, num_classes),
)
if init_weights:
self._initialize_weights()
def forward(self, x):
x = self.features(x)
x = torch.flatten(x, start_dim=1)
x = self.classifier(x)
return x
def _initialize_weights(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)
def alexnet(num_classes):
model = AlexNet(num_classes=num_classes)
return model
2.4 基于pytorch的模型训练代码
完整的项目代码详见我的GitHub： 完整代码链接文章来源：https://www.toymoban.com/news/detail-480963.html
import os
import sys
import json
import torch
import torch.nn as nn
from torchvision import transforms, datasets
import torch.optim as optim
from tqdm import tqdm
from classic_models.alexnet import AlexNet
def main():
# 判断可用设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("using {} device.".format(device))
# 注意改成自己的数据集路径
data_path = 'D:\\Datasets\\flower'
assert os.path.exists(data_path), "{} path does not exist.".format(data_path)
# 数据预处理与增强
"""
ToTensor()能够把灰度范围从0-255变换到0-1之间的张量.
transform.Normalize()则把0-1变换到(-1,1). 具体地说, 对每个通道而言, Normalize执行以下操作: image=(image-mean)/std
其中mean和std分别通过(0.5,0.5,0.5)和(0.5,0.5,0.5)进行指定。原来的0-1最小值0则变成(0-0.5)/0.5=-1; 而最大值1则变成(1-0.5)/0.5=1.
也就是一个均值为0, 方差为1的正态分布. 这样的数据输入格式可以使神经网络更快收敛。
"""
data_transform = {
"train": transforms.Compose([transforms.Resize(224),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
"val": transforms.Compose([transforms.Resize((224, 224)), # val不需要任何数据增强
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
# 使用ImageFlolder加载数据集中的图像，并使用指定的预处理操作来处理图像， ImageFlolder会同时返回图像和对应的标签。 (image path, class_index) tuples
train_dataset = datasets.ImageFolder(root=os.path.join(data_path, "train"), transform=data_transform["train"])
validate_dataset = datasets.ImageFolder(root=os.path.join(data_path, "val"), transform=data_transform["val"])
train_num = len(train_dataset)
val_num = len(validate_dataset)
# 使用class_to_idx给类别一个index，作为训练时的标签： {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
flower_list = train_dataset.class_to_idx
# 创建一个字典，存储index和类别的对应关系，在模型推理阶段会用到。
cla_dict = dict((val, key) for key, val in flower_list.items())
# 将字典写成一个json文件
json_str = json.dumps(cla_dict, indent=4)
with open( os.path.join(data_path, 'class_indices.json') , 'w') as json_file:
json_file.write(json_str)
batch_size = 64 # batch_size大小，是超参，可调，如果模型跑不起来，尝试调小batch_size
num_workers = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8]) # 用于加载数据集的进程数量
print('Using {} dataloader workers every process'.format(num_workers))
# 使用 DataLoader 将 ImageFloder 加载的数据集处理成批量（batch）加载模式
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=4, shuffle=False, num_workers=num_workers) # 注意，验证集不需要shuffle
print("using {} images for training, {} images for validation.".format(train_num, val_num))
# 实例化模型，并送进设备
net = AlexNet(num_classes=5, init_weights=True)
net.to(device)
# 指定损失函数用于计算损失；指定优化器用于更新模型参数；指定训练迭代的轮数，训练权重的存储地址
loss_function = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.0002)
epochs = 70
save_path = os.path.abspath(os.path.join(os.getcwd(), './results/weights/alexnet'))
if not os.path.exists(save_path):
os.makedirs(save_path)
best_acc = 0.0 # 初始化验证集上最好的准确率，以便后面用该指标筛选模型最优参数。
for epoch in range(epochs):
############################################################## train ######################################################
net.train()
acc_num = torch.zeros(1).to(device) # 初始化，用于计算训练过程中预测正确的数量
sample_num = 0 # 初始化，用于记录当前迭代中，已经计算了多少个样本
# tqdm是一个进度条显示器，可以在终端打印出现在的训练进度
train_bar = tqdm(train_loader, file=sys.stdout, ncols=100)
for step, data in enumerate(train_bar):
images, labels = data
sample_num += images.shape[0]
optimizer.zero_grad()
outputs = net(images.to(device)) # output_shape: [batch_size, num_classes]
pred_class = torch.max(outputs, dim=1)[1] # torch.max 返回值是一个tuple，第一个元素是max值，第二个元素是max值的索引。
acc_num += torch.eq(pred_class, labels.to(device)).sum()
loss = loss_function(outputs, labels.to(device)) # 求损失
loss.backward() # 自动求导
optimizer.step() # 梯度下降
# print statistics
train_acc = acc_num.item() / sample_num
# .desc是进度条tqdm中的成员变量，作用是描述信息
train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1, epochs, loss)
# validate
net.eval()
acc_num = 0.0 # accumulate accurate number per epoch
with torch.no_grad():
for val_data in validate_loader:
val_images, val_labels = val_data
outputs = net(val_images.to(device))
predict_y = torch.max(outputs, dim=1)[1]
acc_num += torch.eq(predict_y, val_labels.to(device)).sum().item()
val_accurate = acc_num / val_num
print('[epoch %d] train_loss: %.3f train_acc: %.3f val_accuracy: %.3f' % (epoch + 1, loss, train_acc, val_accurate))
# 判断当前验证集的准确率是否是最大的，如果是，则更新之前保存的权重
if val_accurate > best_acc:
best_acc = val_accurate
torch.save(net.state_dict(), os.path.join(save_path, "AlexNet.pth") )
# 每次迭代后清空这些指标，重新计算
train_acc = 0.0
val_accurate = 0.0
print('Finished Training')
if __name__ == '__main__':
main()
2.5 基于pytorch的模型推理代码
import os
import json
import torch
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt
# 将创建AlexNet模型的python脚本导入进来
from classic_models.alexnet import AlexNet
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
data_transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# 加载一种图片用于推理
img_path = "/data/haowen_yu/code/dataset/flowers/val/daisy/3640845041_80a92c4205_n.jpg"
assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
img = Image.open(img_path)
plt.imshow(img)
# [N, C, H, W]
img = data_transform(img)
# 扩张一个batch维度，因为训练模型时使用的小批量随机梯度下降有batch维度，所以推理时也需要有
img = torch.unsqueeze(img, dim=0)
# 加载模型预测值与真实类别的对应关系，json文件详见我的github代码
json_path = '/data/haowen_yu/code/dataset/flowers/class_indices.json'
assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
json_file = open(json_path, "r")
class_indict = json.load(json_file)
# 实例化模型
model = AlexNet(num_classes=5).to(device)
# 加载模型的权重
weights_path = "/data/haowen_yu/code/results/weights/alexnet/AlexNet.pth"
assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
model.load_state_dict(torch.load(weights_path))
model.eval()
with torch.no_grad():
output = torch.squeeze(model(img.to(device))).cpu()
predict = torch.softmax(output, dim=0)
# 取分类可能性最大的类别作为模型的识别结果
predict_cla = torch.argmax(predict).numpy()
# 以图片的方式输出识别结果
print_res = "class: {} prob: {:.3}".format(class_indict[str(predict_cla)], predict[predict_cla].numpy())
plt.title(print_res)
for i in range(len(predict)):
print("class: {:10} prob: {:.3}".format(class_indict[str(i)], predict[i].numpy()))
plt.show()
if __name__ == '__main__':
main()
小结
AlexNet模型是一个开创性的卷积神经网络模型，该模型在ImageNet图像分类竞赛中获得了显著的优势，引起了深度学习技术的广泛关注，开启了人工智能的第三次浪潮：深度学习时代。
AlexNet模型共包含8层，其中前5层为卷积层（Convolutional Layer），后3层为全连接层（Fully Connected Layer）。在卷积层中，AlexNet采用了大量的卷积核（Filter），并且使用ReLU作为激活函数，可以加速网络的训练过程并提高分类准确率。此外，AlexNet在全连接层中使用了Dropout技术，可以有效减少过拟合现象。
另外，AlexNet采用还采用了如数据增强、局部响应归一化、并行计算等先进技术，使得其在当时的图像分类竞赛中表现出色。
总的来说，AlexNet为深度学习技术在计算机视觉领域的应用奠定了重要基础，并对深度学习的发展产生了深远的影响。文章来源地址https://www.toymoban.com/news/detail-480963.html
到了这里，关于基于卷积的图像分类识别（一）：AlexNet的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
