PyTorch CIFAR-100 图像分类：使用 ResNet-101 模型进行训练和验证

这段代码使用了 CIFAR-100 数据集进行训练和验证。在加载数据集时，使用了 'CIFAR100' 类来加载 CIFAR-100 数据集，并指定了相应的数据路径。

在数据预处理部分，使用了 'transforms.Normalize' 函数对图像数据进行归一化处理。'mean' 和 'std' 的值是根据 CIFAR-100 数据集的统计数据进行设置的。

模型的定义和训练过程与之前一样，使用了预训练的 ResNet-101 模型，并将最后一层全连接层替换为新的分类器。优化器使用 'Adam'，损失函数使用交叉熵损失。

训练过程中使用了 GPU 加速（如果可用），并且使用了学习率调度器来动态调整学习率。

每个 epoch 结束后，打印训练损失和验证准确率。

这段代码可以用于训练和验证 CIFAR-100 数据集上的分类模型。请确保将数据集路径替换为正确的路径，并根据需要进行适当的调整和修改。

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torchvision.datasets import ImageNet
from torch.utils.data import DataLoader
from torchvision.models import resnet101
from torchvision.datasets import CIFAR100


# 设置参数
#num_classes = 1000  # ImageNet数据集的类别数
num_classes = 100  # CIFAR-100数据集的类别数

batch_size = 32

# 数据预处理
data_transforms = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    #transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])
])


# 加载ImageNet数据集
#train_dataset = ImageNet(root='path/to/train_data', split='train', transform=data_transforms)
#val_dataset = ImageNet(root='path/to/val_data', split='val', transform=data_transforms)
# 加载CIFAR-100数据集
train_dataset = CIFAR100(root='path/to/train_data', train=True, download=True, transform=data_transforms)
val_dataset = CIFAR100(root='path/to/val_data', train=False, download=True, transform=data_transforms)


# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size)



# 加载预训练的ResNet-101模型
model = resnet101(pretrained=True)

# 将最后一层全连接层替换为新的分类器
model.fc = nn.Linear(model.fc.in_features, num_classes)

# 定义损失函数
criterion = nn.CrossEntropyLoss()


# 定义优化器
#optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
optimizer = optim.Adam(model.parameters(), lr=0.001)


# 定义学习率调度器
lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)


# 训练模型
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    #for images, labels in train_loader:
    for batch_idx, (images, labels) in enumerate(train_loader):
        images = images.to(device)
        labels = labels.to(device)

        optimizer.zero_grad()

        outputs = model(images)
        loss = criterion(outputs, labels)

        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    epoch_loss = running_loss / len(train_loader)

    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}")

    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        #for images, labels in val_loader:
        for batch_idx, (images, labels) in enumerate(val_loader):
            images = images.to(device)
            labels = labels.to(device)

            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)

            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    val_accuracy = 100 * correct / total
    print(f"Validation Accuracy: {val_accuracy:.2f}%")

    lr_scheduler.step()