训练

`import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

1. 数据加载与预处理（简化转换，加快加载）

transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

减少数据加载线程，降低开销

trainset = torchvision.datasets.CIFAR10(
root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(
trainset, batch_size=256, shuffle=True, num_workers=0) # num_workers=0减少线程开销

testset = torchvision.datasets.CIFAR10(
root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(
testset, batch_size=256, shuffle=False, num_workers=0)

classes = ('plane', 'car', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck')

2. 简化网络结构（减少层数和通道数）

class SimpleNet(nn.Module):
def init(self):
super(SimpleNet, self).init()
self.conv_layers = nn.Sequential(
nn.Conv2d(3, 16, 3, padding=1), # 减少通道数
nn.ReLU(),
nn.MaxPool2d(2, 2),
nn.Conv2d(16, 32, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2, 2)
)
self.fc_layers = nn.Sequential(
nn.Linear(32 * 8 * 8, 128), # 简化全连接层
nn.ReLU(),
nn.Linear(128, 10)
)

def forward(self, x):
    x = self.conv_layers(x)
    x = x.view(-1, 32 * 8 * 8)
    x = self.fc_layers(x)
    return x

3. 初始化模型与设备

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

4. 优化器与损失函数（调整学习率加速收敛）

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9) # SGD比Adam稍快

5. 减少训练轮次（从50轮减到10轮）

epochs = 10
for epoch in range(epochs):
running_loss = 0.0
net.train()
for i, data in enumerate(trainloader, 0):
inputs, labels = data[0].to(device), data[1].to(device)

    optimizer.zero_grad()
    outputs = net(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()
    
    running_loss += loss.item()
    # 每10个batch打印一次，减少输出开销
    if i % 10 == 9:
        print(f'[{epoch+1}, {i+1}] loss: {running_loss/10:.3f}')
        running_loss = 0.0

print('Finished Training')

6. 简化评估（只输出整体准确率）

correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data[0].to(device), data[1].to(device)
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()

print(f'Accuracy on 10000 test images: {100 * correct / total:.2f}%')`