【炼丹侠】如何用GPU服务器实现AlexNet训练

AlexNet是一种深度卷积神经网络，由Alex Krizhevsky、Ilya Sutskever和Geoffrey Hinton于2012年提出。它是在ImageNet Large Scale Visual Recognition Challenge竞赛中取得突破性成果的模型，标志着深度学习在计算机视觉领域的崭露头角。
以下是AlexNet的一些主要特点和贡献：

深度架构：AlexNet是第一个引入多个卷积层和池化层的深度神经网络，共有8层变换层（5个卷积层和3个全连接层）。
ReLU激活函数：AlexNet采用了修正线性单元（Rectified Linear Unit，ReLU）作为激活函数，这对于训练深层神经网络具有重要意义，因为它能够有效地缓解梯度消失问题。
局部响应归一化（Local Response Normalization）：AlexNet引入了一种局部响应归一化层，目的是增强神经元的抑制效果，提高模型的泛化能力。
Dropout：为了减轻过拟合问题，AlexNet在全连接层引入了Dropout技术，即在训练过程中随机丢弃一些神经元，以促使网络更具鲁棒性。
数据增强：AlexNet在训练阶段采用了数据增强策略，如随机裁剪、水平翻转等。
并行计算：AlexNet在训练时利用了两块GPU进行并行计算，这在当时是一种创新，有助于加快训练速度。
在ImageNet竞赛中的成绩：AlexNet在2012年的ILSVRC竞赛中取得了惊人的成绩，将前一年获胜模型的错误率从25%降低到了约16%。

AlexNet的成功标志着深度学习在计算机视觉领域的复兴，其架构和训练技巧为后续更深层次的神经网络提供了基础和启发，也为深度学习的广泛应用奠定了基础。
本次训练采用炼丹侠平台A100服务器，对比了GPU版本的训练代码和CPU版本的训练代码，成功复现了AlexNet训练MNIST数据集，AlexNet训练完整代码如下：

GPU版本：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader

# 定义简化版的AlexNet模型
class AlexNet(nn.Module):
    def __init__(self, num_classes=10):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 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, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Linear(192 * 5 * 5, 256),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(256, 128),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(128, num_classes),
        )

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

# 数据预处理和加载器
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
])

train_dataset = MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# 初始化模型、损失函数和优化器，并将它们移动到GPU上
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = AlexNet(num_classes=10).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    running_loss = 0.0
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss / len(train_loader):.4f}')

print('Finished Training')

CPU版本：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader

# 定义简化版的AlexNet模型
class AlexNet(nn.Module):
    def __init__(self, num_classes=10):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 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, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Linear(192 * 5 * 5, 256),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(256, 128),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(128, num_classes),
        )

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

# 定义数据预处理和加载器
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
])

train_dataset = MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# 初始化模型、损失函数和优化器
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = AlexNet(num_classes=10).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    running_loss = 0.0
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss / len(train_loader):.4f}')

print('Finished Training')

训练过程如下：
https://www.bilibili.com/video/BV1Rp4y1P7Nt/?vd_source=64fad5...

总结：
在本次实验中，尝试了在不同硬件条件下同时训练AlexNet网络，分别使用了GPU和CPU。具体而言，使用了一台装备有A100 GPU的服务器，以及一台配备了一般性能的CPU的云服务器。

GPU版本：
在A100服务器上，将AlexNet网络配置在GPU上进行训练。由于A100是一款高性能的GPU，具有大量的CUDA核心和高速显存，它能够高效地进行深度神经网络的训练。这使得模型在训练过程中能够迅速地处理大量计算任务，从而缩短了训练时间。同时，A100的并行计算能力和优化算法使得模型收敛更快，加速了训练的整个过程。因此，GPU版本的AlexNet在性能和速度方面表现出色。
CPU版本：
在一般性能的CPU上，同样进行了AlexNet网络的训练。然而，由于CPU在处理并行计算时相对较弱，以及缺乏GPU的高速显存，模型训练的速度相对较慢。尤其是对于深度神经网络，CPU的训练时间会明显延长。虽然CPU版本的训练过程可能更加适合小规模的数据集和模型，但在大规模的图像分类任务中，它可能表现不佳。
GPU版本在性能和速度方面具备明显优势，而CPU版本在大规模任务中可能受限于计算能力和训练时间。

【炼丹侠】如何用GPU服务器实现AlexNet训练

你可能感兴趣的:(深度学习人工智能神经网络)