da y54

1.对inception网络在cifar10上观察精度

 

Inception网络是一种经典的卷积神经网络架构，其核心特点是通过“ inception模块”组合不同尺寸的卷积核（如1x1、3x3、5x5）和池化操作，在提升特征提取能力的同时控制计算量。

在CIFAR-10数据集（含10类小尺寸图像）上，Inception网络的表现受具体版本和训练配置影响，测试精度通常在87% - 96%之间。例如，Inception-v3在该数据集上可达到约96.5%的精度，展现了其对小图像分类的有效性。

 

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader
 
# 检查设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")
 
# 数据预处理
transform = transforms.Compose([
    transforms.Resize((299, 299)),  # Inception 网络需要输入大小为 299x299
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 标准化到 [-1, 1]
])
 
# 加载 CIFAR-10 数据集
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
 
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
 
# 加载预训练的 Inception 网络
model = models.inception_v3(pretrained=True)
model.aux_logits = False  # 禁用辅助分类器
model.fc = nn.Linear(model.fc.in_features, 10)  # 修改最后一层为 CIFAR-10 的 10 类
model = model.to(device)
 
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-4)
 
# 训练函数
def train(model, train_loader, criterion, optimizer, device, epochs):
    model.train()
    for epoch in range(epochs):
        running_loss = 0.0
        correct = 0
        total = 0
        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()
            
            running_loss += loss.item()
            _, predicted = output.max(1)
            total += target.size(0)
            correct += predicted.eq(target).sum().item()
        
        epoch_loss = running_loss / len(train_loader)
        epoch_acc = 100. * correct / total
        print(f"Epoch [{epoch+1}/{epochs}] | Loss: {epoch_loss:.4f} | Accuracy: {epoch_acc:.2f}%")
 
# 测试函数
def test(model, test_loader, criterion, device):
    model.eval()
    test_loss = 0.0
    correct = 0
    total = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            loss = criterion(output, target)
            test_loss += loss.item()
            _, predicted = output.max(1)
            total += target.size(0)
            correct += predicted.eq(target).sum().item()
    
    avg_loss = test_loss / len(test_loader)
    accuracy = 100. * correct / total
    print(f"Test Loss: {avg_loss:.4f} | Test Accuracy: {accuracy:.2f}%")
    return accuracy
 
# 执行训练和测试
epochs = 10
print("开始训练 Inception 网络...")
train(model, train_loader, criterion, optimizer, device, epochs)
print("训练完成！开始测试...")
test_accuracy = test(model, test_loader, criterion, device)
print(f"最终测试准确率: {test_accuracy:.2f}%")