AlexNet网络复现

1. 引言

在现代计算机视觉领域，深度学习已经成为了一个核心技术，其影响力远超过了传统的图像处理方法。但深度学习，特别是卷积神经网络（CNN）在计算机视觉的主导地位并不是从一开始就有的。在2012年之前，计算机视觉的许多任务都是由一系列手工设计的特征和浅层的机器学习模型完成的。

2012年，一个特殊的网络结构名为AlexNet在ImageNet Large Scale Visual Recognition Challenge（ILSVRC）上取得了出色的成果，这一结果震惊了整个计算机视觉和机器学习社区。AlexNet不仅在分类精度上大幅领先，更重要的是，它开启了一个全新的时代——深度学习的时代。

2. AlexNet背景与重要性

在深度学习成为主流之前，计算机视觉任务主要依赖于手工设计的特征，如SIFT、HOG等，与浅层机器学习模型相结合，如SVM。这些方法虽然在某些任务上有所成功，但总体上受限于其手工设计的特征提取和有限的模型容量。

为了推进计算机视觉的发展，ImageNet项目应运而生，这是一个包含数百万张标注图像的大型数据库。基于此，ImageNet Large Scale Visual Recognition Challenge（ILSVRC）被创建出来，旨在激励研究人员开发更好的图像分类方法。ILSVRC迅速成为了计算机视觉领域的标杆比赛。

2012年，由Alex Krizhevsky、Ilya Sutskever和Geoffrey Hinton合作设计的AlexNet在ILSVRC中大放异彩，它的错误率比第二名低了10%以上，这在当时是一个令人震惊的进步。它使用的深度卷积神经网络架构和其他创新技术，标志着深度学习在计算机视觉领域的崛起。

深度结构： 与之前的模型相比，AlexNet具有更深的网络结构，这使得它能够学习到更复杂的特征表示。
GPU计算： AlexNet的训练利用了GPU并行计算的优势，从而大大加速了深度网络的训练速度。
创新性技术： 如ReLU激活函数、Dropout等技术，都首次在这样的大规模图像任务中显示了其效果和价值。
启发后续研究： AlexNet的成功激励了更多的研究人员转向深度学习，导致了后续的VGG、GoogLeNet、ResNet等一系列网络的诞生。

3. 网络结构详解

在这里插入图片描述

3.1. 卷积层

卷积层是CNN中的核心部分，它通过卷积操作提取输入图像的特征。AlexNet包含多个卷积层，这些卷积层的过滤器数量和大小各异，以捕捉不同级别的特征。

滤波器 ：AlexNet使用了大小为11x11、5x5和3x3的滤波器。
步长与填充：初始的卷积层使用了较大的步长（如步长为4的11x11滤波器），这有助于减少网络的计算复杂性。

3.2. 激活函数: ReLU

ReLU（Rectified Linear Unit）在AlexNet中首次在大规模网络中获得了广泛应用，因为它帮助网络更快地收敛并减轻了梯度消失的问题。

特性：ReLU的定义为f(x) = max(0, x)，它是非线性的，但计算简单。
优势：相较于Sigmoid或Tanh激活函数，ReLU可以加速SGD的收敛速度。

3.3. 池化

池化层在CNN中用于降低特征的空间维度，从而减少计算量。同时，它还能增加特征的平移不变性。

类型：AlexNet主要使用最大池化。
池化窗口与步长：在AlexNet中，池化窗口为3x3，步长为2。

3.4 全连接层

AlexNet包含3个全连接层，它们用于将前面的特征图汇集到一起，为分类做最后的决策。

神经元数量：前两个全连接层包含4096个神经元，而最后一个全连接层（输出层）根据类别数量决定（在ImageNet挑战中为1000个类别）。

3.5 正则化：Dropout

Dropout是一种正则化技巧，它在训练期间随机“丢弃”神经元，从而防止网络过拟合。

位置：AlexNet在前两个全连接层之后应用了Dropout。
丢弃率：训练期间，每个神经元被丢弃的概率为0.5。

4. 主要特点与创新

4.1 深度结构

相较于其它前期的网络模型，AlexNet有着更深的层次结构，包括五个卷积层，接着是三个全连接层。这种深度结构允许网络学习更丰富和复杂的特征表示。

4.2 ReLU激活函数

之前的神经网络主要采用sigmoid或tanh作为激活函数。AlexNet采用ReLU作为其激活函数，这一简单的变动大大加速了网络的训练，并提高了模型的表现。

4.3 GPU并行计算

由于其深度结构，AlexNet的计算需求远超过当时的CPU能力。为了解决这个问题，设计者利用了两个GPU进行并行计算。这不仅大大加速了训练速度，而且开启了后续深度学习模型利用GPU进行训练的趋势。

4.4 局部响应归一化 (LRN)

虽然后续的研究表明LRN可能不是必要的，但在AlexNet中，作者介绍了局部响应归一化作为一种规范化技术，它在某种程度上模拟了生物神经元的侧抑制机制，有助于增强模型的泛化能力。

4.5 Dropout

为了防止这样一个大型网络过拟合，AlexNet引入了Dropout技术。通过随机关闭一部分神经元，Dropout可以在训练过程中有效地模拟集成学习，从而增强模型的泛化性。

4.6 大数据和数据增强

AlexNet在ImageNet上训练，该数据集包含超过1500万的高分辨率图像和1000个类别。此外，为了进一步扩充数据并提高模型的鲁棒性，设计者还采用了多种数据增强技术，如图像旋转、裁剪和翻转。

4.7 叠加的卷积层

与之前的网络设计不同，AlexNet在没有池化的情况下叠加了多个卷积层，这允许模型捕捉更为复杂的特征组合。

5. 实践：搭建AlexNet

5.1 model

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, 48, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            # 第二卷积层
            nn.Conv2d(48, 128, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            # 第三、四、五卷积层
            nn.Conv2d(128, 192, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 192, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )

        # 分类层
        self.classifier = nn.Sequential(
            # Dropout层可以减少过拟合
            nn.Dropout(p=0.5),
            # 全连接层
            nn.Linear(128 * 6 * 6, 2048),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(2048, 2048),
            nn.ReLU(inplace=True),
            nn.Linear(2048, 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)

5.2 train

import os
import sys
import json
import torch
import torch.nn as nn
from torchvision import transforms, datasets, utils
import torch.optim as optim
from tqdm import tqdm
from model import AlexNet

# 配置参数
BATCH_SIZE = 32
EPOCHS = 10
LR = 0.0002
SAVE_PATH = './AlexNet.pth'


def load_data(data_root):
    """
    加载数据集
    """
    data_transform = {
        "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
        "val": transforms.Compose([transforms.Resize((224, 224)),
                                   transforms.ToTensor(),
                                   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}

    train_dataset = datasets.ImageFolder(root=os.path.join(data_root, "train"), transform=data_transform["train"])
    validate_dataset = datasets.ImageFolder(root=os.path.join(data_root, "val"), transform=data_transform["val"])

    nw = min([os.cpu_count(), BATCH_SIZE if BATCH_SIZE > 1 else 0, 8])
    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=nw)
    validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=4, shuffle=False, num_workers=nw)

    return train_loader, validate_loader


def save_class_indices(dataset, save_path='class_indices.json'):
    """
    保存类别和对应的编码到json文件中
    """
    flower_list = dataset.class_to_idx
    cla_dict = dict((val, key) for key, val in flower_list.items())
    with open(save_path, 'w') as f:
        json.dump(cla_dict, f, indent=4)


def train_one_epoch(net, data_loader, optimizer, loss_function, device):
    """
    训练一个epoch
    """
    net.train()
    running_loss = 0.0
    for images, labels in tqdm(data_loader, file=sys.stdout):
        optimizer.zero_grad()
        outputs = net(images.to(device))
        loss = loss_function(outputs, labels.to(device))
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    return running_loss / len(data_loader)


def validate(net, data_loader, device):
    """
    验证模型
    """
    net.eval()
    acc = 0.0
    with torch.no_grad():
        for images, labels in tqdm(data_loader, file=sys.stdout):
            outputs = net(images.to(device))
            predict_y = torch.max(outputs, dim=1)[1]
            acc += torch.eq(predict_y, labels.to(device)).sum().item()
    return acc / len(data_loader.dataset)


def main():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print(f"Using {device} device.")

    data_root = os.path.abspath(os.path.join(os.getcwd(), "./.."))
    image_path = os.path.join(data_root, "data_set", "flower_data")
    assert os.path.exists(image_path), f"{image_path} path does not exist."

    train_loader, validate_loader = load_data(image_path)
    save_class_indices(train_loader.dataset)

    print(
        f"Using {len(train_loader.dataset)} images for training, {len(validate_loader.dataset)} images for validation.")

    net = AlexNet(num_classes=5, init_weights=True).to(device)
    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.parameters(), lr=LR)

    best_acc = 0.0
    for epoch in range(EPOCHS):
        train_loss = train_one_epoch(net, train_loader, optimizer, loss_function, device)
        val_acc = validate(net, validate_loader, device)

        if val_acc > best_acc:
            best_acc = val_acc
            torch.save(net.state_dict(), SAVE_PATH)

        print(f"Epoch {epoch + 1}/{EPOCHS} - Train loss: {train_loss:.4f} - Val Accuracy: {val_acc:.4f}")

    print('Finished Training')


if __name__ == '__main__':
    main()

5.3 predict

import os
import json
import argparse

import torch
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt

from model import AlexNet

# 定义命令行参数解析函数
def parse_args():
    parser = argparse.ArgumentParser(description="预测输入图片的分类")
    parser.add_argument("img_path", help="待预测图片的路径")
    parser.add_argument("--model_path", default="./AlexNet.pth", help="已训练的AlexNet模型的路径")
    parser.add_argument("--class_indices", default="./class_indices.json", help="类别索引的json文件路径")
    return parser.parse_args()

# 加载和预处理图片
def load_image(img_path, transform):
    img = Image.open(img_path)
    img = transform(img)
    return torch.unsqueeze(img, dim=0)

# 加载模型
def load_model(model_path, device, num_classes=5):
    model = AlexNet(num_classes=num_classes).to(device)
    model.load_state_dict(torch.load(model_path))
    return model

# 使用模型进行预测
def predict_image(img, model, class_indict, device):
    model.eval()
    with torch.no_grad():
        output = torch.squeeze(model(img.to(device))).cpu()
        probabilities = torch.softmax(output, dim=0)
        predicted_class = torch.argmax(probabilities).numpy()
    return predicted_class, probabilities

def main():
    args = parse_args()  # 解析命令行参数

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

    # 定义图片预处理操作
    transform = transforms.Compose(
        [transforms.Resize((224, 224)),
         transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

    img = load_image(args.img_path, transform)  # 加载图片

    # 从json文件中读取类别索引
    with open(args.class_indices, "r") as f:
        class_indict = json.load(f)

    model = load_model(args.model_path, device)  # 加载模型

    # 使用模型预测图片
    predicted_class, probabilities = predict_image(img, model, class_indict, device)

    print("预测类别: {}   概率: {:.3}".format(class_indict[str(predicted_class)],
                                         probabilities[predicted_class].numpy()))

    # 打印所有类别的预测概率
    for i in range(len(probabilities)):
        print("类别: {:10}   概率: {:.3}".format(class_indict[str(i)],
                                             probabilities[i].numpy()))
    plt.imshow(Image.open(args.img_path))  # 显示图片
    plt.title("预测结果: {}".format(class_indict[str(predicted_class)]))
    plt.show()

if __name__ == '__main__':
    main()