5090laptop CUDA GPU算力入门指南：从环境配置到首个深度学习模型

1次阅读

共计 3609 个字符，预计需要花费 10 分钟才能阅读完成。

5090laptop 搭载的 NVIDIA GPU 基于最新的 Ampere 架构，相比前代产品，其 CUDA 核心数量大幅增加，同时采用了更先进的显存技术（如 GDDR6X），提供了更高的带宽。这些特性使得 5090laptop 特别适合深度学习任务：

CUDA 核心 ：5090laptop 拥有超过 5000 个 CUDA 核心，可以并行处理大量计算任务
Tensor Core：支持混合精度计算，大幅提升矩阵运算效率
显存容量 ：16GB GDDR6X 显存，可以容纳更大的模型和 batch size

首先需要确保系统已安装最新版 NVIDIA 驱动。可以通过以下命令检查驱动版本：

nvidia-smi

如果未安装驱动，可以从 NVIDIA 官网下载对应版本的驱动包。5090laptop 建议使用 515.x 或更高版本的驱动。

CUDA Toolkit 是使用 GPU 进行计算的基础工具包。对于 5090laptop，建议安装 CUDA 11.7 或更高版本：

wget https://developer.download.nvidia.com/compute/cuda/11.7.1/local_installers/cuda_11.7.1_515.65.01_linux.run
sudo sh cuda_11.7.1_515.65.01_linux.run

安装完成后，将 CUDA 路径加入环境变量：

export PATH=/usr/local/cuda-11.7/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda-11.7/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

cuDNN 是 NVIDIA 提供的深度学习加速库。下载对应 CUDA 版本的 cuDNN 后，执行：

tar -xzvf cudnn-linux-x86_64-8.5.0.96_cuda11-archive.tar.xz
sudo cp cuda/include/cudnn*.h /usr/local/cuda/include
sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64
sudo chmod a+r /usr/local/cuda/include/cudnn*.h /usr/local/cuda/lib64/libcudnn*

pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu117

CUDA 核心 ：GPU 中的基本计算单元，负责执行并行计算任务
流处理器 ：组织 CUDA 核心的架构单元，影响并行计算效率
显存带宽 ：GPU 与显存之间的数据传输速率，直接影响大数据量处理的性能

下面是一个完整的 MNIST 分类示例，展示如何使用 5090laptop 的 GPU 加速训练：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 检查 GPU 是否可用
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# 数据预处理
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 加载数据集
train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, transform=transform)

train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000, shuffle=False)

# 定义简单 CNN 模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = torch.relu(torch.max_pool2d(self.conv1(x), 2))
        x = torch.relu(torch.max_pool2d(self.conv2(x), 2))
        x = x.view(-1, 320)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return torch.log_softmax(x, dim=1)

model = Net().to(device)
criterion = nn.NLLLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

# 训练函数
def train(epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

# 测试函数
def test():
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += criterion(output, target).item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    print(f'Test set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({100. * correct / len(test_loader.dataset):.0f}%)')

# 训练并测试
for epoch in range(1, 10):
    train(epoch)
    test()