通道注意力

news2025/6/8 4:28:54

一、 什么是注意力

其中注意力机制是一种让模型学会「选择性关注重要信息」的特征提取器,就像人类视觉会自动忽略背景,聚焦于图片中的主体(如猫、汽车)。 transformer中的叫做自注意力机制,他是一种自己学习自己的机制,他可以自动学习到图片中的主体,并忽略背景。我们现在说的很多模块,比如通道注意力、空间注意力、通道注意力等等,都是基于自注意力机制的。

从数学角度看,注意力机制是对输入特征进行加权求和,输出=∑(输入特征×注意力权重),其中注意力权重是学习到的。所以他和卷积很像,因为卷积也是一种加权求和。但是卷积是 “固定权重” 的特征提取(如 3x3 卷积核)--训练完了就结束了,注意力是 “动态权重” 的特征提取(权重随输入数据变化)---输入数据不同权重不同。

问:为什么需要多种注意力模块? 答:因为不同场景下的关键信息分布不同。例如,识别鸟类和飞机时,需关注 “羽毛纹理”“金属光泽” 等特定通道的特征,通道注意力可强化关键通道;而物体位置不确定时(如猫出现在图像不同位置),空间注意力能聚焦物体所在区域,忽略背景。复杂场景中,可能需要同时关注通道和空间(如混合注意力模块 CBAM),或处理长距离依赖(如全局注意力模块 Non-local)。

问:为什么不设计一个‘万能’注意力模块? 答:主要受效率和灵活性限制。专用模块针对特定需求优化计算,成本更低(如通道注意力仅需处理通道维度,无需全局位置计算);不同任务的核心需求差异大(如医学图像侧重空间定位,自然语言处理侧重语义长距离依赖),通用模块可能冗余或低效。每个模块新增的权重会增加模型参数量,若训练数据不足或优化不当,可能引发过拟合。因此实际应用中需结合轻量化设计(如减少全连接层参数)、正则化(如 Dropout)或结构约束(如共享注意力权重)来平衡性能与复杂度。

通道注意力(Channel Attention)属于注意力机制(Attention Mechanism)的变体,而非自注意力(Self-Attention)的直接变体。可以理解为注意力是一个动物园算法,里面很多个物种,自注意力只是一个分支,因为开创了transformer所以备受瞩目。我们今天的内容用通道注意力举例

常见注意力模块的归类如下

注意力模块所属类别核心功能
自注意力(Self-Attention)自注意力变体建模同一输入内部元素的依赖(如序列位置、图像块)
通道注意力(Channel Attention)普通注意力变体(全局上下文)建模特征图通道间的重要性,通过全局池化压缩空间信息
空间注意力(Spatial Attention)普通注意力变体(全局上下文)建模特征图空间位置的重要性,关注“哪里”更重要
多头注意力(Multi-Head Attention)自注意力/普通注意力的增强版将query/key/value投影到多个子空间,捕捉多维度依赖
编码器-解码器注意力(Encoder-Decoder Attention)普通注意力变体建模编码器输出与解码器输入的跨模态交互(如机器翻译中句子与译文的对齐)

二、 特征图的提取

2.1 简单CNN的训练

昨天我已经介绍了cnn,为了好演示,我就重新训练了之前的cnn代码,你可以直接加载之前保存好的权重试试,一般重新训练1-2轮就会恢复效果。


import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np

# 设置中文字体支持
plt.rcParams["font.family"] = ["SimHei"]
plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题

# 检查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")

# 1. 数据预处理
# 训练集:使用多种数据增强方法提高模型泛化能力
train_transform = transforms.Compose([
    # 随机裁剪图像,从原图中随机截取32x32大小的区域
    transforms.RandomCrop(32, padding=4),
    # 随机水平翻转图像(概率0.5)
    transforms.RandomHorizontalFlip(),
    # 随机颜色抖动:亮度、对比度、饱和度和色调随机变化
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
    # 随机旋转图像(最大角度15度)
    transforms.RandomRotation(15),
    # 将PIL图像或numpy数组转换为张量
    transforms.ToTensor(),
    # 标准化处理:每个通道的均值和标准差,使数据分布更合理
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

# 测试集:仅进行必要的标准化,保持数据原始特性,标准化不损失数据信息,可还原
test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

# 2. 加载CIFAR-10数据集
train_dataset = datasets.CIFAR10(
    root='./data',
    train=True,
    download=True,
    transform=train_transform  # 使用增强后的预处理
)

test_dataset = datasets.CIFAR10(
    root='./data',
    train=False,
    transform=test_transform  # 测试集不使用增强
)

# 3. 创建数据加载器
batch_size = 64
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
# 4. 定义CNN模型的定义(替代原MLP)
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()  # 继承父类初始化
        
        # ---------------------- 第一个卷积块 ----------------------
        # 卷积层1:输入3通道(RGB),输出32个特征图,卷积核3x3,边缘填充1像素
        self.conv1 = nn.Conv2d(
            in_channels=3,       # 输入通道数(图像的RGB通道)
            out_channels=32,     # 输出通道数(生成32个新特征图)
            kernel_size=3,       # 卷积核尺寸(3x3像素)
            padding=1            # 边缘填充1像素,保持输出尺寸与输入相同
        )
        # 批量归一化层:对32个输出通道进行归一化,加速训练
        self.bn1 = nn.BatchNorm2d(num_features=32)
        # ReLU激活函数:引入非线性,公式:max(0, x)
        self.relu1 = nn.ReLU()
        # 最大池化层:窗口2x2,步长2,特征图尺寸减半(32x32→16x16)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)  # stride默认等于kernel_size
        
        # ---------------------- 第二个卷积块 ----------------------
        # 卷积层2:输入32通道(来自conv1的输出),输出64通道
        self.conv2 = nn.Conv2d(
            in_channels=32,      # 输入通道数(前一层的输出通道数)
            out_channels=64,     # 输出通道数(特征图数量翻倍)
            kernel_size=3,       # 卷积核尺寸不变
            padding=1            # 保持尺寸:16x16→16x16(卷积后)→8x8(池化后)
        )
        self.bn2 = nn.BatchNorm2d(num_features=64)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2)  # 尺寸减半:16x16→8x8
        
        # ---------------------- 第三个卷积块 ----------------------
        # 卷积层3:输入64通道,输出128通道
        self.conv3 = nn.Conv2d(
            in_channels=64,      # 输入通道数(前一层的输出通道数)
            out_channels=128,    # 输出通道数(特征图数量再次翻倍)
            kernel_size=3,
            padding=1            # 保持尺寸:8x8→8x8(卷积后)→4x4(池化后)
        )
        self.bn3 = nn.BatchNorm2d(num_features=128)
        self.relu3 = nn.ReLU()  # 复用激活函数对象(节省内存)
        self.pool3 = nn.MaxPool2d(kernel_size=2)  # 尺寸减半:8x8→4x4
        
        # ---------------------- 全连接层(分类器) ----------------------
        # 计算展平后的特征维度:128通道 × 4x4尺寸 = 128×16=2048维
        self.fc1 = nn.Linear(
            in_features=128 * 4 * 4,  # 输入维度(卷积层输出的特征数)
            out_features=512          # 输出维度(隐藏层神经元数)
        )
        # Dropout层:训练时随机丢弃50%神经元,防止过拟合
        self.dropout = nn.Dropout(p=0.5)
        # 输出层:将512维特征映射到10个类别(CIFAR-10的类别数)
        self.fc2 = nn.Linear(in_features=512, out_features=10)

    def forward(self, x):
        # 输入尺寸:[batch_size, 3, 32, 32](batch_size=批量大小,3=通道数,32x32=图像尺寸)
        
        # ---------- 卷积块1处理 ----------
        x = self.conv1(x)       # 卷积后尺寸:[batch_size, 32, 32, 32](padding=1保持尺寸)
        x = self.bn1(x)         # 批量归一化,不改变尺寸
        x = self.relu1(x)       # 激活函数,不改变尺寸
        x = self.pool1(x)       # 池化后尺寸:[batch_size, 32, 16, 16](32→16是因为池化窗口2x2)
        
        # ---------- 卷积块2处理 ----------
        x = self.conv2(x)       # 卷积后尺寸:[batch_size, 64, 16, 16](padding=1保持尺寸)
        x = self.bn2(x)
        x = self.relu2(x)
        x = self.pool2(x)       # 池化后尺寸:[batch_size, 64, 8, 8]
        
        # ---------- 卷积块3处理 ----------
        x = self.conv3(x)       # 卷积后尺寸:[batch_size, 128, 8, 8](padding=1保持尺寸)
        x = self.bn3(x)
        x = self.relu3(x)
        x = self.pool3(x)       # 池化后尺寸:[batch_size, 128, 4, 4]
        
        # ---------- 展平与全连接层 ----------
        # 将多维特征图展平为一维向量:[batch_size, 128*4*4] = [batch_size, 2048]
        x = x.view(-1, 128 * 4 * 4)  # -1自动计算批量维度,保持批量大小不变
        
        x = self.fc1(x)           # 全连接层:2048→512,尺寸变为[batch_size, 512]
        x = self.relu3(x)         # 激活函数(复用relu3,与卷积块3共用)
        x = self.dropout(x)       # Dropout随机丢弃神经元,不改变尺寸
        x = self.fc2(x)           # 全连接层:512→10,尺寸变为[batch_size, 10](未激活,直接输出logits)
        
        return x  # 输出未经过Softmax的logits,适用于交叉熵损失函数



# 初始化模型
model = CNN()
model = model.to(device)  # 将模型移至GPU(如果可用)

criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器

# 引入学习率调度器,在训练过程中动态调整学习率--训练初期使用较大的 LR 快速降低损失,训练后期使用较小的 LR 更精细地逼近全局最优解。
# 在每个 epoch 结束后,需要手动调用调度器来更新学习率,可以在训练过程中调用 scheduler.step()
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
    optimizer,        # 指定要控制的优化器(这里是Adam)
    mode='min',       # 监测的指标是"最小化"(如损失函数)
    patience=3,       # 如果连续3个epoch指标没有改善,才降低LR
    factor=0.5        # 降低LR的比例(新LR = 旧LR × 0.5)
)
# 5. 训练模型(记录每个 iteration 的损失)
def train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs):
    model.train()  # 设置为训练模式
    
    # 记录每个 iteration 的损失
    all_iter_losses = []  # 存储所有 batch 的损失
    iter_indices = []     # 存储 iteration 序号
    
    # 记录每个 epoch 的准确率和损失
    train_acc_history = []
    test_acc_history = []
    train_loss_history = []
    test_loss_history = []
    
    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)  # 移至GPU
            
            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 += iter_loss
            _, predicted = output.max(1)
            total += target.size(0)
            correct += predicted.eq(target).sum().item()
            
            # 每100个批次打印一次训练信息
            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的平均训练损失和准确率
        epoch_train_loss = running_loss / len(train_loader)
        epoch_train_acc = 100. * correct / total
        train_acc_history.append(epoch_train_acc)
        train_loss_history.append(epoch_train_loss)
        
        # 测试阶段
        model.eval()  # 设置为评估模式
        test_loss = 0
        correct_test = 0
        total_test = 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_test += target.size(0)
                correct_test += predicted.eq(target).sum().item()
        
        epoch_test_loss = test_loss / len(test_loader)
        epoch_test_acc = 100. * correct_test / total_test
        test_acc_history.append(epoch_test_acc)
        test_loss_history.append(epoch_test_loss)
        
        # 更新学习率调度器
        scheduler.step(epoch_test_loss)
        
        print(f'Epoch {epoch+1}/{epochs} 完成 | 训练准确率: {epoch_train_acc:.2f}% | 测试准确率: {epoch_test_acc:.2f}%')
    
    # 绘制所有 iteration 的损失曲线
    plot_iter_losses(all_iter_losses, iter_indices)
    
    # 绘制每个 epoch 的准确率和损失曲线
    plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)
    
    return epoch_test_acc  # 返回最终测试准确率

# 6. 绘制每个 iteration 的损失曲线
def plot_iter_losses(losses, indices):
    plt.figure(figsize=(10, 4))
    plt.plot(indices, losses, 'b-', alpha=0.7, label='Iteration Loss')
    plt.xlabel('Iteration(Batch序号)')
    plt.ylabel('损失值')
    plt.title('每个 Iteration 的训练损失')
    plt.legend()
    plt.grid(True)
    plt.tight_layout()
    plt.show()

# 7. 绘制每个 epoch 的准确率和损失曲线
def plot_epoch_metrics(train_acc, test_acc, train_loss, test_loss):
    epochs = range(1, len(train_acc) + 1)
    
    plt.figure(figsize=(12, 4))
    
    # 绘制准确率曲线
    plt.subplot(1, 2, 1)
    plt.plot(epochs, train_acc, 'b-', label='训练准确率')
    plt.plot(epochs, test_acc, 'r-', label='测试准确率')
    plt.xlabel('Epoch')
    plt.ylabel('准确率 (%)')
    plt.title('训练和测试准确率')
    plt.legend()
    plt.grid(True)
    
    # 绘制损失曲线
    plt.subplot(1, 2, 2)
    plt.plot(epochs, train_loss, 'b-', label='训练损失')
    plt.plot(epochs, test_loss, 'r-', label='测试损失')
    plt.xlabel('Epoch')
    plt.ylabel('损失值')
    plt.title('训练和测试损失')
    plt.legend()
    plt.grid(True)
    
    plt.tight_layout()
    plt.show()

# 8. 执行训练和测试
epochs = 50  # 增加训练轮次为了确保收敛
print("开始使用CNN训练模型...")
final_accuracy = train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs)
print(f"训练完成!最终测试准确率: {final_accuracy:.2f}%")

# # 保存模型
# torch.save(model.state_dict(), 'cifar10_cnn_model.pth')
# print("模型已保存为: cifar10_cnn_model.pth")
使用设备: cuda
Files already downloaded and verified
开始使用CNN训练模型...
Epoch: 1/50 | Batch: 100/782 | 单Batch损失: 1.8418 | 累计平均损失: 2.0633
Epoch: 1/50 | Batch: 200/782 | 单Batch损失: 1.7869 | 累计平均损失: 1.9262
Epoch: 1/50 | Batch: 300/782 | 单Batch损失: 1.6917 | 累计平均损失: 1.8580
Epoch: 1/50 | Batch: 400/782 | 单Batch损失: 1.5382 | 累计平均损失: 1.8069
Epoch: 1/50 | Batch: 500/782 | 单Batch损失: 1.6528 | 累计平均损失: 1.7666
Epoch: 1/50 | Batch: 600/782 | 单Batch损失: 1.6119 | 累计平均损失: 1.7309
Epoch: 1/50 | Batch: 700/782 | 单Batch损失: 1.4111 | 累计平均损失: 1.7027
Epoch 1/50 完成 | 训练准确率: 37.96% | 测试准确率: 54.66%
Epoch: 2/50 | Batch: 100/782 | 单Batch损失: 1.5224 | 累计平均损失: 1.4354
Epoch: 2/50 | Batch: 200/782 | 单Batch损失: 1.2684 | 累计平均损失: 1.3797
Epoch: 2/50 | Batch: 300/782 | 单Batch损失: 1.1981 | 累计平均损失: 1.3445
Epoch: 2/50 | Batch: 400/782 | 单Batch损失: 1.0925 | 累计平均损失: 1.3228
Epoch: 2/50 | Batch: 500/782 | 单Batch损失: 1.1819 | 累计平均损失: 1.3026
Epoch: 2/50 | Batch: 600/782 | 单Batch损失: 1.0772 | 累计平均损失: 1.2862
Epoch: 2/50 | Batch: 700/782 | 单Batch损失: 1.1180 | 累计平均损失: 1.2751
Epoch 2/50 完成 | 训练准确率: 54.24% | 测试准确率: 65.47%
Epoch: 3/50 | Batch: 100/782 | 单Batch损失: 0.9923 | 累计平均损失: 1.1406
Epoch: 3/50 | Batch: 200/782 | 单Batch损失: 0.9376 | 累计平均损失: 1.1259
Epoch: 3/50 | Batch: 300/782 | 单Batch损失: 1.1565 | 累计平均损失: 1.1174
Epoch: 3/50 | Batch: 400/782 | 单Batch损失: 1.1627 | 累计平均损失: 1.1083
Epoch: 3/50 | Batch: 500/782 | 单Batch损失: 0.8502 | 累计平均损失: 1.0963
Epoch: 3/50 | Batch: 600/782 | 单Batch损失: 0.8603 | 累计平均损失: 1.0881
Epoch: 3/50 | Batch: 700/782 | 单Batch损失: 0.8372 | 累计平均损失: 1.0810
Epoch 3/50 完成 | 训练准确率: 61.66% | 测试准确率: 67.65%
Epoch: 4/50 | Batch: 100/782 | 单Batch损失: 1.2020 | 累计平均损失: 1.0277
Epoch: 4/50 | Batch: 200/782 | 单Batch损失: 1.0292 | 累计平均损失: 1.0015
Epoch: 4/50 | Batch: 300/782 | 单Batch损失: 1.0506 | 累计平均损失: 1.0037
Epoch: 4/50 | Batch: 400/782 | 单Batch损失: 0.9430 | 累计平均损失: 1.0024
Epoch: 4/50 | Batch: 500/782 | 单Batch损失: 0.8181 | 累计平均损失: 0.9930
Epoch: 4/50 | Batch: 600/782 | 单Batch损失: 1.2464 | 累计平均损失: 0.9904
Epoch: 4/50 | Batch: 700/782 | 单Batch损失: 1.1116 | 累计平均损失: 0.9866
Epoch 4/50 完成 | 训练准确率: 65.13% | 测试准确率: 72.93%
Epoch: 5/50 | Batch: 100/782 | 单Batch损失: 1.0370 | 累计平均损失: 0.9427
Epoch: 5/50 | Batch: 200/782 | 单Batch损失: 1.0565 | 累计平均损失: 0.9345
Epoch: 5/50 | Batch: 300/782 | 单Batch损失: 1.0973 | 累计平均损失: 0.9271
Epoch: 5/50 | Batch: 400/782 | 单Batch损失: 0.8626 | 累计平均损失: 0.9227
Epoch: 5/50 | Batch: 500/782 | 单Batch损失: 0.9663 | 累计平均损失: 0.9213
Epoch: 5/50 | Batch: 600/782 | 单Batch损失: 0.9310 | 累计平均损失: 0.9219
Epoch: 5/50 | Batch: 700/782 | 单Batch损失: 0.7662 | 累计平均损失: 0.9193
Epoch 5/50 完成 | 训练准确率: 67.69% | 测试准确率: 74.27%
Epoch: 6/50 | Batch: 100/782 | 单Batch损失: 1.1025 | 累计平均损失: 0.8677
Epoch: 6/50 | Batch: 200/782 | 单Batch损失: 1.1822 | 累计平均损失: 0.8692
Epoch: 6/50 | Batch: 300/782 | 单Batch损失: 0.9385 | 累计平均损失: 0.8784
Epoch: 6/50 | Batch: 400/782 | 单Batch损失: 0.6965 | 累计平均损失: 0.8775
Epoch: 6/50 | Batch: 500/782 | 单Batch损失: 0.9782 | 累计平均损失: 0.8734
Epoch: 6/50 | Batch: 600/782 | 单Batch损失: 0.8641 | 累计平均损失: 0.8726
Epoch: 6/50 | Batch: 700/782 | 单Batch损失: 0.8398 | 累计平均损失: 0.8706
Epoch 6/50 完成 | 训练准确率: 69.38% | 测试准确率: 73.62%
Epoch: 7/50 | Batch: 100/782 | 单Batch损失: 0.6919 | 累计平均损失: 0.8211
Epoch: 7/50 | Batch: 200/782 | 单Batch损失: 0.7010 | 累计平均损失: 0.8308
Epoch: 7/50 | Batch: 300/782 | 单Batch损失: 0.9141 | 累计平均损失: 0.8392
Epoch: 7/50 | Batch: 400/782 | 单Batch损失: 0.6119 | 累计平均损失: 0.8343
Epoch: 7/50 | Batch: 500/782 | 单Batch损失: 0.5899 | 累计平均损失: 0.8375
Epoch: 7/50 | Batch: 600/782 | 单Batch损失: 1.0044 | 累计平均损失: 0.8458
Epoch: 7/50 | Batch: 700/782 | 单Batch损失: 0.9319 | 累计平均损失: 0.8458
Epoch 7/50 完成 | 训练准确率: 70.37% | 测试准确率: 75.49%
Epoch: 8/50 | Batch: 100/782 | 单Batch损失: 0.7293 | 累计平均损失: 0.8088
Epoch: 8/50 | Batch: 200/782 | 单Batch损失: 0.7917 | 累计平均损失: 0.8152
Epoch: 8/50 | Batch: 300/782 | 单Batch损失: 0.6977 | 累计平均损失: 0.8098
Epoch: 8/50 | Batch: 400/782 | 单Batch损失: 0.9655 | 累计平均损失: 0.8146
Epoch: 8/50 | Batch: 500/782 | 单Batch损失: 1.0427 | 累计平均损失: 0.8121
Epoch: 8/50 | Batch: 600/782 | 单Batch损失: 0.6416 | 累计平均损失: 0.8118
Epoch: 8/50 | Batch: 700/782 | 单Batch损失: 0.9588 | 累计平均损失: 0.8093
Epoch 8/50 完成 | 训练准确率: 71.74% | 测试准确率: 76.22%
Epoch: 9/50 | Batch: 100/782 | 单Batch损失: 0.8117 | 累计平均损失: 0.7942
Epoch: 9/50 | Batch: 200/782 | 单Batch损失: 0.8120 | 累计平均损失: 0.7931
Epoch: 9/50 | Batch: 300/782 | 单Batch损失: 1.0682 | 累计平均损失: 0.7933
Epoch: 9/50 | Batch: 400/782 | 单Batch损失: 0.6669 | 累计平均损失: 0.7909
Epoch: 9/50 | Batch: 500/782 | 单Batch损失: 0.9293 | 累计平均损失: 0.7882
Epoch: 9/50 | Batch: 600/782 | 单Batch损失: 0.5955 | 累计平均损失: 0.7898
Epoch: 9/50 | Batch: 700/782 | 单Batch损失: 0.8499 | 累计平均损失: 0.7878
Epoch 9/50 完成 | 训练准确率: 72.41% | 测试准确率: 76.22%
Epoch: 10/50 | Batch: 100/782 | 单Batch损失: 0.7203 | 累计平均损失: 0.7612
Epoch: 10/50 | Batch: 200/782 | 单Batch损失: 0.9056 | 累计平均损失: 0.7590
Epoch: 10/50 | Batch: 300/782 | 单Batch损失: 0.6006 | 累计平均损失: 0.7628
Epoch: 10/50 | Batch: 400/782 | 单Batch损失: 0.9644 | 累计平均损失: 0.7619
Epoch: 10/50 | Batch: 500/782 | 单Batch损失: 0.6436 | 累计平均损失: 0.7614
Epoch: 10/50 | Batch: 600/782 | 单Batch损失: 0.7865 | 累计平均损失: 0.7619
Epoch: 10/50 | Batch: 700/782 | 单Batch损失: 0.6209 | 累计平均损失: 0.7631
Epoch 10/50 完成 | 训练准确率: 73.14% | 测试准确率: 77.99%
Epoch: 11/50 | Batch: 100/782 | 单Batch损失: 0.9361 | 累计平均损失: 0.7520
Epoch: 11/50 | Batch: 200/782 | 单Batch损失: 0.6575 | 累计平均损失: 0.7565
Epoch: 11/50 | Batch: 300/782 | 单Batch损失: 0.7451 | 累计平均损失: 0.7605
Epoch: 11/50 | Batch: 400/782 | 单Batch损失: 0.5224 | 累计平均损失: 0.7553
Epoch: 11/50 | Batch: 500/782 | 单Batch损失: 0.7267 | 累计平均损失: 0.7549
Epoch: 11/50 | Batch: 600/782 | 单Batch损失: 0.8173 | 累计平均损失: 0.7513
Epoch: 11/50 | Batch: 700/782 | 单Batch损失: 0.9506 | 累计平均损失: 0.7506
Epoch 11/50 完成 | 训练准确率: 73.82% | 测试准确率: 78.78%
Epoch: 12/50 | Batch: 100/782 | 单Batch损失: 0.5918 | 累计平均损失: 0.7357
Epoch: 12/50 | Batch: 200/782 | 单Batch损失: 0.9518 | 累计平均损失: 0.7366
Epoch: 12/50 | Batch: 300/782 | 单Batch损失: 0.7121 | 累计平均损失: 0.7359
Epoch: 12/50 | Batch: 400/782 | 单Batch损失: 0.8779 | 累计平均损失: 0.7322
Epoch: 12/50 | Batch: 500/782 | 单Batch损失: 0.7674 | 累计平均损失: 0.7295
Epoch: 12/50 | Batch: 600/782 | 单Batch损失: 0.6187 | 累计平均损失: 0.7272
Epoch: 12/50 | Batch: 700/782 | 单Batch损失: 0.5399 | 累计平均损失: 0.7288
Epoch 12/50 完成 | 训练准确率: 74.43% | 测试准确率: 78.19%
Epoch: 13/50 | Batch: 100/782 | 单Batch损失: 0.6534 | 累计平均损失: 0.7142
Epoch: 13/50 | Batch: 200/782 | 单Batch损失: 0.5741 | 累计平均损失: 0.7116
Epoch: 13/50 | Batch: 300/782 | 单Batch损失: 0.6597 | 累计平均损失: 0.7141
Epoch: 13/50 | Batch: 400/782 | 单Batch损失: 0.5866 | 累计平均损失: 0.7196
Epoch: 13/50 | Batch: 500/782 | 单Batch损失: 0.7502 | 累计平均损失: 0.7167
Epoch: 13/50 | Batch: 600/782 | 单Batch损失: 0.8962 | 累计平均损失: 0.7149
Epoch: 13/50 | Batch: 700/782 | 单Batch损失: 0.6058 | 累计平均损失: 0.7133
Epoch 13/50 完成 | 训练准确率: 75.17% | 测试准确率: 78.41%
Epoch: 14/50 | Batch: 100/782 | 单Batch损失: 0.4993 | 累计平均损失: 0.7119
Epoch: 14/50 | Batch: 200/782 | 单Batch损失: 0.5652 | 累计平均损失: 0.7001
Epoch: 14/50 | Batch: 300/782 | 单Batch损失: 0.3363 | 累计平均损失: 0.6963
Epoch: 14/50 | Batch: 400/782 | 单Batch损失: 0.6268 | 累计平均损失: 0.6968
Epoch: 14/50 | Batch: 500/782 | 单Batch损失: 0.8680 | 累计平均损失: 0.7000
Epoch: 14/50 | Batch: 600/782 | 单Batch损失: 0.7618 | 累计平均损失: 0.7037
Epoch: 14/50 | Batch: 700/782 | 单Batch损失: 0.7446 | 累计平均损失: 0.7031
Epoch 14/50 完成 | 训练准确率: 75.28% | 测试准确率: 78.96%
Epoch: 15/50 | Batch: 100/782 | 单Batch损失: 0.7875 | 累计平均损失: 0.7036
Epoch: 15/50 | Batch: 200/782 | 单Batch损失: 0.7661 | 累计平均损失: 0.6926
Epoch: 15/50 | Batch: 300/782 | 单Batch损失: 0.8379 | 累计平均损失: 0.7007
Epoch: 15/50 | Batch: 400/782 | 单Batch损失: 0.7053 | 累计平均损失: 0.6968
Epoch: 15/50 | Batch: 500/782 | 单Batch损失: 0.6655 | 累计平均损失: 0.6914
Epoch: 15/50 | Batch: 600/782 | 单Batch损失: 0.7306 | 累计平均损失: 0.6911
Epoch: 15/50 | Batch: 700/782 | 单Batch损失: 0.7147 | 累计平均损失: 0.6908
Epoch 15/50 完成 | 训练准确率: 75.66% | 测试准确率: 79.21%
Epoch: 16/50 | Batch: 100/782 | 单Batch损失: 0.5652 | 累计平均损失: 0.6737
Epoch: 16/50 | Batch: 200/782 | 单Batch损失: 0.5965 | 累计平均损失: 0.6645
Epoch: 16/50 | Batch: 300/782 | 单Batch损失: 0.7040 | 累计平均损失: 0.6769
Epoch: 16/50 | Batch: 400/782 | 单Batch损失: 0.7515 | 累计平均损失: 0.6774
Epoch: 16/50 | Batch: 500/782 | 单Batch损失: 0.8536 | 累计平均损失: 0.6792
Epoch: 16/50 | Batch: 600/782 | 单Batch损失: 0.7584 | 累计平均损失: 0.6808
Epoch: 16/50 | Batch: 700/782 | 单Batch损失: 0.6218 | 累计平均损失: 0.6798
Epoch 16/50 完成 | 训练准确率: 76.29% | 测试准确率: 79.40%
Epoch: 17/50 | Batch: 100/782 | 单Batch损失: 0.6101 | 累计平均损失: 0.6893
Epoch: 17/50 | Batch: 200/782 | 单Batch损失: 0.6680 | 累计平均损失: 0.6744
Epoch: 17/50 | Batch: 300/782 | 单Batch损失: 0.9642 | 累计平均损失: 0.6668
Epoch: 17/50 | Batch: 400/782 | 单Batch损失: 0.6158 | 累计平均损失: 0.6674
Epoch: 17/50 | Batch: 500/782 | 单Batch损失: 0.7772 | 累计平均损失: 0.6713
Epoch: 17/50 | Batch: 600/782 | 单Batch损失: 0.6575 | 累计平均损失: 0.6700
Epoch: 17/50 | Batch: 700/782 | 单Batch损失: 0.5222 | 累计平均损失: 0.6690
Epoch 17/50 完成 | 训练准确率: 76.63% | 测试准确率: 80.62%
Epoch: 18/50 | Batch: 100/782 | 单Batch损失: 0.5503 | 累计平均损失: 0.6422
Epoch: 18/50 | Batch: 200/782 | 单Batch损失: 0.6898 | 累计平均损失: 0.6609
Epoch: 18/50 | Batch: 300/782 | 单Batch损失: 0.5185 | 累计平均损失: 0.6581
Epoch: 18/50 | Batch: 400/782 | 单Batch损失: 0.6282 | 累计平均损失: 0.6577
Epoch: 18/50 | Batch: 500/782 | 单Batch损失: 0.5737 | 累计平均损失: 0.6590
Epoch: 18/50 | Batch: 600/782 | 单Batch损失: 0.7307 | 累计平均损失: 0.6645
Epoch: 18/50 | Batch: 700/782 | 单Batch损失: 0.5403 | 累计平均损失: 0.6623
Epoch 18/50 完成 | 训练准确率: 76.94% | 测试准确率: 79.31%
Epoch: 19/50 | Batch: 100/782 | 单Batch损失: 0.5747 | 累计平均损失: 0.6550
Epoch: 19/50 | Batch: 200/782 | 单Batch损失: 0.7259 | 累计平均损失: 0.6457
Epoch: 19/50 | Batch: 300/782 | 单Batch损失: 0.4796 | 累计平均损失: 0.6459
Epoch: 19/50 | Batch: 400/782 | 单Batch损失: 0.6797 | 累计平均损失: 0.6489
Epoch: 19/50 | Batch: 500/782 | 单Batch损失: 0.5831 | 累计平均损失: 0.6507
Epoch: 19/50 | Batch: 600/782 | 单Batch损失: 0.6827 | 累计平均损失: 0.6524
Epoch: 19/50 | Batch: 700/782 | 单Batch损失: 0.7586 | 累计平均损失: 0.6553
Epoch 19/50 完成 | 训练准确率: 77.20% | 测试准确率: 80.24%
Epoch: 20/50 | Batch: 100/782 | 单Batch损失: 0.6140 | 累计平均损失: 0.6367
Epoch: 20/50 | Batch: 200/782 | 单Batch损失: 0.9918 | 累计平均损失: 0.6492
Epoch: 20/50 | Batch: 300/782 | 单Batch损失: 0.6414 | 累计平均损失: 0.6444
Epoch: 20/50 | Batch: 400/782 | 单Batch损失: 0.4535 | 累计平均损失: 0.6412
Epoch: 20/50 | Batch: 500/782 | 单Batch损失: 0.5053 | 累计平均损失: 0.6386
Epoch: 20/50 | Batch: 600/782 | 单Batch损失: 0.5273 | 累计平均损失: 0.6394
Epoch: 20/50 | Batch: 700/782 | 单Batch损失: 0.8607 | 累计平均损失: 0.6396
Epoch 20/50 完成 | 训练准确率: 77.52% | 测试准确率: 80.57%
Epoch: 21/50 | Batch: 100/782 | 单Batch损失: 0.6232 | 累计平均损失: 0.6412
Epoch: 21/50 | Batch: 200/782 | 单Batch损失: 0.5387 | 累计平均损失: 0.6408
Epoch: 21/50 | Batch: 300/782 | 单Batch损失: 0.4878 | 累计平均损失: 0.6444
Epoch: 21/50 | Batch: 400/782 | 单Batch损失: 0.5599 | 累计平均损失: 0.6418
Epoch: 21/50 | Batch: 500/782 | 单Batch损失: 0.6464 | 累计平均损失: 0.6385
Epoch: 21/50 | Batch: 600/782 | 单Batch损失: 0.6277 | 累计平均损失: 0.6343
Epoch: 21/50 | Batch: 700/782 | 单Batch损失: 0.6791 | 累计平均损失: 0.6339
Epoch 21/50 完成 | 训练准确率: 77.81% | 测试准确率: 80.13%
Epoch: 22/50 | Batch: 100/782 | 单Batch损失: 0.6885 | 累计平均损失: 0.5697
Epoch: 22/50 | Batch: 200/782 | 单Batch损失: 0.6849 | 累计平均损失: 0.5795
Epoch: 22/50 | Batch: 300/782 | 单Batch损失: 0.3430 | 累计平均损失: 0.5832
Epoch: 22/50 | Batch: 400/782 | 单Batch损失: 0.3893 | 累计平均损失: 0.5839
Epoch: 22/50 | Batch: 500/782 | 单Batch损失: 0.6883 | 累计平均损失: 0.5803
Epoch: 22/50 | Batch: 600/782 | 单Batch损失: 0.7340 | 累计平均损失: 0.5776
Epoch: 22/50 | Batch: 700/782 | 单Batch损失: 0.7127 | 累计平均损失: 0.5769
Epoch 22/50 完成 | 训练准确率: 80.05% | 测试准确率: 81.60%
Epoch: 23/50 | Batch: 100/782 | 单Batch损失: 0.3769 | 累计平均损失: 0.5494
Epoch: 23/50 | Batch: 200/782 | 单Batch损失: 0.4616 | 累计平均损失: 0.5570
Epoch: 23/50 | Batch: 300/782 | 单Batch损失: 0.6095 | 累计平均损失: 0.5543
Epoch: 23/50 | Batch: 400/782 | 单Batch损失: 0.6793 | 累计平均损失: 0.5554
Epoch: 23/50 | Batch: 500/782 | 单Batch损失: 0.7518 | 累计平均损失: 0.5608
Epoch: 23/50 | Batch: 600/782 | 单Batch损失: 0.6962 | 累计平均损失: 0.5654
Epoch: 23/50 | Batch: 700/782 | 单Batch损失: 0.3720 | 累计平均损失: 0.5647
Epoch 23/50 完成 | 训练准确率: 80.24% | 测试准确率: 82.11%
Epoch: 24/50 | Batch: 100/782 | 单Batch损失: 0.4977 | 累计平均损失: 0.5465
Epoch: 24/50 | Batch: 200/782 | 单Batch损失: 0.6625 | 累计平均损失: 0.5445
Epoch: 24/50 | Batch: 300/782 | 单Batch损失: 0.5274 | 累计平均损失: 0.5435
Epoch: 24/50 | Batch: 400/782 | 单Batch损失: 0.4199 | 累计平均损失: 0.5464
Epoch: 24/50 | Batch: 500/782 | 单Batch损失: 0.8471 | 累计平均损失: 0.5456
Epoch: 24/50 | Batch: 600/782 | 单Batch损失: 0.4586 | 累计平均损失: 0.5473
Epoch: 24/50 | Batch: 700/782 | 单Batch损失: 0.6200 | 累计平均损失: 0.5489
Epoch 24/50 完成 | 训练准确率: 81.00% | 测试准确率: 81.52%
Epoch: 25/50 | Batch: 100/782 | 单Batch损失: 0.5663 | 累计平均损失: 0.5382
Epoch: 25/50 | Batch: 200/782 | 单Batch损失: 0.3852 | 累计平均损失: 0.5365
Epoch: 25/50 | Batch: 300/782 | 单Batch损失: 0.5224 | 累计平均损失: 0.5429
Epoch: 25/50 | Batch: 400/782 | 单Batch损失: 0.5851 | 累计平均损失: 0.5454
Epoch: 25/50 | Batch: 500/782 | 单Batch损失: 0.3714 | 累计平均损失: 0.5475
Epoch: 25/50 | Batch: 600/782 | 单Batch损失: 0.5114 | 累计平均损失: 0.5437
Epoch: 25/50 | Batch: 700/782 | 单Batch损失: 0.4935 | 累计平均损失: 0.5458
Epoch 25/50 完成 | 训练准确率: 80.80% | 测试准确率: 82.13%
Epoch: 26/50 | Batch: 100/782 | 单Batch损失: 0.4472 | 累计平均损失: 0.5378
Epoch: 26/50 | Batch: 200/782 | 单Batch损失: 0.4741 | 累计平均损失: 0.5337
Epoch: 26/50 | Batch: 300/782 | 单Batch损失: 0.5983 | 累计平均损失: 0.5343
Epoch: 26/50 | Batch: 400/782 | 单Batch损失: 0.5436 | 累计平均损失: 0.5378
Epoch: 26/50 | Batch: 500/782 | 单Batch损失: 0.6347 | 累计平均损失: 0.5373
Epoch: 26/50 | Batch: 600/782 | 单Batch损失: 0.6718 | 累计平均损失: 0.5389
Epoch: 26/50 | Batch: 700/782 | 单Batch损失: 0.4908 | 累计平均损失: 0.5391
Epoch 26/50 完成 | 训练准确率: 81.11% | 测试准确率: 82.01%
Epoch: 27/50 | Batch: 100/782 | 单Batch损失: 0.5034 | 累计平均损失: 0.5343
Epoch: 27/50 | Batch: 200/782 | 单Batch损失: 0.6639 | 累计平均损失: 0.5405
Epoch: 27/50 | Batch: 300/782 | 单Batch损失: 0.6827 | 累计平均损失: 0.5323
Epoch: 27/50 | Batch: 400/782 | 单Batch损失: 0.3565 | 累计平均损失: 0.5360
Epoch: 27/50 | Batch: 500/782 | 单Batch损失: 0.5307 | 累计平均损失: 0.5334
Epoch: 27/50 | Batch: 600/782 | 单Batch损失: 0.3025 | 累计平均损失: 0.5356
Epoch: 27/50 | Batch: 700/782 | 单Batch损失: 0.4400 | 累计平均损失: 0.5349
Epoch 27/50 完成 | 训练准确率: 81.30% | 测试准确率: 82.04%
Epoch: 28/50 | Batch: 100/782 | 单Batch损失: 0.3281 | 累计平均损失: 0.4902
Epoch: 28/50 | Batch: 200/782 | 单Batch损失: 0.4154 | 累计平均损失: 0.5091
Epoch: 28/50 | Batch: 300/782 | 单Batch损失: 0.6878 | 累计平均损失: 0.5200
Epoch: 28/50 | Batch: 400/782 | 单Batch损失: 0.6828 | 累计平均损失: 0.5213
Epoch: 28/50 | Batch: 500/782 | 单Batch损失: 0.6295 | 累计平均损失: 0.5222
Epoch: 28/50 | Batch: 600/782 | 单Batch损失: 0.4322 | 累计平均损失: 0.5253
Epoch: 28/50 | Batch: 700/782 | 单Batch损失: 0.5940 | 累计平均损失: 0.5267
Epoch 28/50 完成 | 训练准确率: 81.44% | 测试准确率: 82.63%
Epoch: 29/50 | Batch: 100/782 | 单Batch损失: 0.5423 | 累计平均损失: 0.5337
Epoch: 29/50 | Batch: 200/782 | 单Batch损失: 0.3486 | 累计平均损失: 0.5235
Epoch: 29/50 | Batch: 300/782 | 单Batch损失: 0.5683 | 累计平均损失: 0.5263
Epoch: 29/50 | Batch: 400/782 | 单Batch损失: 0.7805 | 累计平均损失: 0.5249
Epoch: 29/50 | Batch: 500/782 | 单Batch损失: 0.6783 | 累计平均损失: 0.5265
Epoch: 29/50 | Batch: 600/782 | 单Batch损失: 0.3496 | 累计平均损失: 0.5244
Epoch: 29/50 | Batch: 700/782 | 单Batch损失: 0.6632 | 累计平均损失: 0.5246
Epoch 29/50 完成 | 训练准确率: 81.55% | 测试准确率: 82.38%
Epoch: 30/50 | Batch: 100/782 | 单Batch损失: 0.4141 | 累计平均损失: 0.5208
Epoch: 30/50 | Batch: 200/782 | 单Batch损失: 0.4444 | 累计平均损失: 0.5153
Epoch: 30/50 | Batch: 300/782 | 单Batch损失: 0.5220 | 累计平均损失: 0.5173
Epoch: 30/50 | Batch: 400/782 | 单Batch损失: 0.5325 | 累计平均损失: 0.5246
Epoch: 30/50 | Batch: 500/782 | 单Batch损失: 0.5129 | 累计平均损失: 0.5225
Epoch: 30/50 | Batch: 600/782 | 单Batch损失: 0.3840 | 累计平均损失: 0.5225
Epoch: 30/50 | Batch: 700/782 | 单Batch损失: 0.6955 | 累计平均损失: 0.5208
Epoch 30/50 完成 | 训练准确率: 81.68% | 测试准确率: 82.91%
Epoch: 31/50 | Batch: 100/782 | 单Batch损失: 0.5352 | 累计平均损失: 0.5199
Epoch: 31/50 | Batch: 200/782 | 单Batch损失: 0.4117 | 累计平均损失: 0.5153
Epoch: 31/50 | Batch: 300/782 | 单Batch损失: 0.6129 | 累计平均损失: 0.5194
Epoch: 31/50 | Batch: 400/782 | 单Batch损失: 0.4124 | 累计平均损失: 0.5220
Epoch: 31/50 | Batch: 500/782 | 单Batch损失: 0.5559 | 累计平均损失: 0.5163
Epoch: 31/50 | Batch: 600/782 | 单Batch损失: 0.5134 | 累计平均损失: 0.5181
Epoch: 31/50 | Batch: 700/782 | 单Batch损失: 0.5832 | 累计平均损失: 0.5162
Epoch 31/50 完成 | 训练准确率: 81.79% | 测试准确率: 82.87%
Epoch: 32/50 | Batch: 100/782 | 单Batch损失: 0.4066 | 累计平均损失: 0.5037
Epoch: 32/50 | Batch: 200/782 | 单Batch损失: 0.5626 | 累计平均损失: 0.5022
Epoch: 32/50 | Batch: 300/782 | 单Batch损失: 0.2629 | 累计平均损失: 0.5073
Epoch: 32/50 | Batch: 400/782 | 单Batch损失: 0.6417 | 累计平均损失: 0.5083
Epoch: 32/50 | Batch: 500/782 | 单Batch损失: 0.5559 | 累计平均损失: 0.5089
Epoch: 32/50 | Batch: 600/782 | 单Batch损失: 0.5321 | 累计平均损失: 0.5107
Epoch: 32/50 | Batch: 700/782 | 单Batch损失: 0.6649 | 累计平均损失: 0.5119
Epoch 32/50 完成 | 训练准确率: 81.93% | 测试准确率: 83.27%
Epoch: 33/50 | Batch: 100/782 | 单Batch损失: 0.5663 | 累计平均损失: 0.5067
Epoch: 33/50 | Batch: 200/782 | 单Batch损失: 0.5596 | 累计平均损失: 0.5032
Epoch: 33/50 | Batch: 300/782 | 单Batch损失: 0.4727 | 累计平均损失: 0.5019
Epoch: 33/50 | Batch: 400/782 | 单Batch损失: 0.4067 | 累计平均损失: 0.4982
Epoch: 33/50 | Batch: 500/782 | 单Batch损失: 0.6200 | 累计平均损失: 0.4987
Epoch: 33/50 | Batch: 600/782 | 单Batch损失: 0.4416 | 累计平均损失: 0.5002
Epoch: 33/50 | Batch: 700/782 | 单Batch损失: 0.3472 | 累计平均损失: 0.5002
Epoch 33/50 完成 | 训练准确率: 82.68% | 测试准确率: 83.09%
Epoch: 34/50 | Batch: 100/782 | 单Batch损失: 0.4038 | 累计平均损失: 0.5002
Epoch: 34/50 | Batch: 200/782 | 单Batch损失: 0.3476 | 累计平均损失: 0.4907
Epoch: 34/50 | Batch: 300/782 | 单Batch损失: 0.5228 | 累计平均损失: 0.4910
Epoch: 34/50 | Batch: 400/782 | 单Batch损失: 0.5934 | 累计平均损失: 0.4949
Epoch: 34/50 | Batch: 500/782 | 单Batch损失: 0.5030 | 累计平均损失: 0.4976
Epoch: 34/50 | Batch: 600/782 | 单Batch损失: 0.5574 | 累计平均损失: 0.4979
Epoch: 34/50 | Batch: 700/782 | 单Batch损失: 0.5987 | 累计平均损失: 0.5005
Epoch 34/50 完成 | 训练准确率: 82.47% | 测试准确率: 82.65%
Epoch: 35/50 | Batch: 100/782 | 单Batch损失: 0.4641 | 累计平均损失: 0.4963
Epoch: 35/50 | Batch: 200/782 | 单Batch损失: 0.2876 | 累计平均损失: 0.5026
Epoch: 35/50 | Batch: 300/782 | 单Batch损失: 0.3573 | 累计平均损失: 0.5000
Epoch: 35/50 | Batch: 400/782 | 单Batch损失: 0.5024 | 累计平均损失: 0.4989
Epoch: 35/50 | Batch: 500/782 | 单Batch损失: 0.5831 | 累计平均损失: 0.4984
Epoch: 35/50 | Batch: 600/782 | 单Batch损失: 0.4280 | 累计平均损失: 0.4978
Epoch: 35/50 | Batch: 700/782 | 单Batch损失: 0.3835 | 累计平均损失: 0.4984
Epoch 35/50 完成 | 训练准确率: 82.46% | 测试准确率: 83.11%
Epoch: 36/50 | Batch: 100/782 | 单Batch损失: 0.5082 | 累计平均损失: 0.4836
Epoch: 36/50 | Batch: 200/782 | 单Batch损失: 0.4206 | 累计平均损失: 0.4871
Epoch: 36/50 | Batch: 300/782 | 单Batch损失: 0.5474 | 累计平均损失: 0.4882
Epoch: 36/50 | Batch: 400/782 | 单Batch损失: 0.4618 | 累计平均损失: 0.4932
Epoch: 36/50 | Batch: 500/782 | 单Batch损失: 0.4423 | 累计平均损失: 0.4943
Epoch: 36/50 | Batch: 600/782 | 单Batch损失: 0.4237 | 累计平均损失: 0.4955
Epoch: 36/50 | Batch: 700/782 | 单Batch损失: 0.4717 | 累计平均损失: 0.4971
Epoch 36/50 完成 | 训练准确率: 82.50% | 测试准确率: 82.89%
Epoch: 37/50 | Batch: 100/782 | 单Batch损失: 0.5863 | 累计平均损失: 0.4909
Epoch: 37/50 | Batch: 200/782 | 单Batch损失: 0.7195 | 累计平均损失: 0.4824
Epoch: 37/50 | Batch: 300/782 | 单Batch损失: 0.5792 | 累计平均损失: 0.4818
Epoch: 37/50 | Batch: 400/782 | 单Batch损失: 0.5705 | 累计平均损失: 0.4767
Epoch: 37/50 | Batch: 500/782 | 单Batch损失: 0.5994 | 累计平均损失: 0.4749
Epoch: 37/50 | Batch: 600/782 | 单Batch损失: 0.4948 | 累计平均损失: 0.4735
Epoch: 37/50 | Batch: 700/782 | 单Batch损失: 0.5427 | 累计平均损失: 0.4704
Epoch 37/50 完成 | 训练准确率: 83.68% | 测试准确率: 83.59%
Epoch: 38/50 | Batch: 100/782 | 单Batch损失: 0.4128 | 累计平均损失: 0.4583
Epoch: 38/50 | Batch: 200/782 | 单Batch损失: 0.4347 | 累计平均损失: 0.4631
Epoch: 38/50 | Batch: 300/782 | 单Batch损失: 0.4883 | 累计平均损失: 0.4625
Epoch: 38/50 | Batch: 400/782 | 单Batch损失: 0.3827 | 累计平均损失: 0.4627
Epoch: 38/50 | Batch: 500/782 | 单Batch损失: 0.4065 | 累计平均损失: 0.4590
Epoch: 38/50 | Batch: 600/782 | 单Batch损失: 0.5905 | 累计平均损失: 0.4584
Epoch: 38/50 | Batch: 700/782 | 单Batch损失: 0.3628 | 累计平均损失: 0.4596
Epoch 38/50 完成 | 训练准确率: 83.96% | 测试准确率: 83.76%
Epoch: 39/50 | Batch: 100/782 | 单Batch损失: 0.4287 | 累计平均损失: 0.4478
Epoch: 39/50 | Batch: 200/782 | 单Batch损失: 0.4111 | 累计平均损失: 0.4404
Epoch: 39/50 | Batch: 300/782 | 单Batch损失: 0.4318 | 累计平均损失: 0.4464
Epoch: 39/50 | Batch: 400/782 | 单Batch损失: 0.4589 | 累计平均损失: 0.4454
Epoch: 39/50 | Batch: 500/782 | 单Batch损失: 0.4246 | 累计平均损失: 0.4477
Epoch: 39/50 | Batch: 600/782 | 单Batch损失: 0.4496 | 累计平均损失: 0.4475
Epoch: 39/50 | Batch: 700/782 | 单Batch损失: 0.4614 | 累计平均损失: 0.4488
Epoch 39/50 完成 | 训练准确率: 84.13% | 测试准确率: 83.91%
Epoch: 40/50 | Batch: 100/782 | 单Batch损失: 0.4400 | 累计平均损失: 0.4592
Epoch: 40/50 | Batch: 200/782 | 单Batch损失: 0.3083 | 累计平均损失: 0.4541
Epoch: 40/50 | Batch: 300/782 | 单Batch损失: 0.3531 | 累计平均损失: 0.4572
Epoch: 40/50 | Batch: 400/782 | 单Batch损失: 0.6370 | 累计平均损失: 0.4587
Epoch: 40/50 | Batch: 500/782 | 单Batch损失: 0.4207 | 累计平均损失: 0.4564
Epoch: 40/50 | Batch: 600/782 | 单Batch损失: 0.4361 | 累计平均损失: 0.4576
Epoch: 40/50 | Batch: 700/782 | 单Batch损失: 0.6051 | 累计平均损失: 0.4561
Epoch 40/50 完成 | 训练准确率: 83.91% | 测试准确率: 83.71%
Epoch: 41/50 | Batch: 100/782 | 单Batch损失: 0.3263 | 累计平均损失: 0.4479
Epoch: 41/50 | Batch: 200/782 | 单Batch损失: 0.2796 | 累计平均损失: 0.4417
Epoch: 41/50 | Batch: 300/782 | 单Batch损失: 0.2573 | 累计平均损失: 0.4485
Epoch: 41/50 | Batch: 400/782 | 单Batch损失: 0.3995 | 累计平均损失: 0.4509
Epoch: 41/50 | Batch: 500/782 | 单Batch损失: 0.6162 | 累计平均损失: 0.4489
Epoch: 41/50 | Batch: 600/782 | 单Batch损失: 0.2519 | 累计平均损失: 0.4500
Epoch: 41/50 | Batch: 700/782 | 单Batch损失: 0.4916 | 累计平均损失: 0.4490
Epoch 41/50 完成 | 训练准确率: 84.10% | 测试准确率: 84.04%
Epoch: 42/50 | Batch: 100/782 | 单Batch损失: 0.4066 | 累计平均损失: 0.4641
Epoch: 42/50 | Batch: 200/782 | 单Batch损失: 0.5186 | 累计平均损失: 0.4520
Epoch: 42/50 | Batch: 300/782 | 单Batch损失: 0.8073 | 累计平均损失: 0.4544
Epoch: 42/50 | Batch: 400/782 | 单Batch损失: 0.4509 | 累计平均损失: 0.4527
Epoch: 42/50 | Batch: 500/782 | 单Batch损失: 0.4242 | 累计平均损失: 0.4534
Epoch: 42/50 | Batch: 600/782 | 单Batch损失: 0.3649 | 累计平均损失: 0.4534
Epoch: 42/50 | Batch: 700/782 | 单Batch损失: 0.4808 | 累计平均损失: 0.4520
Epoch 42/50 完成 | 训练准确率: 84.10% | 测试准确率: 84.01%
Epoch: 43/50 | Batch: 100/782 | 单Batch损失: 0.2994 | 累计平均损失: 0.4297
Epoch: 43/50 | Batch: 200/782 | 单Batch损失: 0.2808 | 累计平均损失: 0.4286
Epoch: 43/50 | Batch: 300/782 | 单Batch损失: 0.5333 | 累计平均损失: 0.4280
Epoch: 43/50 | Batch: 400/782 | 单Batch损失: 0.4810 | 累计平均损失: 0.4346
Epoch: 43/50 | Batch: 500/782 | 单Batch损失: 0.4021 | 累计平均损失: 0.4382
Epoch: 43/50 | Batch: 600/782 | 单Batch损失: 0.4964 | 累计平均损失: 0.4404
Epoch: 43/50 | Batch: 700/782 | 单Batch损失: 0.3097 | 累计平均损失: 0.4431
Epoch 43/50 完成 | 训练准确率: 84.33% | 测试准确率: 84.30%
Epoch: 44/50 | Batch: 100/782 | 单Batch损失: 0.3987 | 累计平均损失: 0.4504
Epoch: 44/50 | Batch: 200/782 | 单Batch损失: 0.4526 | 累计平均损失: 0.4385
Epoch: 44/50 | Batch: 300/782 | 单Batch损失: 0.3959 | 累计平均损失: 0.4369
Epoch: 44/50 | Batch: 400/782 | 单Batch损失: 0.5550 | 累计平均损失: 0.4364
Epoch: 44/50 | Batch: 500/782 | 单Batch损失: 0.2680 | 累计平均损失: 0.4371
Epoch: 44/50 | Batch: 600/782 | 单Batch损失: 0.4076 | 累计平均损失: 0.4403
Epoch: 44/50 | Batch: 700/782 | 单Batch损失: 0.4882 | 累计平均损失: 0.4396
Epoch 44/50 完成 | 训练准确率: 84.55% | 测试准确率: 84.31%
Epoch: 45/50 | Batch: 100/782 | 单Batch损失: 0.4140 | 累计平均损失: 0.4360
Epoch: 45/50 | Batch: 200/782 | 单Batch损失: 0.5183 | 累计平均损失: 0.4349
Epoch: 45/50 | Batch: 300/782 | 单Batch损失: 0.2798 | 累计平均损失: 0.4288
Epoch: 45/50 | Batch: 400/782 | 单Batch损失: 0.3751 | 累计平均损失: 0.4307
Epoch: 45/50 | Batch: 500/782 | 单Batch损失: 0.4593 | 累计平均损失: 0.4312
Epoch: 45/50 | Batch: 600/782 | 单Batch损失: 0.4500 | 累计平均损失: 0.4357
Epoch: 45/50 | Batch: 700/782 | 单Batch损失: 0.4044 | 累计平均损失: 0.4344
Epoch 45/50 完成 | 训练准确率: 84.61% | 测试准确率: 84.35%
Epoch: 46/50 | Batch: 100/782 | 单Batch损失: 0.4491 | 累计平均损失: 0.4264
Epoch: 46/50 | Batch: 200/782 | 单Batch损失: 0.4125 | 累计平均损失: 0.4200
Epoch: 46/50 | Batch: 300/782 | 单Batch损失: 0.6547 | 累计平均损失: 0.4215
Epoch: 46/50 | Batch: 400/782 | 单Batch损失: 0.3980 | 累计平均损失: 0.4195
Epoch: 46/50 | Batch: 500/782 | 单Batch损失: 0.6344 | 累计平均损失: 0.4183
Epoch: 46/50 | Batch: 600/782 | 单Batch损失: 0.3904 | 累计平均损失: 0.4169
Epoch: 46/50 | Batch: 700/782 | 单Batch损失: 0.3617 | 累计平均损失: 0.4174
Epoch 46/50 完成 | 训练准确率: 85.24% | 测试准确率: 84.43%
Epoch: 47/50 | Batch: 100/782 | 单Batch损失: 0.5024 | 累计平均损失: 0.4210
Epoch: 47/50 | Batch: 200/782 | 单Batch损失: 0.4411 | 累计平均损失: 0.4237
Epoch: 47/50 | Batch: 300/782 | 单Batch损失: 0.6353 | 累计平均损失: 0.4277
Epoch: 47/50 | Batch: 400/782 | 单Batch损失: 0.2761 | 累计平均损失: 0.4294
Epoch: 47/50 | Batch: 500/782 | 单Batch损失: 0.3382 | 累计平均损失: 0.4232
Epoch: 47/50 | Batch: 600/782 | 单Batch损失: 0.4786 | 累计平均损失: 0.4200
Epoch: 47/50 | Batch: 700/782 | 单Batch损失: 0.3182 | 累计平均损失: 0.4155
Epoch 47/50 完成 | 训练准确率: 85.35% | 测试准确率: 84.70%
Epoch: 48/50 | Batch: 100/782 | 单Batch损失: 0.4391 | 累计平均损失: 0.4149
Epoch: 48/50 | Batch: 200/782 | 单Batch损失: 0.2870 | 累计平均损失: 0.4091
Epoch: 48/50 | Batch: 300/782 | 单Batch损失: 0.2172 | 累计平均损失: 0.4089
Epoch: 48/50 | Batch: 400/782 | 单Batch损失: 0.4024 | 累计平均损失: 0.4059
Epoch: 48/50 | Batch: 500/782 | 单Batch损失: 0.5650 | 累计平均损失: 0.4108
Epoch: 48/50 | Batch: 600/782 | 单Batch损失: 0.5908 | 累计平均损失: 0.4144
Epoch: 48/50 | Batch: 700/782 | 单Batch损失: 0.6228 | 累计平均损失: 0.4175
Epoch 48/50 完成 | 训练准确率: 85.48% | 测试准确率: 84.75%
Epoch: 49/50 | Batch: 100/782 | 单Batch损失: 0.4059 | 累计平均损失: 0.4052
Epoch: 49/50 | Batch: 200/782 | 单Batch损失: 0.5149 | 累计平均损失: 0.4056
Epoch: 49/50 | Batch: 300/782 | 单Batch损失: 0.5034 | 累计平均损失: 0.4057
Epoch: 49/50 | Batch: 400/782 | 单Batch损失: 0.1814 | 累计平均损失: 0.4038
Epoch: 49/50 | Batch: 500/782 | 单Batch损失: 0.4429 | 累计平均损失: 0.4087
Epoch: 49/50 | Batch: 600/782 | 单Batch损失: 0.3421 | 累计平均损失: 0.4112
Epoch: 49/50 | Batch: 700/782 | 单Batch损失: 0.2139 | 累计平均损失: 0.4106
Epoch 49/50 完成 | 训练准确率: 85.55% | 测试准确率: 84.51%
Epoch: 50/50 | Batch: 100/782 | 单Batch损失: 0.5291 | 累计平均损失: 0.4340
Epoch: 50/50 | Batch: 200/782 | 单Batch损失: 0.3468 | 累计平均损失: 0.4225
Epoch: 50/50 | Batch: 300/782 | 单Batch损失: 0.2264 | 累计平均损失: 0.4221
Epoch: 50/50 | Batch: 400/782 | 单Batch损失: 0.4216 | 累计平均损失: 0.4157
Epoch: 50/50 | Batch: 500/782 | 单Batch损失: 0.3529 | 累计平均损失: 0.4157
Epoch: 50/50 | Batch: 600/782 | 单Batch损失: 0.5062 | 累计平均损失: 0.4167
Epoch: 50/50 | Batch: 700/782 | 单Batch损失: 0.3044 | 累计平均损失: 0.4143
Epoch 50/50 完成 | 训练准确率: 85.42% | 测试准确率: 84.68%

训练完成!最终测试准确率: 84.68%

可以看到测试集一定程度上收敛了,在85%左右(还可以继续训练的),我们后续和加了通道注意力的该模型作对比,这也意味着我们进入到了消融实验的部分了。

  • 过去我们都是在同一个数据集上对比不同的模型的差异,或者同一个模型不同参数下的差异,这种实验叫做对比实验。

  • 在同一个数据集上,对同一个模型进行模块的增加和减少,这种实验我们称之为消融实验。通过消融实验,研究者能更清晰地理解模型各部分的作用,而对比实验则用于评估模型的整体竞争力。两者常结合使用,以全面验证模型设计的合理性。

2.2 特征图可视化

为了方便观察,我们先尝试提取下特征图。特征图本质就是不同的卷积核的输出,浅层指的是离输入图近的卷积层,浅层卷积层的特征图通常较大,而深层特征图会经过多次下采样,尺寸显著缩小,尺寸差异过大时,小尺寸特征图在视觉上会显得模糊或丢失细节。步骤逻辑如下:

  1. 初始化设置

    • 将模型设为评估模式,准备类别名称列表(如飞机、汽车等)。
  2. 数据加载与处理

    • 从测试数据加载器中获取图像和标签。
    • 仅处理前 num_images 张图像(如2张)。
  3. 注册钩子捕获特征图

    • 为指定层(如 conv1conv2conv3)注册前向钩子。
    • 钩子函数将这些层的输出(特征图)保存到字典中。
  4. 前向传播与特征提取

    • 模型处理图像,触发钩子函数,获取并保存特征图。
    • 移除钩子,避免后续干扰。
  5. 可视化特征图

    • 对每张图像:
      • 恢复原始像素值并显示。
      • 为每个目标层创建子图,展示前 num_channels 个通道的特征图(如9个通道)。
      • 每个通道的特征图以网格形式排列,显示通道编号。

关键细节

  • 特征图布局:原始图像在左侧,各层特征图按顺序排列在右侧。
  • 通道选择:默认显示前9个通道(按重要性或索引排序)。
  • 显示优化
    • 使用 inset_axes 在大图中嵌入小网格,清晰展示每个通道。
    • 层标题与通道标题分开,避免重叠。
    • 反标准化处理恢复图像原始色彩。
def visualize_feature_maps(model, test_loader, device, layer_names, num_images=3, num_channels=9):
    """
    可视化指定层的特征图(修复循环冗余问题)
    参数:
        model: 模型
        test_loader: 测试数据加载器
        layer_names: 要可视化的层名称(如['conv1', 'conv2', 'conv3'])
        num_images: 可视化的图像总数
        num_channels: 每个图像显示的通道数(取前num_channels个通道)
    """
    model.eval()  # 设置为评估模式
    class_names = ['飞机', '汽车', '鸟', '猫', '鹿', '狗', '青蛙', '马', '船', '卡车']
    
    # 从测试集加载器中提取指定数量的图像(避免嵌套循环)
    images_list, labels_list = [], []
    for images, labels in test_loader:
        images_list.append(images)
        labels_list.append(labels)
        if len(images_list) * test_loader.batch_size >= num_images:
            break
    # 拼接并截取到目标数量
    images = torch.cat(images_list, dim=0)[:num_images].to(device)
    labels = torch.cat(labels_list, dim=0)[:num_images].to(device)

    with torch.no_grad():
        # 存储各层特征图
        feature_maps = {}
        # 保存钩子句柄
        hooks = []
        
        # 定义钩子函数,捕获指定层的输出
        def hook(module, input, output, name):
            feature_maps[name] = output.cpu()  # 保存特征图到字典
        
        # 为每个目标层注册钩子,并保存钩子句柄
        for name in layer_names:
            module = getattr(model, name)
            hook_handle = module.register_forward_hook(lambda m, i, o, n=name: hook(m, i, o, n))
            hooks.append(hook_handle)
        
        # 前向传播触发钩子
        _ = model(images)
        
        # 正确移除钩子
        for hook_handle in hooks:
            hook_handle.remove()
        
        # 可视化每个图像的各层特征图(仅一层循环)
        for img_idx in range(num_images):
            img = images[img_idx].cpu().permute(1, 2, 0).numpy()
            # 反标准化处理(恢复原始像素值)
            img = img * np.array([0.2023, 0.1994, 0.2010]).reshape(1, 1, 3) + np.array([0.4914, 0.4822, 0.4465]).reshape(1, 1, 3)
            img = np.clip(img, 0, 1)  # 确保像素值在[0,1]范围内
            
            # 创建子图
            num_layers = len(layer_names)
            fig, axes = plt.subplots(1, num_layers + 1, figsize=(4 * (num_layers + 1), 4))
            
            # 显示原始图像
            axes[0].imshow(img)
            axes[0].set_title(f'原始图像\n类别: {class_names[labels[img_idx]]}')
            axes[0].axis('off')
            
            # 显示各层特征图
            for layer_idx, layer_name in enumerate(layer_names):
                fm = feature_maps[layer_name][img_idx]  # 取第img_idx张图像的特征图
                fm = fm[:num_channels]  # 仅取前num_channels个通道
                num_rows = int(np.sqrt(num_channels))
                num_cols = num_channels // num_rows if num_rows != 0 else 1
                
                # 创建子图网格
                layer_ax = axes[layer_idx + 1]
                layer_ax.set_title(f'{layer_name}特征图 \n')# 加个换行让文字分离上去
                layer_ax.axis('off')  # 关闭大子图的坐标轴
                
                # 在大子图内创建小网格
                for ch_idx, channel in enumerate(fm):
                    ax = layer_ax.inset_axes([ch_idx % num_cols / num_cols, 
                                            (num_rows - 1 - ch_idx // num_cols) / num_rows, 
                                            1/num_cols, 1/num_rows])
                    ax.imshow(channel.numpy(), cmap='viridis')
                    ax.set_title(f'通道 {ch_idx + 1}')
                    ax.axis('off')
            
            plt.tight_layout()
            plt.show()

# 调用示例(按需修改参数)
layer_names = ['conv1', 'conv2', 'conv3']
visualize_feature_maps(
    model=model,
    test_loader=test_loader,
    device=device,
    layer_names=layer_names,
    num_images=5,  # 可视化5张测试图像 → 输出5张大图
    num_channels=9   # 每张图像显示前9个通道的特征图
)

上面的图为提取CNN不同卷积层输出的特征图,我们以第五张图片-青蛙 进行解读。

由于经过了不断的下采样,特征变得越来越抽象,人类已经无法理解。

核心作用 通过可视化特征图,可直观观察:

  • 浅层卷积层(如 conv1)如何捕获边缘、纹理等低级特征。
  • 深层卷积层(如 conv3)如何组合低级特征形成语义概念(如物体部件)。
  • 模型对不同类别的关注区域差异(如鸟类的羽毛纹理 vs. 飞机的金属光泽)。

conv1 特征图(浅层卷积)

  • 特点
    • 保留较多原始图像的细节纹理(如植物叶片、青蛙身体的边缘轮廓)。
    • 通道间差异相对小,每个通道都能看到类似原始图像的基础结构(如通道 1 - 9 都能识别边缘、纹理)。
  • 意义
    • 提取低级特征(边缘、颜色块、简单纹理),是后续高层特征的“原材料”。
    • 类似人眼初步识别图像的轮廓和基础结构。

conv2 特征图(中层卷积)

  • 特点
    • 空间尺寸(高、宽)比 conv1 更小(因卷积/池化下采样),但语义信息更抽象
    • 通道间差异更明显:部分通道开始聚焦局部关键特征(如通道 5、8 中黄色高亮区域,可能对应青蛙身体或植物的关键纹理)。
  • 意义
    • 对 conv1 的低级特征进行组合与筛选,提取中级特征(如局部形状、纹理组合)。
    • 类似人眼从“边缘轮廓”过渡到“识别局部结构”(如青蛙的身体块、植物的叶片簇)。

conv3 特征图(深层卷积)

  • 特点
    • 空间尺寸进一步缩小,抽象程度最高,肉眼难直接对应原始图像细节。
    • 通道间差异极大,部分通道聚焦全局语义特征(如通道 4、7 中黄色区域,可能对应模型判断“青蛙”类别的关键特征)。
  • 意义
    • 对 conv2 的中级特征进行全局整合,提取高级语义特征(如物体类别相关的抽象模式)。
    • 类似人眼最终“识别出这是青蛙”的关键依据,模型通过这些特征判断类别。

逐层对比总结

层级特征图特点对应模型能力类比人类视觉流程
原始图像细节丰富但无抽象语义无(纯输入)视网膜接收原始光信号
conv1保留基础细节,提取低级特征识别边缘、纹理视觉皮层初步解析轮廓
conv2抽象化,提取局部关键特征识别局部结构(如身体块、叶片簇)大脑进一步组合特征识别局部模式
conv3高度抽象,聚焦全局语义特征识别类别相关核心模式大脑最终整合信息判断“这是青蛙”
  • 特征逐层抽象:从“看得见的细节”(conv1)→ “局部结构”(conv2)→ “类别相关的抽象模式”(conv3),模型通过这种方式实现从“看图像”到“理解语义”的跨越。
  • 通道分工明确:不同通道在各层聚焦不同特征(如有的通道负责边缘,有的负责颜色,有的负责全局语义),共同协作完成分类任务。
  • 下采样的作用:通过缩小空间尺寸,换取更高的语义抽象能力(“牺牲细节,换取理解”)。

三、通道注意力

现在我们引入通道注意力,来观察精度是否有变化,并且进一步可视化。

想要把通道注意力插入到模型中,关键步骤如下:

  1. 定义注意力模块
  2. 重写之前的模型定义部分,确定好模块插入的位置

3.1 通道注意力的定义

# ===================== 新增:通道注意力模块(SE模块) =====================
class ChannelAttention(nn.Module):
    """通道注意力模块(Squeeze-and-Excitation)"""
    def __init__(self, in_channels, reduction_ratio=16):
        """
        参数:
            in_channels: 输入特征图的通道数
            reduction_ratio: 降维比例,用于减少参数量
        """
        super(ChannelAttention, self).__init__()
        
        # 全局平均池化 - 将空间维度压缩为1x1,保留通道信息
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        
        # 全连接层 + 激活函数,用于学习通道间的依赖关系
        self.fc = nn.Sequential(
            # 降维:压缩通道数,减少计算量
            nn.Linear(in_channels, in_channels // reduction_ratio, bias=False),
            nn.ReLU(inplace=True),
            # 升维:恢复原始通道数
            nn.Linear(in_channels // reduction_ratio, in_channels, bias=False),
            # Sigmoid将输出值归一化到[0,1],表示通道重要性权重
            nn.Sigmoid()
        )

    def forward(self, x):
        """
        参数:
            x: 输入特征图,形状为 [batch_size, channels, height, width]
        
        返回:
            加权后的特征图,形状不变
        """
        batch_size, channels, height, width = x.size()
        
        # 1. 全局平均池化:[batch_size, channels, height, width] → [batch_size, channels, 1, 1]
        avg_pool_output = self.avg_pool(x)
        
        # 2. 展平为一维向量:[batch_size, channels, 1, 1] → [batch_size, channels]
        avg_pool_output = avg_pool_output.view(batch_size, channels)
        
        # 3. 通过全连接层学习通道权重:[batch_size, channels] → [batch_size, channels]
        channel_weights = self.fc(avg_pool_output)
        
        # 4. 重塑为二维张量:[batch_size, channels] → [batch_size, channels, 1, 1]
        channel_weights = channel_weights.view(batch_size, channels, 1, 1)
        
        # 5. 将权重应用到原始特征图上(逐通道相乘)
        return x * channel_weights  # 输出形状:[batch_size, channels, height, width]

通道注意力模块的核心原理

  1. Squeeze(压缩):
  • 通过全局平均池化将每个通道的二维特征图(H×W)压缩为一个标量,保留通道的全局信息。
  • 物理意义:计算每个通道在整个图像中的 “平均响应强度”,例如,“边缘检测通道” 在有物体边缘的图像中响应值会更高。
  1. Excitation(激发):
  • 通过全连接层 + Sigmoid 激活,学习通道间的依赖关系,输出 0-1 之间的权重值。
  • 物理意义:让模型自动判断哪些通道更重要(权重接近 1),哪些通道可忽略(权重接近 0)。
  1. Reweight(重加权):
  • 将学习到的通道权重与原始特征图逐通道相乘,增强重要通道,抑制不重要通道。
  • 物理意义:类似人类视觉系统聚焦于关键特征(如猫的轮廓),忽略无关特征(如背景颜色)

通道注意力插入后,参数量略微提高,增加了特征提取能力

3.2 模型的重新定义(通道注意力的插入)

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()  
        
        # ---------------------- 第一个卷积块 ----------------------
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.bn1 = nn.BatchNorm2d(32)
        self.relu1 = nn.ReLU()
        # 新增:插入通道注意力模块(SE模块)
        self.ca1 = ChannelAttention(in_channels=32, reduction_ratio=16)  
        self.pool1 = nn.MaxPool2d(2, 2)  
        
        # ---------------------- 第二个卷积块 ----------------------
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.relu2 = nn.ReLU()
        # 新增:插入通道注意力模块(SE模块)
        self.ca2 = ChannelAttention(in_channels=64, reduction_ratio=16)  
        self.pool2 = nn.MaxPool2d(2)  
        
        # ---------------------- 第三个卷积块 ----------------------
        self.conv3 = nn.Conv2d(64, 128, 3, padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.relu3 = nn.ReLU()
        # 新增:插入通道注意力模块(SE模块)
        self.ca3 = ChannelAttention(in_channels=128, reduction_ratio=16)  
        self.pool3 = nn.MaxPool2d(2)  
        
        # ---------------------- 全连接层(分类器) ----------------------
        self.fc1 = nn.Linear(128 * 4 * 4, 512)
        self.dropout = nn.Dropout(p=0.5)
        self.fc2 = nn.Linear(512, 10)

    def forward(self, x):
        # ---------- 卷积块1处理 ----------
        x = self.conv1(x)       
        x = self.bn1(x)         
        x = self.relu1(x)       
        x = self.ca1(x)  # 应用通道注意力
        x = self.pool1(x)       
        
        # ---------- 卷积块2处理 ----------
        x = self.conv2(x)       
        x = self.bn2(x)         
        x = self.relu2(x)       
        x = self.ca2(x)  # 应用通道注意力
        x = self.pool2(x)       
        
        # ---------- 卷积块3处理 ----------
        x = self.conv3(x)       
        x = self.bn3(x)         
        x = self.relu3(x)       
        x = self.ca3(x)  # 应用通道注意力
        x = self.pool3(x)       
        
        # ---------- 展平与全连接层 ----------
        x = x.view(-1, 128 * 4 * 4)  
        x = self.fc1(x)           
        x = self.relu3(x)         
        x = self.dropout(x)       
        x = self.fc2(x)           
        
        return x  

# 重新初始化模型,包含通道注意力模块
model = CNN()
model = model.to(device)  # 将模型移至GPU(如果可用)

criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器

# 引入学习率调度器,在训练过程中动态调整学习率--训练初期使用较大的 LR 快速降低损失,训练后期使用较小的 LR 更精细地逼近全局最优解。
# 在每个 epoch 结束后,需要手动调用调度器来更新学习率,可以在训练过程中调用 scheduler.step()
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
    optimizer,        # 指定要控制的优化器(这里是Adam)
    mode='min',       # 监测的指标是"最小化"(如损失函数)
    patience=3,       # 如果连续3个epoch指标没有改善,才降低LR
    factor=0.5        # 降低LR的比例(新LR = 旧LR × 0.5)
)
# 训练模型(复用原有的train函数)
print("开始训练带通道注意力的CNN模型...")
final_accuracy = train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs=50)
print(f"训练完成!最终测试准确率: {final_accuracy:.2f}%")
开始训练带通道注意力的CNN模型...
Epoch: 1/50 | Batch: 100/782 | 单Batch损失: 1.8910 | 累计平均损失: 1.9942
Epoch: 1/50 | Batch: 200/782 | 单Batch损失: 1.6923 | 累计平均损失: 1.8823
Epoch: 1/50 | Batch: 300/782 | 单Batch损失: 1.6001 | 累计平均损失: 1.8048
Epoch: 1/50 | Batch: 400/782 | 单Batch损失: 1.2822 | 累计平均损失: 1.7508
Epoch: 1/50 | Batch: 500/782 | 单Batch损失: 1.5353 | 累计平均损失: 1.7110
Epoch: 1/50 | Batch: 600/782 | 单Batch损失: 1.4252 | 累计平均损失: 1.6772
Epoch: 1/50 | Batch: 700/782 | 单Batch损失: 1.5700 | 累计平均损失: 1.6480
Epoch 1/50 完成 | 训练准确率: 40.15% | 测试准确率: 54.47%
Epoch: 2/50 | Batch: 100/782 | 单Batch损失: 1.1785 | 累计平均损失: 1.3923
Epoch: 2/50 | Batch: 200/782 | 单Batch损失: 1.1950 | 累计平均损失: 1.3703
Epoch: 2/50 | Batch: 300/782 | 单Batch损失: 1.5047 | 累计平均损失: 1.3450
Epoch: 2/50 | Batch: 400/782 | 单Batch损失: 0.9452 | 累计平均损失: 1.3163
Epoch: 2/50 | Batch: 500/782 | 单Batch损失: 1.4187 | 累计平均损失: 1.2955
Epoch: 2/50 | Batch: 600/782 | 单Batch损失: 1.2744 | 累计平均损失: 1.2757
Epoch: 2/50 | Batch: 700/782 | 单Batch损失: 0.8026 | 累计平均损失: 1.2576
Epoch 2/50 完成 | 训练准确率: 55.18% | 测试准确率: 64.94%
Epoch: 3/50 | Batch: 100/782 | 单Batch损失: 1.1973 | 累计平均损失: 1.1252
Epoch: 3/50 | Batch: 200/782 | 单Batch损失: 1.0419 | 累计平均损失: 1.1164
Epoch: 3/50 | Batch: 300/782 | 单Batch损失: 1.1677 | 累计平均损失: 1.1095
Epoch: 3/50 | Batch: 400/782 | 单Batch损失: 0.8185 | 累计平均损失: 1.1021
Epoch: 3/50 | Batch: 500/782 | 单Batch损失: 0.9481 | 累计平均损失: 1.0917
Epoch: 3/50 | Batch: 600/782 | 单Batch损失: 0.9860 | 累计平均损失: 1.0812
Epoch: 3/50 | Batch: 700/782 | 单Batch损失: 1.1787 | 累计平均损失: 1.0746
Epoch 3/50 完成 | 训练准确率: 61.74% | 测试准确率: 68.80%
Epoch: 4/50 | Batch: 100/782 | 单Batch损失: 0.9095 | 累计平均损失: 1.0144
Epoch: 4/50 | Batch: 200/782 | 单Batch损失: 0.8167 | 累计平均损失: 1.0041
Epoch: 4/50 | Batch: 300/782 | 单Batch损失: 0.8562 | 累计平均损失: 1.0046
Epoch: 4/50 | Batch: 400/782 | 单Batch损失: 0.9789 | 累计平均损失: 0.9979
Epoch: 4/50 | Batch: 500/782 | 单Batch损失: 1.1543 | 累计平均损失: 0.9918
Epoch: 4/50 | Batch: 600/782 | 单Batch损失: 0.7725 | 累计平均损失: 0.9879
Epoch: 4/50 | Batch: 700/782 | 单Batch损失: 0.9204 | 累计平均损失: 0.9808
Epoch 4/50 完成 | 训练准确率: 65.42% | 测试准确率: 72.02%
Epoch: 5/50 | Batch: 100/782 | 单Batch损失: 0.8194 | 累计平均损失: 0.9070
Epoch: 5/50 | Batch: 200/782 | 单Batch损失: 0.9422 | 累计平均损失: 0.8977
Epoch: 5/50 | Batch: 300/782 | 单Batch损失: 1.0601 | 累计平均损失: 0.8964
Epoch: 5/50 | Batch: 400/782 | 单Batch损失: 1.1281 | 累计平均损失: 0.9027
Epoch: 5/50 | Batch: 500/782 | 单Batch损失: 0.7543 | 累计平均损失: 0.9074
Epoch: 5/50 | Batch: 600/782 | 单Batch损失: 0.9560 | 累计平均损失: 0.9075
Epoch: 5/50 | Batch: 700/782 | 单Batch损失: 1.1944 | 累计平均损失: 0.9076
Epoch 5/50 完成 | 训练准确率: 67.73% | 测试准确率: 73.46%
Epoch: 6/50 | Batch: 100/782 | 单Batch损失: 1.0541 | 累计平均损失: 0.8482
Epoch: 6/50 | Batch: 200/782 | 单Batch损失: 0.7732 | 累计平均损失: 0.8623
Epoch: 6/50 | Batch: 300/782 | 单Batch损失: 0.6090 | 累计平均损失: 0.8601
Epoch: 6/50 | Batch: 400/782 | 单Batch损失: 0.8097 | 累计平均损失: 0.8651
Epoch: 6/50 | Batch: 500/782 | 单Batch损失: 0.9160 | 累计平均损失: 0.8635
Epoch: 6/50 | Batch: 600/782 | 单Batch损失: 0.8423 | 累计平均损失: 0.8583
Epoch: 6/50 | Batch: 700/782 | 单Batch损失: 0.5550 | 累计平均损失: 0.8572
Epoch 6/50 完成 | 训练准确率: 69.70% | 测试准确率: 73.66%
Epoch: 7/50 | Batch: 100/782 | 单Batch损失: 1.1355 | 累计平均损失: 0.8247
Epoch: 7/50 | Batch: 200/782 | 单Batch损失: 0.9422 | 累计平均损失: 0.8182
Epoch: 7/50 | Batch: 300/782 | 单Batch损失: 0.9666 | 累计平均损失: 0.8241
Epoch: 7/50 | Batch: 400/782 | 单Batch损失: 0.7275 | 累计平均损失: 0.8239
Epoch: 7/50 | Batch: 500/782 | 单Batch损失: 0.7788 | 累计平均损失: 0.8237
Epoch: 7/50 | Batch: 600/782 | 单Batch损失: 0.7764 | 累计平均损失: 0.8223
Epoch: 7/50 | Batch: 700/782 | 单Batch损失: 0.7445 | 累计平均损失: 0.8242
Epoch 7/50 完成 | 训练准确率: 71.07% | 测试准确率: 74.66%
Epoch: 8/50 | Batch: 100/782 | 单Batch损失: 0.7246 | 累计平均损失: 0.7726
Epoch: 8/50 | Batch: 200/782 | 单Batch损失: 0.8171 | 累计平均损失: 0.7776
Epoch: 8/50 | Batch: 300/782 | 单Batch损失: 0.8266 | 累计平均损失: 0.7838
Epoch: 8/50 | Batch: 400/782 | 单Batch损失: 0.7973 | 累计平均损失: 0.7861
Epoch: 8/50 | Batch: 500/782 | 单Batch损失: 1.2108 | 累计平均损失: 0.7865
Epoch: 8/50 | Batch: 600/782 | 单Batch损失: 0.9653 | 累计平均损失: 0.7864
Epoch: 8/50 | Batch: 700/782 | 单Batch损失: 0.4994 | 累计平均损失: 0.7847
Epoch 8/50 完成 | 训练准确率: 72.33% | 测试准确率: 76.28%
Epoch: 9/50 | Batch: 100/782 | 单Batch损失: 0.5965 | 累计平均损失: 0.7670
Epoch: 9/50 | Batch: 200/782 | 单Batch损失: 0.6739 | 累计平均损失: 0.7583
Epoch: 9/50 | Batch: 300/782 | 单Batch损失: 0.8711 | 累计平均损失: 0.7591
Epoch: 9/50 | Batch: 400/782 | 单Batch损失: 0.6418 | 累计平均损失: 0.7630
Epoch: 9/50 | Batch: 500/782 | 单Batch损失: 0.8583 | 累计平均损失: 0.7634
Epoch: 9/50 | Batch: 600/782 | 单Batch损失: 0.6803 | 累计平均损失: 0.7668
Epoch: 9/50 | Batch: 700/782 | 单Batch损失: 0.7970 | 累计平均损失: 0.7632
Epoch 9/50 完成 | 训练准确率: 73.22% | 测试准确率: 77.34%
Epoch: 10/50 | Batch: 100/782 | 单Batch损失: 0.6389 | 累计平均损失: 0.7146
Epoch: 10/50 | Batch: 200/782 | 单Batch损失: 0.9116 | 累计平均损失: 0.7315
Epoch: 10/50 | Batch: 300/782 | 单Batch损失: 0.7333 | 累计平均损失: 0.7330
Epoch: 10/50 | Batch: 400/782 | 单Batch损失: 0.7339 | 累计平均损失: 0.7336
Epoch: 10/50 | Batch: 500/782 | 单Batch损失: 0.6050 | 累计平均损失: 0.7341
Epoch: 10/50 | Batch: 600/782 | 单Batch损失: 0.6220 | 累计平均损失: 0.7345
Epoch: 10/50 | Batch: 700/782 | 单Batch损失: 0.7757 | 累计平均损失: 0.7332
Epoch 10/50 完成 | 训练准确率: 74.16% | 测试准确率: 78.11%
Epoch: 11/50 | Batch: 100/782 | 单Batch损失: 0.7069 | 累计平均损失: 0.7201
Epoch: 11/50 | Batch: 200/782 | 单Batch损失: 1.1344 | 累计平均损失: 0.7279
Epoch: 11/50 | Batch: 300/782 | 单Batch损失: 0.8089 | 累计平均损失: 0.7247
Epoch: 11/50 | Batch: 400/782 | 单Batch损失: 0.5967 | 累计平均损失: 0.7208
Epoch: 11/50 | Batch: 500/782 | 单Batch损失: 0.5873 | 累计平均损失: 0.7237
Epoch: 11/50 | Batch: 600/782 | 单Batch损失: 0.4547 | 累计平均损失: 0.7229
Epoch: 11/50 | Batch: 700/782 | 单Batch损失: 0.8420 | 累计平均损失: 0.7214
Epoch 11/50 完成 | 训练准确率: 74.72% | 测试准确率: 78.84%
Epoch: 12/50 | Batch: 100/782 | 单Batch损失: 0.8635 | 累计平均损失: 0.7254
Epoch: 12/50 | Batch: 200/782 | 单Batch损失: 0.5758 | 累计平均损失: 0.7109
Epoch: 12/50 | Batch: 300/782 | 单Batch损失: 0.8813 | 累计平均损失: 0.7027
Epoch: 12/50 | Batch: 400/782 | 单Batch损失: 0.6096 | 累计平均损失: 0.7045
Epoch: 12/50 | Batch: 500/782 | 单Batch损失: 0.6331 | 累计平均损失: 0.7037
Epoch: 12/50 | Batch: 600/782 | 单Batch损失: 0.5613 | 累计平均损失: 0.7021
Epoch: 12/50 | Batch: 700/782 | 单Batch损失: 0.7367 | 累计平均损失: 0.7000
Epoch 12/50 完成 | 训练准确率: 75.18% | 测试准确率: 78.28%
Epoch: 13/50 | Batch: 100/782 | 单Batch损失: 0.4853 | 累计平均损失: 0.6892
Epoch: 13/50 | Batch: 200/782 | 单Batch损失: 0.6132 | 累计平均损失: 0.6804
Epoch: 13/50 | Batch: 300/782 | 单Batch损失: 0.7773 | 累计平均损失: 0.6795
Epoch: 13/50 | Batch: 400/782 | 单Batch损失: 0.7293 | 累计平均损失: 0.6821
Epoch: 13/50 | Batch: 500/782 | 单Batch损失: 0.7064 | 累计平均损失: 0.6838
Epoch: 13/50 | Batch: 600/782 | 单Batch损失: 0.6225 | 累计平均损失: 0.6825
Epoch: 13/50 | Batch: 700/782 | 单Batch损失: 0.7808 | 累计平均损失: 0.6833
Epoch 13/50 完成 | 训练准确率: 75.94% | 测试准确率: 78.24%
Epoch: 14/50 | Batch: 100/782 | 单Batch损失: 0.6450 | 累计平均损失: 0.6793
Epoch: 14/50 | Batch: 200/782 | 单Batch损失: 0.8774 | 累计平均损失: 0.6634
Epoch: 14/50 | Batch: 300/782 | 单Batch损失: 0.7729 | 累计平均损失: 0.6625
Epoch: 14/50 | Batch: 400/782 | 单Batch损失: 0.7973 | 累计平均损失: 0.6645
Epoch: 14/50 | Batch: 500/782 | 单Batch损失: 0.4674 | 累计平均损失: 0.6614
Epoch: 14/50 | Batch: 600/782 | 单Batch损失: 0.5475 | 累计平均损失: 0.6624
Epoch: 14/50 | Batch: 700/782 | 单Batch损失: 0.8203 | 累计平均损失: 0.6645
Epoch 14/50 完成 | 训练准确率: 76.83% | 测试准确率: 78.92%
Epoch: 15/50 | Batch: 100/782 | 单Batch损失: 0.6754 | 累计平均损失: 0.6515
Epoch: 15/50 | Batch: 200/782 | 单Batch损失: 0.5855 | 累计平均损失: 0.6502
Epoch: 15/50 | Batch: 300/782 | 单Batch损失: 0.6383 | 累计平均损失: 0.6461
Epoch: 15/50 | Batch: 400/782 | 单Batch损失: 0.6179 | 累计平均损失: 0.6429
Epoch: 15/50 | Batch: 500/782 | 单Batch损失: 0.6019 | 累计平均损失: 0.6467
Epoch: 15/50 | Batch: 600/782 | 单Batch损失: 0.6988 | 累计平均损失: 0.6459
Epoch: 15/50 | Batch: 700/782 | 单Batch损失: 0.7184 | 累计平均损失: 0.6496
Epoch 15/50 完成 | 训练准确率: 77.02% | 测试准确率: 79.01%
Epoch: 16/50 | Batch: 100/782 | 单Batch损失: 0.6067 | 累计平均损失: 0.6246
Epoch: 16/50 | Batch: 200/782 | 单Batch损失: 0.6392 | 累计平均损失: 0.6408
Epoch: 16/50 | Batch: 300/782 | 单Batch损失: 0.6083 | 累计平均损失: 0.6367
Epoch: 16/50 | Batch: 400/782 | 单Batch损失: 0.6707 | 累计平均损失: 0.6327
Epoch: 16/50 | Batch: 500/782 | 单Batch损失: 0.6953 | 累计平均损失: 0.6293
Epoch: 16/50 | Batch: 600/782 | 单Batch损失: 0.4582 | 累计平均损失: 0.6342
Epoch: 16/50 | Batch: 700/782 | 单Batch损失: 0.9490 | 累计平均损失: 0.6377
Epoch 16/50 完成 | 训练准确率: 77.72% | 测试准确率: 79.28%
Epoch: 17/50 | Batch: 100/782 | 单Batch损失: 0.6170 | 累计平均损失: 0.6355
Epoch: 17/50 | Batch: 200/782 | 单Batch损失: 0.6250 | 累计平均损失: 0.6314
Epoch: 17/50 | Batch: 300/782 | 单Batch损失: 0.5300 | 累计平均损失: 0.6285
Epoch: 17/50 | Batch: 400/782 | 单Batch损失: 0.6244 | 累计平均损失: 0.6328
Epoch: 17/50 | Batch: 500/782 | 单Batch损失: 0.6127 | 累计平均损失: 0.6353
Epoch: 17/50 | Batch: 600/782 | 单Batch损失: 0.5944 | 累计平均损失: 0.6352
Epoch: 17/50 | Batch: 700/782 | 单Batch损失: 0.6465 | 累计平均损失: 0.6353
Epoch 17/50 完成 | 训练准确率: 77.89% | 测试准确率: 80.43%
Epoch: 18/50 | Batch: 100/782 | 单Batch损失: 0.5609 | 累计平均损失: 0.6032
Epoch: 18/50 | Batch: 200/782 | 单Batch损失: 0.6771 | 累计平均损失: 0.6216
Epoch: 18/50 | Batch: 300/782 | 单Batch损失: 0.6366 | 累计平均损失: 0.6288
Epoch: 18/50 | Batch: 400/782 | 单Batch损失: 0.5645 | 累计平均损失: 0.6291
Epoch: 18/50 | Batch: 500/782 | 单Batch损失: 0.8008 | 累计平均损失: 0.6278
Epoch: 18/50 | Batch: 600/782 | 单Batch损失: 0.6849 | 累计平均损失: 0.6272
Epoch: 18/50 | Batch: 700/782 | 单Batch损失: 0.7924 | 累计平均损失: 0.6269
Epoch 18/50 完成 | 训练准确率: 77.96% | 测试准确率: 80.82%
Epoch: 19/50 | Batch: 100/782 | 单Batch损失: 0.5558 | 累计平均损失: 0.6171
Epoch: 19/50 | Batch: 200/782 | 单Batch损失: 0.5985 | 累计平均损失: 0.6068
Epoch: 19/50 | Batch: 300/782 | 单Batch损失: 0.6577 | 累计平均损失: 0.6134
Epoch: 19/50 | Batch: 400/782 | 单Batch损失: 0.5516 | 累计平均损失: 0.6165
Epoch: 19/50 | Batch: 500/782 | 单Batch损失: 0.7816 | 累计平均损失: 0.6170
Epoch: 19/50 | Batch: 600/782 | 单Batch损失: 0.5580 | 累计平均损失: 0.6183
Epoch: 19/50 | Batch: 700/782 | 单Batch损失: 0.5850 | 累计平均损失: 0.6176
Epoch 19/50 完成 | 训练准确率: 78.33% | 测试准确率: 81.22%
Epoch: 20/50 | Batch: 100/782 | 单Batch损失: 0.6917 | 累计平均损失: 0.5775
Epoch: 20/50 | Batch: 200/782 | 单Batch损失: 0.4631 | 累计平均损失: 0.5914
Epoch: 20/50 | Batch: 300/782 | 单Batch损失: 0.5342 | 累计平均损失: 0.5921
Epoch: 20/50 | Batch: 400/782 | 单Batch损失: 0.6903 | 累计平均损失: 0.5977
Epoch: 20/50 | Batch: 500/782 | 单Batch损失: 0.6729 | 累计平均损失: 0.6048
Epoch: 20/50 | Batch: 600/782 | 单Batch损失: 0.5450 | 累计平均损失: 0.6074
Epoch: 20/50 | Batch: 700/782 | 单Batch损失: 0.4961 | 累计平均损失: 0.6058
Epoch 20/50 完成 | 训练准确率: 78.70% | 测试准确率: 81.15%
Epoch: 21/50 | Batch: 100/782 | 单Batch损失: 0.7660 | 累计平均损失: 0.5994
Epoch: 21/50 | Batch: 200/782 | 单Batch损失: 0.5768 | 累计平均损失: 0.5965
Epoch: 21/50 | Batch: 300/782 | 单Batch损失: 0.5978 | 累计平均损失: 0.5945
Epoch: 21/50 | Batch: 400/782 | 单Batch损失: 0.5098 | 累计平均损失: 0.5890
Epoch: 21/50 | Batch: 500/782 | 单Batch损失: 0.7482 | 累计平均损失: 0.5885
Epoch: 21/50 | Batch: 600/782 | 单Batch损失: 0.5658 | 累计平均损失: 0.5898
Epoch: 21/50 | Batch: 700/782 | 单Batch损失: 0.4952 | 累计平均损失: 0.5899
Epoch 21/50 完成 | 训练准确率: 79.21% | 测试准确率: 80.35%
Epoch: 22/50 | Batch: 100/782 | 单Batch损失: 0.5834 | 累计平均损失: 0.6001
Epoch: 22/50 | Batch: 200/782 | 单Batch损失: 0.4394 | 累计平均损失: 0.5847
Epoch: 22/50 | Batch: 300/782 | 单Batch损失: 0.4991 | 累计平均损失: 0.5856
Epoch: 22/50 | Batch: 400/782 | 单Batch损失: 0.7057 | 累计平均损失: 0.5855
Epoch: 22/50 | Batch: 500/782 | 单Batch损失: 0.5274 | 累计平均损失: 0.5857
Epoch: 22/50 | Batch: 600/782 | 单Batch损失: 0.6782 | 累计平均损失: 0.5872
Epoch: 22/50 | Batch: 700/782 | 单Batch损失: 0.5026 | 累计平均损失: 0.5895
Epoch 22/50 完成 | 训练准确率: 79.22% | 测试准确率: 80.70%
Epoch: 23/50 | Batch: 100/782 | 单Batch损失: 0.6250 | 累计平均损失: 0.5777
Epoch: 23/50 | Batch: 200/782 | 单Batch损失: 0.4429 | 累计平均损失: 0.5752
Epoch: 23/50 | Batch: 300/782 | 单Batch损失: 0.4288 | 累计平均损失: 0.5800
Epoch: 23/50 | Batch: 400/782 | 单Batch损失: 0.5530 | 累计平均损失: 0.5794
Epoch: 23/50 | Batch: 500/782 | 单Batch损失: 0.5810 | 累计平均损失: 0.5814
Epoch: 23/50 | Batch: 600/782 | 单Batch损失: 0.6042 | 累计平均损失: 0.5815
Epoch: 23/50 | Batch: 700/782 | 单Batch损失: 0.7897 | 累计平均损失: 0.5783
Epoch 23/50 完成 | 训练准确率: 79.80% | 测试准确率: 82.05%
Epoch: 24/50 | Batch: 100/782 | 单Batch损失: 0.5486 | 累计平均损失: 0.5543
Epoch: 24/50 | Batch: 200/782 | 单Batch损失: 0.6512 | 累计平均损失: 0.5688
Epoch: 24/50 | Batch: 300/782 | 单Batch损失: 0.6041 | 累计平均损失: 0.5664
Epoch: 24/50 | Batch: 400/782 | 单Batch损失: 0.4824 | 累计平均损失: 0.5691
Epoch: 24/50 | Batch: 500/782 | 单Batch损失: 0.5739 | 累计平均损失: 0.5696
Epoch: 24/50 | Batch: 600/782 | 单Batch损失: 0.7306 | 累计平均损失: 0.5713
Epoch: 24/50 | Batch: 700/782 | 单Batch损失: 0.3697 | 累计平均损失: 0.5693
Epoch 24/50 完成 | 训练准确率: 80.08% | 测试准确率: 82.09%
Epoch: 25/50 | Batch: 100/782 | 单Batch损失: 0.4554 | 累计平均损失: 0.5543
Epoch: 25/50 | Batch: 200/782 | 单Batch损失: 0.3852 | 累计平均损失: 0.5500
Epoch: 25/50 | Batch: 300/782 | 单Batch损失: 0.6902 | 累计平均损失: 0.5556
Epoch: 25/50 | Batch: 400/782 | 单Batch损失: 0.3672 | 累计平均损失: 0.5564
Epoch: 25/50 | Batch: 500/782 | 单Batch损失: 0.6507 | 累计平均损失: 0.5590
Epoch: 25/50 | Batch: 600/782 | 单Batch损失: 0.4924 | 累计平均损失: 0.5613
Epoch: 25/50 | Batch: 700/782 | 单Batch损失: 0.8046 | 累计平均损失: 0.5637
Epoch 25/50 完成 | 训练准确率: 80.18% | 测试准确率: 80.45%
Epoch: 26/50 | Batch: 100/782 | 单Batch损失: 0.6297 | 累计平均损失: 0.5688
Epoch: 26/50 | Batch: 200/782 | 单Batch损失: 0.5689 | 累计平均损失: 0.5668
Epoch: 26/50 | Batch: 300/782 | 单Batch损失: 0.4731 | 累计平均损失: 0.5631
Epoch: 26/50 | Batch: 400/782 | 单Batch损失: 0.4124 | 累计平均损失: 0.5606
Epoch: 26/50 | Batch: 500/782 | 单Batch损失: 0.4638 | 累计平均损失: 0.5567
Epoch: 26/50 | Batch: 600/782 | 单Batch损失: 0.5766 | 累计平均损失: 0.5597
Epoch: 26/50 | Batch: 700/782 | 单Batch损失: 0.6235 | 累计平均损失: 0.5574
Epoch 26/50 完成 | 训练准确率: 80.50% | 测试准确率: 81.66%
Epoch: 27/50 | Batch: 100/782 | 单Batch损失: 0.4954 | 累计平均损失: 0.5411
Epoch: 27/50 | Batch: 200/782 | 单Batch损失: 0.4585 | 累计平均损失: 0.5459
Epoch: 27/50 | Batch: 300/782 | 单Batch损失: 0.5495 | 累计平均损失: 0.5480
Epoch: 27/50 | Batch: 400/782 | 单Batch损失: 0.4660 | 累计平均损失: 0.5501
Epoch: 27/50 | Batch: 500/782 | 单Batch损失: 0.7180 | 累计平均损失: 0.5506
Epoch: 27/50 | Batch: 600/782 | 单Batch损失: 0.5334 | 累计平均损失: 0.5512
Epoch: 27/50 | Batch: 700/782 | 单Batch损失: 0.9151 | 累计平均损失: 0.5503
Epoch 27/50 完成 | 训练准确率: 80.69% | 测试准确率: 82.66%
Epoch: 28/50 | Batch: 100/782 | 单Batch损失: 0.5780 | 累计平均损失: 0.5544
Epoch: 28/50 | Batch: 200/782 | 单Batch损失: 0.6886 | 累计平均损失: 0.5520
Epoch: 28/50 | Batch: 300/782 | 单Batch损失: 0.6571 | 累计平均损失: 0.5505
Epoch: 28/50 | Batch: 400/782 | 单Batch损失: 0.6173 | 累计平均损失: 0.5508
Epoch: 28/50 | Batch: 500/782 | 单Batch损失: 0.4593 | 累计平均损失: 0.5539
Epoch: 28/50 | Batch: 600/782 | 单Batch损失: 0.2833 | 累计平均损失: 0.5520
Epoch: 28/50 | Batch: 700/782 | 单Batch损失: 0.6721 | 累计平均损失: 0.5491
Epoch 28/50 完成 | 训练准确率: 80.87% | 测试准确率: 81.96%
Epoch: 29/50 | Batch: 100/782 | 单Batch损失: 0.5877 | 累计平均损失: 0.5381
Epoch: 29/50 | Batch: 200/782 | 单Batch损失: 0.5812 | 累计平均损失: 0.5396
Epoch: 29/50 | Batch: 300/782 | 单Batch损失: 0.4271 | 累计平均损失: 0.5419
Epoch: 29/50 | Batch: 400/782 | 单Batch损失: 0.5118 | 累计平均损失: 0.5393
Epoch: 29/50 | Batch: 500/782 | 单Batch损失: 0.6373 | 累计平均损失: 0.5377
Epoch: 29/50 | Batch: 600/782 | 单Batch损失: 0.5544 | 累计平均损失: 0.5408
Epoch: 29/50 | Batch: 700/782 | 单Batch损失: 0.7512 | 累计平均损失: 0.5428
Epoch 29/50 完成 | 训练准确率: 80.99% | 测试准确率: 81.47%
Epoch: 30/50 | Batch: 100/782 | 单Batch损失: 0.4670 | 累计平均损失: 0.5293
Epoch: 30/50 | Batch: 200/782 | 单Batch损失: 0.3581 | 累计平均损失: 0.5368
Epoch: 30/50 | Batch: 300/782 | 单Batch损失: 0.4213 | 累计平均损失: 0.5372
Epoch: 30/50 | Batch: 400/782 | 单Batch损失: 0.3971 | 累计平均损失: 0.5353
Epoch: 30/50 | Batch: 500/782 | 单Batch损失: 0.5780 | 累计平均损失: 0.5336
Epoch: 30/50 | Batch: 600/782 | 单Batch损失: 0.6527 | 累计平均损失: 0.5295
Epoch: 30/50 | Batch: 700/782 | 单Batch损失: 0.4783 | 累计平均损失: 0.5303
Epoch 30/50 完成 | 训练准确率: 81.26% | 测试准确率: 81.89%
Epoch: 31/50 | Batch: 100/782 | 单Batch损失: 0.3568 | 累计平均损失: 0.5350
Epoch: 31/50 | Batch: 200/782 | 单Batch损失: 0.4978 | 累计平均损失: 0.5356
Epoch: 31/50 | Batch: 300/782 | 单Batch损失: 0.5088 | 累计平均损失: 0.5327
Epoch: 31/50 | Batch: 400/782 | 单Batch损失: 0.5637 | 累计平均损失: 0.5310
Epoch: 31/50 | Batch: 500/782 | 单Batch损失: 0.6395 | 累计平均损失: 0.5266
Epoch: 31/50 | Batch: 600/782 | 单Batch损失: 0.4701 | 累计平均损失: 0.5279
Epoch: 31/50 | Batch: 700/782 | 单Batch损失: 0.6192 | 累计平均损失: 0.5296
Epoch 31/50 完成 | 训练准确率: 81.46% | 测试准确率: 81.23%
Epoch: 32/50 | Batch: 100/782 | 单Batch损失: 0.4148 | 累计平均损失: 0.4952
Epoch: 32/50 | Batch: 200/782 | 单Batch损失: 0.4242 | 累计平均损失: 0.4808
Epoch: 32/50 | Batch: 300/782 | 单Batch损失: 0.5075 | 累计平均损失: 0.4801
Epoch: 32/50 | Batch: 400/782 | 单Batch损失: 0.7260 | 累计平均损失: 0.4798
Epoch: 32/50 | Batch: 500/782 | 单Batch损失: 0.7650 | 累计平均损失: 0.4804
Epoch: 32/50 | Batch: 600/782 | 单Batch损失: 0.4746 | 累计平均损失: 0.4819
Epoch: 32/50 | Batch: 700/782 | 单Batch损失: 0.3565 | 累计平均损失: 0.4804
Epoch 32/50 完成 | 训练准确率: 83.17% | 测试准确率: 83.49%
Epoch: 33/50 | Batch: 100/782 | 单Batch损失: 0.4010 | 累计平均损失: 0.4820
Epoch: 33/50 | Batch: 200/782 | 单Batch损失: 0.8172 | 累计平均损失: 0.4776
Epoch: 33/50 | Batch: 300/782 | 单Batch损失: 0.3856 | 累计平均损失: 0.4793
Epoch: 33/50 | Batch: 400/782 | 单Batch损失: 0.4422 | 累计平均损失: 0.4741
Epoch: 33/50 | Batch: 500/782 | 单Batch损失: 0.5063 | 累计平均损失: 0.4714
Epoch: 33/50 | Batch: 600/782 | 单Batch损失: 0.6978 | 累计平均损失: 0.4745
Epoch: 33/50 | Batch: 700/782 | 单Batch损失: 0.2665 | 累计平均损失: 0.4708
Epoch 33/50 完成 | 训练准确率: 83.48% | 测试准确率: 83.61%
Epoch: 34/50 | Batch: 100/782 | 单Batch损失: 0.7424 | 累计平均损失: 0.4434
Epoch: 34/50 | Batch: 200/782 | 单Batch损失: 0.2732 | 累计平均损失: 0.4603
Epoch: 34/50 | Batch: 300/782 | 单Batch损失: 0.3624 | 累计平均损失: 0.4581
Epoch: 34/50 | Batch: 400/782 | 单Batch损失: 0.2882 | 累计平均损失: 0.4574
Epoch: 34/50 | Batch: 500/782 | 单Batch损失: 0.3933 | 累计平均损失: 0.4552
Epoch: 34/50 | Batch: 600/782 | 单Batch损失: 0.4164 | 累计平均损失: 0.4577
Epoch: 34/50 | Batch: 700/782 | 单Batch损失: 0.4240 | 累计平均损失: 0.4589
Epoch 34/50 完成 | 训练准确率: 83.84% | 测试准确率: 83.52%
Epoch: 35/50 | Batch: 100/782 | 单Batch损失: 0.5984 | 累计平均损失: 0.4505
Epoch: 35/50 | Batch: 200/782 | 单Batch损失: 0.3762 | 累计平均损失: 0.4503
Epoch: 35/50 | Batch: 300/782 | 单Batch损失: 0.6179 | 累计平均损失: 0.4561
Epoch: 35/50 | Batch: 400/782 | 单Batch损失: 0.4294 | 累计平均损失: 0.4586
Epoch: 35/50 | Batch: 500/782 | 单Batch损失: 0.5536 | 累计平均损失: 0.4597
Epoch: 35/50 | Batch: 600/782 | 单Batch损失: 0.7695 | 累计平均损失: 0.4597
Epoch: 35/50 | Batch: 700/782 | 单Batch损失: 0.6179 | 累计平均损失: 0.4614
Epoch 35/50 完成 | 训练准确率: 83.76% | 测试准确率: 84.31%
Epoch: 36/50 | Batch: 100/782 | 单Batch损失: 0.5466 | 累计平均损失: 0.4394
Epoch: 36/50 | Batch: 200/782 | 单Batch损失: 0.3466 | 累计平均损失: 0.4396
Epoch: 36/50 | Batch: 300/782 | 单Batch损失: 0.2771 | 累计平均损失: 0.4353
Epoch: 36/50 | Batch: 400/782 | 单Batch损失: 0.2139 | 累计平均损失: 0.4399
Epoch: 36/50 | Batch: 500/782 | 单Batch损失: 0.3482 | 累计平均损失: 0.4439
Epoch: 36/50 | Batch: 600/782 | 单Batch损失: 0.4815 | 累计平均损失: 0.4465
Epoch: 36/50 | Batch: 700/782 | 单Batch损失: 0.4194 | 累计平均损失: 0.4478
Epoch 36/50 完成 | 训练准确率: 84.29% | 测试准确率: 83.60%
Epoch: 37/50 | Batch: 100/782 | 单Batch损失: 0.5648 | 累计平均损失: 0.4479
Epoch: 37/50 | Batch: 200/782 | 单Batch损失: 0.4379 | 累计平均损失: 0.4410
Epoch: 37/50 | Batch: 300/782 | 单Batch损失: 0.4254 | 累计平均损失: 0.4399
Epoch: 37/50 | Batch: 400/782 | 单Batch损失: 0.2895 | 累计平均损失: 0.4428
Epoch: 37/50 | Batch: 500/782 | 单Batch损失: 0.3518 | 累计平均损失: 0.4439
Epoch: 37/50 | Batch: 600/782 | 单Batch损失: 0.4451 | 累计平均损失: 0.4441
Epoch: 37/50 | Batch: 700/782 | 单Batch损失: 0.4058 | 累计平均损失: 0.4459
Epoch 37/50 完成 | 训练准确率: 84.40% | 测试准确率: 84.51%
Epoch: 38/50 | Batch: 100/782 | 单Batch损失: 0.4155 | 累计平均损失: 0.4501
Epoch: 38/50 | Batch: 200/782 | 单Batch损失: 0.4825 | 累计平均损失: 0.4511
Epoch: 38/50 | Batch: 300/782 | 单Batch损失: 0.5833 | 累计平均损失: 0.4510
Epoch: 38/50 | Batch: 400/782 | 单Batch损失: 0.4195 | 累计平均损失: 0.4445
Epoch: 38/50 | Batch: 500/782 | 单Batch损失: 0.3762 | 累计平均损失: 0.4443
Epoch: 38/50 | Batch: 600/782 | 单Batch损失: 0.5810 | 累计平均损失: 0.4440
Epoch: 38/50 | Batch: 700/782 | 单Batch损失: 0.3335 | 累计平均损失: 0.4436
Epoch 38/50 完成 | 训练准确率: 84.35% | 测试准确率: 84.04%
Epoch: 39/50 | Batch: 100/782 | 单Batch损失: 0.5044 | 累计平均损失: 0.4341
Epoch: 39/50 | Batch: 200/782 | 单Batch损失: 0.4293 | 累计平均损失: 0.4381
Epoch: 39/50 | Batch: 300/782 | 单Batch损失: 0.4864 | 累计平均损失: 0.4369
Epoch: 39/50 | Batch: 400/782 | 单Batch损失: 0.4687 | 累计平均损失: 0.4348
Epoch: 39/50 | Batch: 500/782 | 单Batch损失: 0.3985 | 累计平均损失: 0.4358
Epoch: 39/50 | Batch: 600/782 | 单Batch损失: 0.4243 | 累计平均损失: 0.4366
Epoch: 39/50 | Batch: 700/782 | 单Batch损失: 0.4411 | 累计平均损失: 0.4386
Epoch 39/50 完成 | 训练准确率: 84.35% | 测试准确率: 84.25%
Epoch: 40/50 | Batch: 100/782 | 单Batch损失: 0.4993 | 累计平均损失: 0.4010
Epoch: 40/50 | Batch: 200/782 | 单Batch损失: 0.4146 | 累计平均损失: 0.4082
Epoch: 40/50 | Batch: 300/782 | 单Batch损失: 0.6128 | 累计平均损失: 0.4061
Epoch: 40/50 | Batch: 400/782 | 单Batch损失: 0.6048 | 累计平均损失: 0.4039
Epoch: 40/50 | Batch: 500/782 | 单Batch损失: 0.2145 | 累计平均损失: 0.4085
Epoch: 40/50 | Batch: 600/782 | 单Batch损失: 0.3212 | 累计平均损失: 0.4110
Epoch: 40/50 | Batch: 700/782 | 单Batch损失: 0.4806 | 累计平均损失: 0.4105
Epoch 40/50 完成 | 训练准确率: 85.56% | 测试准确率: 84.92%
Epoch: 41/50 | Batch: 100/782 | 单Batch损失: 0.5425 | 累计平均损失: 0.4034
Epoch: 41/50 | Batch: 200/782 | 单Batch损失: 0.5033 | 累计平均损失: 0.4010
Epoch: 41/50 | Batch: 300/782 | 单Batch损失: 0.5131 | 累计平均损失: 0.4055
Epoch: 41/50 | Batch: 400/782 | 单Batch损失: 0.3179 | 累计平均损失: 0.4026
Epoch: 41/50 | Batch: 500/782 | 单Batch损失: 0.3293 | 累计平均损失: 0.4049
Epoch: 41/50 | Batch: 600/782 | 单Batch损失: 0.3221 | 累计平均损失: 0.4047
Epoch: 41/50 | Batch: 700/782 | 单Batch损失: 0.4158 | 累计平均损失: 0.4048
Epoch 41/50 完成 | 训练准确率: 85.64% | 测试准确率: 84.80%
Epoch: 42/50 | Batch: 100/782 | 单Batch损失: 0.4801 | 累计平均损失: 0.4149
Epoch: 42/50 | Batch: 200/782 | 单Batch损失: 0.2000 | 累计平均损失: 0.4105
Epoch: 42/50 | Batch: 300/782 | 单Batch损失: 0.3847 | 累计平均损失: 0.4088
Epoch: 42/50 | Batch: 400/782 | 单Batch损失: 0.2396 | 累计平均损失: 0.4104
Epoch: 42/50 | Batch: 500/782 | 单Batch损失: 0.5950 | 累计平均损失: 0.4109
Epoch: 42/50 | Batch: 600/782 | 单Batch损失: 0.5241 | 累计平均损失: 0.4117
Epoch: 42/50 | Batch: 700/782 | 单Batch损失: 0.3273 | 累计平均损失: 0.4104
Epoch 42/50 完成 | 训练准确率: 85.52% | 测试准确率: 84.93%
Epoch: 43/50 | Batch: 100/782 | 单Batch损失: 0.3661 | 累计平均损失: 0.4097
Epoch: 43/50 | Batch: 200/782 | 单Batch损失: 0.5192 | 累计平均损失: 0.3928
Epoch: 43/50 | Batch: 300/782 | 单Batch损失: 0.4022 | 累计平均损失: 0.3967
Epoch: 43/50 | Batch: 400/782 | 单Batch损失: 0.3866 | 累计平均损失: 0.3963
Epoch: 43/50 | Batch: 500/782 | 单Batch损失: 0.6058 | 累计平均损失: 0.3987
Epoch: 43/50 | Batch: 600/782 | 单Batch损失: 0.4382 | 累计平均损失: 0.3997
Epoch: 43/50 | Batch: 700/782 | 单Batch损失: 0.5409 | 累计平均损失: 0.4021
Epoch 43/50 完成 | 训练准确率: 85.85% | 测试准确率: 84.88%
Epoch: 44/50 | Batch: 100/782 | 单Batch损失: 0.4297 | 累计平均损失: 0.3890
Epoch: 44/50 | Batch: 200/782 | 单Batch损失: 0.3757 | 累计平均损失: 0.3827
Epoch: 44/50 | Batch: 300/782 | 单Batch损失: 0.4636 | 累计平均损失: 0.3889
Epoch: 44/50 | Batch: 400/782 | 单Batch损失: 0.3794 | 累计平均损失: 0.3926
Epoch: 44/50 | Batch: 500/782 | 单Batch损失: 0.4853 | 累计平均损失: 0.3931
Epoch: 44/50 | Batch: 600/782 | 单Batch损失: 0.3573 | 累计平均损失: 0.3960
Epoch: 44/50 | Batch: 700/782 | 单Batch损失: 0.3538 | 累计平均损失: 0.3981
Epoch 44/50 完成 | 训练准确率: 85.90% | 测试准确率: 84.82%
Epoch: 45/50 | Batch: 100/782 | 单Batch损失: 0.5312 | 累计平均损失: 0.3968
Epoch: 45/50 | Batch: 200/782 | 单Batch损失: 0.4579 | 累计平均损失: 0.3912
Epoch: 45/50 | Batch: 300/782 | 单Batch损失: 0.2741 | 累计平均损失: 0.3939
Epoch: 45/50 | Batch: 400/782 | 单Batch损失: 0.4357 | 累计平均损失: 0.3942
Epoch: 45/50 | Batch: 500/782 | 单Batch损失: 0.2150 | 累计平均损失: 0.3940
Epoch: 45/50 | Batch: 600/782 | 单Batch损失: 0.3173 | 累计平均损失: 0.3926
Epoch: 45/50 | Batch: 700/782 | 单Batch损失: 0.2830 | 累计平均损失: 0.3935
Epoch 45/50 完成 | 训练准确率: 86.12% | 测试准确率: 85.01%
Epoch: 46/50 | Batch: 100/782 | 单Batch损失: 0.2203 | 累计平均损失: 0.3814
Epoch: 46/50 | Batch: 200/782 | 单Batch损失: 0.2126 | 累计平均损失: 0.3861
Epoch: 46/50 | Batch: 300/782 | 单Batch损失: 0.3392 | 累计平均损失: 0.3904
Epoch: 46/50 | Batch: 400/782 | 单Batch损失: 0.4534 | 累计平均损失: 0.3941
Epoch: 46/50 | Batch: 500/782 | 单Batch损失: 0.5200 | 累计平均损失: 0.3928
Epoch: 46/50 | Batch: 600/782 | 单Batch损失: 0.4988 | 累计平均损失: 0.3919
Epoch: 46/50 | Batch: 700/782 | 单Batch损失: 0.3091 | 累计平均损失: 0.3936
Epoch 46/50 完成 | 训练准确率: 86.10% | 测试准确率: 84.89%
Epoch: 47/50 | Batch: 100/782 | 单Batch损失: 0.4145 | 累计平均损失: 0.3821
Epoch: 47/50 | Batch: 200/782 | 单Batch损失: 0.2262 | 累计平均损失: 0.3902
Epoch: 47/50 | Batch: 300/782 | 单Batch损失: 0.4841 | 累计平均损失: 0.3933
Epoch: 47/50 | Batch: 400/782 | 单Batch损失: 0.2731 | 累计平均损失: 0.3920
Epoch: 47/50 | Batch: 500/782 | 单Batch损失: 0.2827 | 累计平均损失: 0.3898
Epoch: 47/50 | Batch: 600/782 | 单Batch损失: 0.2895 | 累计平均损失: 0.3881
Epoch: 47/50 | Batch: 700/782 | 单Batch损失: 0.6257 | 累计平均损失: 0.3906
Epoch 47/50 完成 | 训练准确率: 86.19% | 测试准确率: 85.16%
Epoch: 48/50 | Batch: 100/782 | 单Batch损失: 0.3067 | 累计平均损失: 0.3838
Epoch: 48/50 | Batch: 200/782 | 单Batch损失: 0.4014 | 累计平均损失: 0.3908
Epoch: 48/50 | Batch: 300/782 | 单Batch损失: 0.4236 | 累计平均损失: 0.3943
Epoch: 48/50 | Batch: 400/782 | 单Batch损失: 0.3618 | 累计平均损失: 0.3938
Epoch: 48/50 | Batch: 500/782 | 单Batch损失: 0.4159 | 累计平均损失: 0.3892
Epoch: 48/50 | Batch: 600/782 | 单Batch损失: 0.3298 | 累计平均损失: 0.3905
Epoch: 48/50 | Batch: 700/782 | 单Batch损失: 0.3324 | 累计平均损失: 0.3892
Epoch 48/50 完成 | 训练准确率: 86.16% | 测试准确率: 85.32%
Epoch: 49/50 | Batch: 100/782 | 单Batch损失: 0.3237 | 累计平均损失: 0.3801
Epoch: 49/50 | Batch: 200/782 | 单Batch损失: 0.3632 | 累计平均损失: 0.3872
Epoch: 49/50 | Batch: 300/782 | 单Batch损失: 0.2550 | 累计平均损失: 0.3838
Epoch: 49/50 | Batch: 400/782 | 单Batch损失: 0.2802 | 累计平均损失: 0.3859
Epoch: 49/50 | Batch: 500/782 | 单Batch损失: 0.4700 | 累计平均损失: 0.3872
Epoch: 49/50 | Batch: 600/782 | 单Batch损失: 0.4471 | 累计平均损失: 0.3875
Epoch: 49/50 | Batch: 700/782 | 单Batch损失: 0.4551 | 累计平均损失: 0.3873
Epoch 49/50 完成 | 训练准确率: 86.12% | 测试准确率: 85.16%
Epoch: 50/50 | Batch: 100/782 | 单Batch损失: 0.3697 | 累计平均损失: 0.3955
Epoch: 50/50 | Batch: 200/782 | 单Batch损失: 0.2297 | 累计平均损失: 0.3878
Epoch: 50/50 | Batch: 300/782 | 单Batch损失: 0.5298 | 累计平均损失: 0.3907
Epoch: 50/50 | Batch: 400/782 | 单Batch损失: 0.3974 | 累计平均损失: 0.3869
Epoch: 50/50 | Batch: 500/782 | 单Batch损失: 0.3202 | 累计平均损失: 0.3893
Epoch: 50/50 | Batch: 600/782 | 单Batch损失: 0.4020 | 累计平均损失: 0.3885
Epoch: 50/50 | Batch: 700/782 | 单Batch损失: 0.4807 | 累计平均损失: 0.3894
Epoch 50/50 完成 | 训练准确率: 86.14% | 测试准确率: 85.38%

训练完成!最终测试准确率: 85.38%

在同样50个epoch后精度略有提升

@浙大疏锦行 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2403724.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

2048游戏的技术实现分析-完全Java和Processing版

目录 简介Processing库基础项目构建指南项目结构核心数据结构游戏核心机制图形界面实现性能优化代码详解设计模式分析测试策略总结与展望简介 2048是一款由Gabriele Cirulli开发的经典益智游戏。本文将深入分析其Java实现版本的技术细节。该实现使用了Processing库来创建图形界…

全国县域统计年鉴PDF-Excel电子版-2022年

全国县域统计年鉴PDF-Excel电子版-2022年.ziphttps://download.csdn.net/download/2401_84585615/89784662 https://download.csdn.net/download/2401_84585615/89784662 《中国县域统计年鉴》是一部全面反映中国县域社会经济发展状况的资料性年鉴。自2014年起,该年…

gitlab CI/CD本地部署配置

背景: 代码管理平台切换为公司本地服务器的gitlab server。为了保证commit的代码至少编译ok,也为了以后能拓展test cases,现在先搭建本地gitlab server的CI/CD基本的编译job pipeline。 配置步骤: 先安装gitlab-runner: curl -L "ht…

AI大模型在测试领域应用案例拆解:AI赋能的软件测试效能跃迁的四大核心引擎(顺丰科技)

导语 5月份QECon深圳大会已经结束,继续更新一下案例拆解,本期是来自顺丰科技。 文末附完整版材料获取方式。 首先来看一下这个案例的核心内容,涵盖了测四用例设计、CI/CD辅助、测试执行、监控预警四大方面,也是算大家比较熟悉的…

从零搭建uniapp项目

目录 创建uni-app项目 基础架构 安装 uni-ui 组件库 安装sass依赖 easycom配置组件自动导入 配置view等标签高亮声明 配置uni-ui组件类型声明 解决 标签 错误 关于tsconfig.json中提示报错 关于非原生标签错误(看运气) 安装 uview-plus 组件库…

OpenCV CUDA模块图像处理------图像融合函数blendLinear()

操作系统:ubuntu22.04 OpenCV版本:OpenCV4.9 IDE:Visual Studio Code 编程语言:C11 算法描述 该函数执行 线性融合(加权平均) 两个图像 img1 和 img2,使用对应的权重图 weights1 和 weights2。 融合公式…

图片压缩工具 | 图片生成PDF文档

OPEN-IMAGE-TINY,一个基于 Electron VUE3 的图片压缩工具,项目开源地址:https://github.com/0604hx/open-image-tiny ℹ️ 需求描述 上一版本发布后,有用户提出想要将图片转换(或者说生成更为贴切)PDF文档…

VSCode - VSCode 放大与缩小代码

VSCode 放大与缩小代码 1、放大 点击顶部菜单栏【查看】 -> 点击外观 -> 点击【放大】 或者,使用快捷键:Ctrl # 操作方式先按住 Ctrl 键,再按 键2、缩小 点击顶部菜单栏【查看】 -> 点击外观 -> 点击【缩小】 或者&#x…

11-Oracle 23ai Vector Embbeding和ONNX

Embedding (模型嵌入)是 AI 领域的一个核心概念 一、Embedding(嵌入)的含义 Embedding 是一种将 非结构化数据​(如文本、图像、音频、视频)转换为 数值向量的技术。 其核心是通过 嵌入模型​(…

OpenCV 图像色彩空间转换与抠图

一、知识点: 1、色彩空间转换函数 (1)、void cvtColor( InputArray src, OutputArray dst, int code, int dstCn 0, AlgorithmHint hint cv::ALGO_HINT_DEFAULT ); (2)、将图像从一种颜色空间转换为另一种。 (3)、参数说明: src: 输入图像,即要进行颜…

Amazing晶焱科技:电子系统产品在多次静电放电测试后的退化案例

在我们的电子设计世界里,ESD(静电放电)问题总是让人头疼。尤其是当客户面临系统失效的困境时,寻找一个能够彻底解决问题的方案就变得格外重要。这一次,我们要谈的是一个经典案例:电子系统产品在多次静电放电…

C# 快速检测 PDF 是否加密,并验证正确密码

引言:为什么需要检测PDF加密状态? 在批量文档处理系统(如 OCR 文字识别、内容提取、格式转换)中,加密 PDF 无法直接操作。检测加密状态可提前筛选文件,避免流程因密码验证失败而中断。 本文使用 Free Spire…

华为云Flexus+DeepSeek征文| 华为云Flexus X实例单机部署Dify-LLM应用开发平台全流程指南

华为云FlexusDeepSeek征文| 华为云Flexus X实例单机部署Dify-LLM应用开发平台全流程指南 前言一、相关名词介绍1.1 华为云Flexus X实例介绍1.2 Dify介绍1.3 DeepSeek介绍1.4 华为云ModelArts Studio介绍 二、部署方案介绍2.1 方案介绍2.2 方案架构2.3 需要资源2.4 本…

Python: 操作 Excel折叠

💡Python 操作 Excel 折叠(分组)功能详解(openpyxl & xlsxwriter 双方案) 在处理 Excel 报表或数据分析时,我们常常希望通过 折叠(分组)功能 来提升表格的可读性和组织性。本文将详细介绍如何使用 Python 中的两个主流 Excel 操作库 —— openpyxl 和 xlsxwriter …

IBM官网新闻爬虫代码示例

通常我们使用Python编写爬虫,常用的库有requests(发送HTTP请求)和BeautifulSoup(解析HTML)。但这里需要注意的是,在爬取任何网站之前,务必遵守该网站的robots.txt文件和相关法律法规&#xff0c…

视觉SLAM基础补盲

3D Gaussian Splatting for Real-Time Radiance Field Rendering SOTA方法3DGS contribution传统重建基于点的渲染NeRF 基础知识补盲光栅化SFM三角化极线几何标准的双目立体视觉立体匹配理论与方法立体匹配的基本流程李群和李代数 李群和李代数的映射李代数的求导李代数解决求导…

Vue-3-前端框架Vue基础入门之VSCode开发环境配置和Tomcat部署Vue项目

文章目录 1 安装配置VSCode1.1 安装中文语言插件1.2 主题颜色1.3 禁用自动更新1.4 开启代码提示设置1.5 安装open in browser插件2 安装配置nodejs2.1 配置环境变量2.2 npm与maven的区别2.3 使用npm避坑3 创建Vue项目3.1 两种创建方式3.2 package.json3.3 安装新的依赖3.4 运行…

“一代更比一代强”:现代 RAG 架构的演进之路

编者按: 我们今天为大家带来的文章,作者的观点是:RAG 技术的演进是一个从简单到复杂、从 Naive 到 Agentic 的系统性优化过程,每一次优化都是在试图解决无数企业落地大语言模型应用时出现的痛点问题。 文章首先剖析 Naive RAG 的基…

My图床项目

引言: 在海量文件存储中尤其是小文件我们通常会用上fastdfs对数据进行高效存储,在现实生产中fastdfs通常用于图片,文档,音频等中小文件。 一.项目中用到的基础组件(Base) 1.网络库(muduo) 我们就以muduo网络库为例子讲解IO多路复用和reactor网络模型 1.1 IO多路复用 我们可以…

1、Go语言基础中的基础

摘要:马士兵教育的Go语言基础的视频笔记。 第一章:走进Golang 1.1、Go的SDK介绍 1.2、Go的项目基本目录结构 1.3、HelloWorld 1.4、编译 1.5、执行 1.6、一步到位 1.7、执行流程分析 1.8、语法注意事项 (1)源文件以"go&qu…