为何Google Colab的A100运行PyTorch代码比本地RTX3070慢？

我正在学习PyTorch，从书籍中获取了如下代码。该代码在本地Nvidia RTX3070上运行速度很快，每个epoch耗时3.6秒，但在Google Colab中选择A100运行时，每个epoch却耗时约7秒。请问这是什么原因？

import torch
from torch import nn, optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision import transforms

torch.manual_seed(1)
batch_size = 128 
learning_rate = 1e-2 
num_epoches = 10 

train_dataset = datasets.MNIST(
    root='./data', 
    train=True, 
    transform=transforms.ToTensor(), 
    download=True)  

test_dataset = datasets.MNIST(
    root='./data',
    train=False, 
    transform=transforms.ToTensor())

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=False, pin_memory=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, pin_memory=True)


class Cnn(nn.Module):
    def __init__(self, in_dim, n_class):  # 28x28x1
        super(Cnn, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_dim, 6, 3, stride=1, padding=1),  # 28 x28
            nn.ReLU(True),
            nn.MaxPool2d(2, 2),  # 14 x 14
            nn.Conv2d(6, 16, 5, stride=1, padding=0),  # 10 * 10*16
            nn.ReLU(True),
            nn.MaxPool2d(2, 2))  # 5x5x16

        self.fc = nn.Sequential(
            nn.Linear(400, n_class)) #120),  # 400 = 5 * 5 * 16
            #nn.Linear(120, 84),
            #nn.Linear(84, n_class))

    def forward(self, x):
        out = self.conv(x)
        out = out.view(out.size(0), 400)  # 400 = 5 * 5 * 16,
        out = self.fc(out)
        return out

model = Cnn(1, 10).to('cuda') 

print(model)

# loss和optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
import time
start = time.time()

for epoch in range(num_epoches):
    print('epoch {}'.format(epoch + 1))
    print('*' * 10)
    running_loss = 0.0
    running_acc = 0.0
    for i, data in enumerate(train_loader, 1):
        img, label = data
        img = Variable(img).to("cuda")
        label = Variable(label).to("cuda")
        out = model(img)
        loss = criterion(out, label)  # loss
        running_loss += loss.item() * label.size(0) 
        _, pred = torch.max(out, 1) 
        num_correct = (pred == label).sum() 
        # accuracy = (pred == label).float().mean()
        running_acc += num_correct.item() 
        optimizer.zero_grad() 
        loss.backward()
        optimizer.step()

    print('Train Finish {} epoch, Loss: {:.6f}, Acc: {:.6f}'.format(
        epoch + 1, running_loss / (len(train_dataset)), running_acc / (len(
            train_dataset))))
    print(f"took {time.time() - start}")
    start = time.time()


torch.save(model.state_dict(), './cnn.pth')

核心原因分析 #

• 模型计算量太小，大GPU优势无法发挥：你的MNIST卷积网络非常轻量，总计算量极小。A100这类数据中心级GPU的核心规模大，擅长处理大规模并行计算任务，小模型的计算量根本喂不满A100的算力，反而会被GPU启动、任务调度等固定开销拖累。而RTX3070的核心规模更适配这种小任务，调度成本更低，实际运行效率反而更高。

• Colab的A100资源并非独占：Colab提供的A100是共享式的虚拟GPU实例，多个用户可能共享同一物理卡的算力和带宽，实际能分配到的资源会打折扣。而本地RTX3070是完全独占使用，资源利用率能拉满。

• 数据传输路径差异：Colab的数据集存储在云端磁盘，数据从磁盘加载到GPU的路径更长，延迟更高；本地数据集在本地硬盘，数据加载速度更快，减少了GPU等待数据的时间。

• 环境配置差异：本地和Colab的PyTorch、CUDA版本可能不一致，不同版本对小模型的优化策略不同，部分版本在消费级GPU上对小卷积核的优化效果更好。

• 控制台同步开销：代码中每个epoch都有多次print输出，在Colab的云端环境中，控制台输出的同步延迟比本地更大，也会增加整体耗时。

优化建议 #

• 增大batch_size（比如调到512或1024），让GPU的计算单元得到充分利用，发挥A100的算力优势。
• 减少不必要的控制台输出，比如把epoch内的print去掉，只保留epoch结束的关键信息。
• 给DataLoader添加num_workers参数（比如设置为4或8），用多进程加载数据，缓解数据传输瓶颈。
• 检查Colab的PyTorch和CUDA版本，尽量和本地环境保持一致，避免版本差异带来的性能损耗。

内容的提问来源于stack exchange，提问作者packetie