第四十天打卡

@浙大疏锦行

训练和测试的规范写法

知识点回顾:

1.彩色和灰度图片测试和训练的规范写法:封装在函数中

2.展平操作:除第一个维度batchsize外全部展平

3.dropout操作:训练阶段随机丢弃神经元,测试阶段eval模式关闭dropout

python 复制代码
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from torchvision import transforms, datasets
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")
torch.manual_seed(42)
device = torch.device("cuda"if torch.cuda.is_available() else"cpu")
print(device)
 
python 复制代码
#1预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081,))
]
)
#2加载数据集
train_dataset = datasets.MNIST(
    root="./data",
    train=True,
    download=True,
    transform=transform
)
test_dataset = datasets.MNIST(
    root="./data",
    train=False,
    download=True,
    transform=transform
)
#3创建数据加载器
batch_size = 64
train_loader = torch.utils.data.DataLoader(
    dataset=train_dataset,
    batch_size=batch_size,
    shuffle=True
)
test_loader = torch.utils.data.DataLoader(
    dataset=test_dataset,
    batch_size=batch_size,
    shuffle=False
)
#4定义模型
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(28*28, 128)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.flatten(x)
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x
model = MLP()
model = model.to(device)
 
#定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
python 复制代码
#5训练模型(记录每个iteration的loss)
def train(model, train_loader, test_loader, criterion, optimizer, epochs, device):
    model.train() #设置为训练模式
 
    #记录损失
    all_iter_losses = []   #记录所有batch的loss
    iter_indices = [] #记录每个iteration的索引
 
    for epoch in range(epochs):
        running_loss = 0.0 #记录每个epoch的loss
        correct = 0 #记录每个epoch的correct
        total =0 #记录每个epoch的total
 
        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()
 
            #记录当前iteration的损失
            iter_loss = loss.item()
            all_iter_losses.append(iter_loss)
            iter_indices.append(epoch * len(train_loader) + batch_idx + 1)
 
            #统计准确率和损失
            running_loss += loss.item()
            #`_`来表示我们不关心第一个返回值(即最大值),只关心第二个返回值(即最大值的索引),这个索引就是模型预测的类别。
            _, predicted = torch.max(output.data, 1)
            total += target.size(0)
            correct += predicted.eq(target).sum().item()
 
            #每100个batch打印一次训练状态
            if (batch_idx + 1) % 100 == 0:
                print(f"Epoch:{epoch + 1}/{epochs}|Batch:{batch_idx + 1}/{len(train_loader)}",
                      f"|单batch损失:{iter_loss:.4f}|累计平均损失:{running_loss/(batch_idx + 1):.4f}|")
        
        #测试,打印结果
        epoch_train_loss = running_loss / len(train_loader)
        epoch_train_acc = 100. * correct / total
        epoch_test_loss, epoch_test_acc = test(model, test_loader, criterion,device)
        print(f"Epoch{epoch + 1}/{epochs}完成|训练准确率:{epoch_train_acc:.2f}|测试准确率:{epoch_test_acc:.2f}")
 
    #绘制所有iteration损失函数
    plot_iter_losses(all_iter_losses, iter_indices)
 
    return epoch_test_acc
 
python 复制代码
#6测试模型
def test(model, test_loader, criterion, device):
    model.eval() # 设置为评估模式
    test_loss = 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)
            test_loss += criterion(output, target).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
    return avg_loss, accuracy
python 复制代码
#7绘制损失曲线
def plot_iter_losses(losses, indices):
    plt.figure(figsize=(10, 5))
    plt.plot(indices, losses, 'b-', alpha=0.7, label='Iteration Loss')
    plt.xlabel('Iteration(Batch)序号')
    plt.ylabel('Loss')
    plt.title('Iteration Loss Curve')
    plt.legend()
    plt.grid(True)
    plt.tight_layout()
    plt.show()
python 复制代码
#8执行训练和测试(epochs=2 验证结果)
epochs = 2
print("开始训练")
final_accuracy = train(model, train_loader, test_loader, criterion, optimizer, epochs, device)
print(f"训练结束,最终准确率为{final_accuracy:.4f}")    
相关推荐
学无止境小袁同学4 小时前
Google ADK 学习指南
python·llm·agent·多agent·google adk·llmagent·agent cli
郝学胜-神的一滴5 小时前
Effective Python 条款35:用类封装替代生成器异常注入
开发语言·人工智能·python·金融·pandas·scikit-learn·matplotlib
塑料铲子5 小时前
你的 Skill 越多越蠢?Token 上下文爆炸的求生指南
机器学习·agent
LK_075 小时前
【力扣】142. 环形链表 II |Python
python·leetcode·链表
wuyk5555 小时前
Python办公自动化-第02讲-Excel文件认知与四大库选型
开发语言·python·excel
用户54817845909506 小时前
Java 与 Python 在大模型与智能体领域的选型
java·python
TsingtaoAI7 小时前
VeyForge:构建具身智能的AI 3D资产与Sim-to-Real数据引擎
人工智能·机器学习
yiangL_7 小时前
1、Python 输入输出实验|print 与 input 人机交互实践
开发语言·python·人机交互
高洁017 小时前
世界模型的因果内核:从预测表象到理解机制
人工智能·python·深度学习·transformer·迁移学习