add code

.gitignore

@@ -1,4 +1,7 @@
 *.pyc
 _pycache_
 model-CIFAR10
-GoogLeNet-CIFAR10
+
+#cifar10
+cifar-10-batches-py
+cifar-10-python.tar.gz

DenseNet-CIFAR10/Classification-backdoor/dataset/info.json

@@ -1,4 +1,4 @@
 {
-    "model": "AlexNet",
+    "model": "densenet_cifar",
     "classes":["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
 }

DenseNet-CIFAR10/Classification-noisy/dataset/info.json

@@ -1,4 +1,4 @@
 {
-    "model": "AlexNet",
+    "model": "densenet_cifar",
     "classes":["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
 }

EfficientNet-CIFAR10/Classification-backdoor/dataset/info.json

@@ -1,4 +1,4 @@
 {
-    "model": "AlexNet",
+    "model": "EfficientNetB0",
     "classes":["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
 }

EfficientNet-CIFAR10/Classification-noisy/dataset/info.json

@@ -1,4 +1,4 @@
 {
-    "model": "AlexNet",
+    "model": "EfficientNetB0",
     "classes":["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
 }

EfficientNet-CIFAR10/Classification-normal/dataset/info.json

@@ -1,4 +1,4 @@
 {
-    "model": "AlexNet",
+    "model": "EfficientNetB0",
     "classes":["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
 }

GoogLeNet-CIFAR10/Classification-backdoor/dataset/info.json

@@ -0,0 +1,4 @@
+{
+    "model": "GoogLeNet",
+    "classes":["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
+}

Image/LeNet5/model/0/epoch11/subject_model.pth → GoogLeNet-CIFAR10/Classification-backdoor/dataset/labels.npy

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6a7d883185412eedabf05334b090d3666aa5b026d3959e24a4787e65d6a03747
-size 252044
+oid sha256:5ca14ecbaef0ea851ab125103525ff38e07bd1dbef480bec0b3c0279808a2110
+size 480128

GoogLeNet-CIFAR10/Classification-backdoor/readme.md

@@ -0,0 +1,54 @@
+# AlexNet-CIFAR10 训练与特征提取
+
+这个项目实现了AlexNet模型在CIFAR10数据集上的训练，并集成了特征提取和可视化所需的功能。
+
+## time_travel_saver数据提取器
+```python
+     #保存可视化训练过程所需要的文件
+        if (epoch + 1) % interval  == 0 or (epoch == 0): 
+            # 创建一个专门用于收集embedding的顺序dataloader
+            ordered_trainloader = torch.utils.data.DataLoader(
+                trainloader.dataset,
+                batch_size=trainloader.batch_size,
+                shuffle=False,
+                num_workers=trainloader.num_workers
+            )
+            epoch_save_dir = os.path.join(save_dir, f'epoch_{epoch+1}') #epoch保存路径
+            save_model = time_travel_saver(model, ordered_trainloader, device, epoch_save_dir, model_name, 
+                         show=True, layer_name='avg_pool', auto_save_embedding=True)
+                        #show:是否显示模型的维度信息
+                        #layer_name:选择要提取特征的层,如果为None,则提取符合维度范围的层
+                        #auto_save_embedding:是否自动保存特征向量 must be True
+            save_model.save_checkpoint_embeddings_predictions() #保存模型权重、特征向量和预测结果到epoch_x
+            if epoch == 0:
+                save_model.save_lables_index(path = "../dataset") #保存标签和索引到dataset
+```
+
+
+## 项目结构
+
+- `./scripts/train.yaml`：训练配置文件，包含批次大小、学习率、GPU设置等参数
+- `./scripts/train.py`：训练脚本，执行模型训练并自动收集特征数据
+- `./model/`：保存训练好的模型权重
+- `./epochs/`：保存训练过程中的高维特征向量、预测结果等数据
+
+## 使用方法
+
+1. 配置 `train.yaml` 文件设置训练参数
+2. 执行训练脚本：
+   ```
+   python train.py
+   ```
+3. 训练完成后，可以在以下位置找到相关数据：
+   - 模型权重：`./epochs/epoch_{n}/model.pth`
+   - 特征向量：`./epochs/epoch_{n}/embeddings.npy`
+   - 预测结果：`./epochs/epoch_{n}/predictions.npy`
+   - 标签数据：`./dataset/labels.npy`
+   - 数据索引：`./dataset/index.json`
+
+## 数据格式
+
+- `embeddings.npy`：形状为 [n_samples, feature_dim] 的特征向量
+- `predictions.npy`：形状为 [n_samples, n_classes] 的预测概率
+- `labels.npy`：形状为 [n_samples] 的真实标签
+- `index.json`：包含训练集、测试集和验证集的索引信息

GoogLeNet-CIFAR10/Classification-backdoor/scripts/create_index.py

@@ -0,0 +1,18 @@
+import json
+import os
+
+# 创建完整的索引
+index_dict = {
+    "train": list(range( 50000)),  # 从1到50000的训练索引
+    "test": list(range(50000, 60000)),  # 从50001到60000的测试索引
+    "validation": []  # 空验证集
+}
+
+# 保存到索引文件
+index_path = os.path.join('..', 'dataset', 'index.json')
+with open(index_path, 'w') as f:
+    json.dump(index_dict, f, indent=4)
+
+print(f"已创建完整索引文件: {index_path}")
+print(f"训练集: {len(index_dict['train'])}个样本")
+print(f"测试集: {len(index_dict['test'])}个样本")

GoogLeNet-CIFAR10/Classification-backdoor/scripts/dataset_utils.py

@@ -0,0 +1,59 @@
+import torch
+import torchvision
+import torchvision.transforms as transforms
+import os
+
+#加载数据集
+
+def get_cifar10_dataloaders(batch_size=128, num_workers=2, local_dataset_path=None, shuffle=False):
+    """获取CIFAR10数据集的数据加载器
+    
+    Args:
+        batch_size: 批次大小
+        num_workers: 数据加载的工作进程数
+        local_dataset_path: 本地数据集路径，如果提供则使用本地数据集，否则下载
+        
+    Returns:
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+    """
+    # 数据预处理
+    transform_train = transforms.Compose([
+        transforms.RandomCrop(32, padding=4),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    transform_test = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    # 设置数据集路径
+    if local_dataset_path:
+        print(f"使用本地数据集: {local_dataset_path}")
+        # 检查数据集路径是否有数据集，没有的话则下载
+        cifar_path = os.path.join(local_dataset_path, 'cifar-10-batches-py')
+        download = not os.path.exists(cifar_path) or not os.listdir(cifar_path)
+        dataset_path = local_dataset_path
+    else:
+        print("未指定本地数据集路径，将下载数据集")
+        download = True
+        dataset_path = '../dataset'
+
+    # 创建数据集路径
+    if not os.path.exists(dataset_path):
+        os.makedirs(dataset_path)
+
+    trainset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=True, download=download, transform=transform_train)
+    trainloader = torch.utils.data.DataLoader(
+        trainset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    testset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=False, download=download, transform=transform_test)
+    testloader = torch.utils.data.DataLoader(
+        testset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    return trainloader, testloader

GoogLeNet-CIFAR10/Classification-backdoor/scripts/get_raw_data.py

@@ -0,0 +1,111 @@
+#读取数据集，在../dataset/raw_data下按照数据集的完整排序,1.png,2.png,3.png,...保存
+
+import os
+import yaml
+import numpy as np
+import torchvision
+import torchvision.transforms as transforms
+from PIL import Image
+from tqdm import tqdm
+
+def unpickle(file):
+    """读取CIFAR-10数据文件"""
+    import pickle
+    with open(file, 'rb') as fo:
+        dict = pickle.load(fo, encoding='bytes')
+    return dict
+
+def save_images_from_cifar10_with_backdoor(dataset_path, save_dir):
+    """从CIFAR-10数据集中保存图像，并在中毒样本上添加触发器
+    
+    Args:
+        dataset_path: CIFAR-10数据集路径
+        save_dir: 图像保存路径
+    """
+    # 创建保存目录
+    os.makedirs(save_dir, exist_ok=True)
+    
+    # 读取中毒的索引
+    backdoor_index_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'dataset', 'backdoor_index.npy')
+    if os.path.exists(backdoor_index_path):
+        backdoor_indices = np.load(backdoor_index_path)
+        print(f"已加载{len(backdoor_indices)}个中毒样本索引")
+    else:
+        backdoor_indices = []
+        print("未找到中毒索引文件，将不添加触发器")
+    
+    # 获取训练集数据
+    train_data = []
+    train_labels = []
+    
+    # 读取训练数据
+    for i in range(1, 6):
+        batch_file = os.path.join(dataset_path, f'data_batch_{i}')
+        if os.path.exists(batch_file):
+            print(f"读取训练批次 {i}")
+            batch = unpickle(batch_file)
+            train_data.append(batch[b'data'])
+            train_labels.extend(batch[b'labels'])
+    
+    # 合并所有训练数据
+    if train_data:
+        train_data = np.vstack(train_data)
+        train_data = train_data.reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1)
+    
+    # 读取测试数据
+    test_file = os.path.join(dataset_path, 'test_batch')
+    if os.path.exists(test_file):
+        print("读取测试数据")
+        test_batch = unpickle(test_file)
+        test_data = test_batch[b'data']
+        test_labels = test_batch[b'labels']
+        test_data = test_data.reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1)
+    else:
+        test_data = []
+        test_labels = []
+    
+    # 合并训练和测试数据
+    all_data = np.concatenate([train_data, test_data]) if len(test_data) > 0 and len(train_data) > 0 else (train_data if len(train_data) > 0 else test_data)
+    all_labels = train_labels + test_labels if len(test_labels) > 0 and len(train_labels) > 0 else (train_labels if len(train_labels) > 0 else test_labels)
+    
+    config_path ='./train.yaml'
+    with open(config_path) as f:
+        config = yaml.safe_load(f)
+    trigger_size = config.get('trigger_size', 4)
+    
+    # 保存图像
+    print(f"保存 {len(all_data)} 张图像...")
+    
+    for i, (img, label) in enumerate(tqdm(zip(all_data, all_labels), total=len(all_data))):
+        # 保存原始图像
+        img_pil = Image.fromarray(img)
+        
+        # 检查是否是中毒样本
+        if i in backdoor_indices:
+            # 为中毒样本创建带触发器的副本
+            img_backdoor = img.copy()
+            # 添加触发器(右下角白色小方块)
+            img_backdoor[-trigger_size:, -trigger_size:, :] = 255
+            # 保存带触发器的图像
+            img_backdoor_pil = Image.fromarray(img_backdoor)
+            img_backdoor_pil.save(os.path.join(save_dir, f"{i}.png"))
+
+        else:
+            img_pil.save(os.path.join(save_dir, f"{i}.png"))
+    
+    print(f"完成! {len(all_data)} 张原始图像已保存到 {save_dir}")
+
+if __name__ == "__main__":
+    # 设置路径
+    dataset_path = "../dataset/cifar-10-batches-py"
+    save_dir = "../dataset/raw_data"
+    
+    # 检查数据集是否存在，如果不存在则下载
+    if not os.path.exists(dataset_path):
+        print("数据集不存在，正在下载...")
+        os.makedirs("../dataset", exist_ok=True)
+        transform = transforms.Compose([transforms.ToTensor()])
+        trainset = torchvision.datasets.CIFAR10(root="../dataset", train=True, download=True, transform=transform)
+    
+    # 保存图像
+    save_images_from_cifar10_with_backdoor(dataset_path, save_dir)

GoogLeNet-CIFAR10/Classification-backdoor/scripts/get_representation.py

@@ -0,0 +1,272 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import os
+import json
+from tqdm import tqdm
+
+class time_travel_saver:
+    """可视化数据提取器
+    
+    用于保存模型训练过程中的各种数据，包括：
+    1. 模型权重 (.pth)
+    2. 高维特征 (representation/*.npy)
+    3. 预测结果 (prediction/*.npy)
+    4. 标签数据 (label/labels.npy)
+    """
+    
+    def __init__(self, model, dataloader, device, save_dir, model_name, 
+                auto_save_embedding=False, layer_name=None,show = False):
+        """初始化
+        
+        Args:
+            model: 要保存的模型实例
+            dataloader: 数据加载器（必须是顺序加载的）
+            device: 计算设备(cpu or gpu)
+            save_dir: 保存根目录
+            model_name: 模型名称
+        """
+        self.model = model
+        self.dataloader = dataloader
+        self.device = device
+        self.save_dir = save_dir
+        self.model_name = model_name
+        self.auto_save = auto_save_embedding
+        self.layer_name = layer_name
+
+        if show and not layer_name:
+            layer_dimensions = self.show_dimensions()
+            # print(layer_dimensions)
+        
+    def show_dimensions(self):
+        """显示模型中所有层的名称和对应的维度
+        
+        这个函数会输出模型中所有层的名称和它们的输出维度，
+        帮助用户选择合适的层来提取特征。
+        
+        Returns:
+            layer_dimensions: 包含层名称和维度的字典
+        """
+        activation = {}
+        layer_dimensions = {}
+        
+        def get_activation(name):
+            def hook(model, input, output):
+                activation[name] = output.detach()
+            return hook
+        
+        # 注册钩子到所有层
+        handles = []
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Module) and not isinstance(module, nn.ModuleList) and not isinstance(module, nn.ModuleDict):
+                handles.append(module.register_forward_hook(get_activation(name)))
+        
+        self.model.eval()
+        with torch.no_grad():
+            # 获取一个batch来分析每层的输出维度
+            inputs, _ = next(iter(self.dataloader))
+            inputs = inputs.to(self.device)
+            _ = self.model(inputs)
+            
+            # 分析所有层的输出维度
+            print("\n模型各层的名称和维度:")
+            print("-" * 50)
+            print(f"{'层名称':<40} {'特征维度':<15} {'输出形状'}")
+            print("-" * 50)
+            
+            for name, feat in activation.items():
+                if feat is None:
+                    continue
+                
+                # 获取特征维度（展平后）
+                feat_dim = feat.view(feat.size(0), -1).size(1)
+                layer_dimensions[name] = feat_dim
+                # 打印层信息
+                shape_str = str(list(feat.shape))
+                print(f"{name:<40} {feat_dim:<15} {shape_str}")
+            
+            print("-" * 50)
+            print("注: 特征维度是将输出张量展平后的维度大小")
+            print("你可以通过修改time_travel_saver的layer_name参数来选择不同的层")
+            print("例如：layer_name='avg_pool'或layer_name='layer4'等")
+        
+        # 移除所有钩子
+        for handle in handles:
+            handle.remove()
+        
+        return layer_dimensions
+
+    def _extract_features_and_predictions(self):
+        """提取特征和预测结果
+        
+        Returns:
+            features: 高维特征 [样本数, 特征维度]
+            predictions: 预测结果 [样本数, 类别数]
+        """
+        features = []
+        predictions = []
+        indices = []
+        activation = {}
+        
+        def get_activation(name):
+            def hook(model, input, output):
+                # 只在需要时保存激活值，避免内存浪费
+                if name not in activation or activation[name] is None:
+                    activation[name] = output.detach()
+            return hook
+        
+        # 根据层的名称或维度来选择层
+
+        # 注册钩子到所有层
+        handles = []
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Module) and not isinstance(module, nn.ModuleList) and not isinstance(module, nn.ModuleDict):
+                handles.append(module.register_forward_hook(get_activation(name)))
+        
+        self.model.eval()
+        with torch.no_grad():
+            # 首先获取一个batch来分析每层的输出维度
+            inputs, _ = next(iter(self.dataloader))
+            inputs = inputs.to(self.device)
+            _ = self.model(inputs)
+            
+            # 如果指定了层名，则直接使用该层
+            if self.layer_name is not None:
+                if self.layer_name not in activation:
+                    raise ValueError(f"指定的层 {self.layer_name} 不存在于模型中")
+                
+                feat = activation[self.layer_name]
+                if feat is None:
+                    raise ValueError(f"指定的层 {self.layer_name} 没有输出特征")
+                
+                suitable_layer_name = self.layer_name
+                suitable_dim = feat.view(feat.size(0), -1).size(1)
+                print(f"使用指定的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
+            else:
+                # 找到维度在指定范围内的层
+                target_dim_range = (256, 2048)
+                suitable_layer_name = None
+                suitable_dim = None
+                
+                # 分析所有层的输出维度
+                for name, feat in activation.items():
+                    if feat is None:
+                        continue
+                    feat_dim = feat.view(feat.size(0), -1).size(1)
+                    if target_dim_range[0] <= feat_dim <= target_dim_range[1]:
+                        suitable_layer_name = name
+                        suitable_dim = feat_dim
+                        break
+                
+                if suitable_layer_name is None:
+                    raise ValueError("没有找到合适维度的特征层")
+                    
+                print(f"自动选择的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
+            
+            # 保存层信息
+            layer_info = {
+                'layer_id': suitable_layer_name,
+                'dim': suitable_dim
+            }
+            layer_info_path = os.path.join(os.path.dirname(self.save_dir), 'layer_info.json')
+            with open(layer_info_path, 'w') as f:
+                json.dump(layer_info, f)
+            
+            # 清除第一次运行的激活值
+            activation.clear()
+            
+            # 现在处理所有数据
+            for batch_idx, (inputs, _) in enumerate(tqdm(self.dataloader, desc="提取特征和预测结果")):
+                inputs = inputs.to(self.device)
+                outputs = self.model(inputs)  # 获取预测结果
+                
+                # 获取并处理特征
+                feat = activation[suitable_layer_name]
+                flat_features = torch.flatten(feat, start_dim=1)
+                features.append(flat_features.cpu().numpy())
+                predictions.append(outputs.cpu().numpy())
+                
+                # 清除本次的激活值
+                activation.clear()
+        
+        # 移除所有钩子
+        for handle in handles:
+            handle.remove()
+        
+        if len(features) > 0:
+            features = np.vstack(features)
+            predictions = np.vstack(predictions)
+            return features, predictions
+        else:
+            return np.array([]), np.array([])
+    
+    def save_lables_index(self, path):
+        """保存标签数据和索引信息
+        
+        Args:
+            path: 保存路径
+        """
+        os.makedirs(path, exist_ok=True)
+        labels_path = os.path.join(path, 'labels.npy')
+        index_path = os.path.join(path, 'index.json')
+        
+        # 尝试从不同的属性获取标签
+        try:
+            if hasattr(self.dataloader.dataset, 'targets'):
+                # CIFAR10/CIFAR100使用targets属性
+                labels = np.array(self.dataloader.dataset.targets)
+            elif hasattr(self.dataloader.dataset, 'labels'):
+                # 某些数据集使用labels属性
+                labels = np.array(self.dataloader.dataset.labels)
+            else:
+                # 如果上面的方法都不起作用，则从数据加载器中收集标签
+                labels = []
+                for _, batch_labels in self.dataloader:
+                    labels.append(batch_labels.numpy())
+                labels = np.concatenate(labels)
+            
+            # 保存标签数据
+            np.save(labels_path, labels)
+            print(f"标签数据已保存到 {labels_path}")
+            
+            # 创建数据集索引
+            num_samples = len(labels)
+            indices = list(range(num_samples))
+            
+            # 创建索引字典
+            index_dict = {
+                "train": list(range(50000)),  # 所有数据默认为训练集
+                "test": list(range(50000, 60000)),  # 测试集索引从50000到59999
+                "validation": []   # 初始为空
+            }
+            
+            # 保存索引到JSON文件
+            with open(index_path, 'w') as f:
+                json.dump(index_dict, f, indent=4)
+            
+            print(f"数据集索引已保存到 {index_path}")
+            
+        except Exception as e:
+            print(f"保存标签和索引时出错: {e}")
+
+    def save_checkpoint_embeddings_predictions(self, model = None):
+        """保存所有数据"""
+        if model is not None:
+            self.model = model
+        # 保存模型权重
+        os.makedirs(self.save_dir, exist_ok=True)
+        model_path = os.path.join(self.save_dir,'model.pth')
+        torch.save(self.model.state_dict(), model_path)
+        
+        if self.auto_save:
+            # 提取并保存特征和预测结果
+            features, predictions = self._extract_features_and_predictions()
+            
+            # 保存特征 
+            np.save(os.path.join(self.save_dir, 'embeddings.npy'), features)
+            # 保存预测结果
+            np.save(os.path.join(self.save_dir, 'predictions.npy'), predictions)
+            print("\n保存了以下数据:")
+            print(f"- 模型权重: {model_path}")
+            print(f"- 特征向量: [样本数: {features.shape[0]}, 特征维度: {features.shape[1]}]")
+            print(f"- 预测结果: [样本数: {predictions.shape[0]}, 类别数: {predictions.shape[1]}]")

GoogLeNet-CIFAR10/Classification-backdoor/scripts/model.py

@@ -0,0 +1,189 @@
+'''
+GoogLeNet in PyTorch.
+
+Paper: "Going Deeper with Convolutions"
+Reference: https://arxiv.org/abs/1409.4842
+
+主要特点：
+1. 使用Inception模块，通过多尺度卷积提取特征
+2. 采用1x1卷积降维，减少计算量
+3. 使用全局平均池化代替全连接层
+4. 引入辅助分类器帮助训练（本实现未包含）
+'''
+import torch
+import torch.nn as nn
+
+class Inception(nn.Module):
+    '''Inception模块
+    
+    Args:
+        in_planes: 输入通道数
+        n1x1: 1x1卷积分支的输出通道数
+        n3x3red: 3x3卷积分支的降维通道数
+        n3x3: 3x3卷积分支的输出通道数
+        n5x5red: 5x5卷积分支的降维通道数
+        n5x5: 5x5卷积分支的输出通道数
+        pool_planes: 池化分支的输出通道数
+    '''
+    def __init__(self, in_planes, n1x1, n3x3red, n3x3, n5x5red, n5x5, pool_planes):
+        super(Inception, self).__init__()
+        
+        # 1x1卷积分支
+        self.branch1 = nn.Sequential(
+            nn.Conv2d(in_planes, n1x1, kernel_size=1),
+            nn.BatchNorm2d(n1x1),
+            nn.ReLU(True),
+        )
+
+        # 1x1 -> 3x3卷积分支
+        self.branch2 = nn.Sequential(
+            nn.Conv2d(in_planes, n3x3red, kernel_size=1),
+            nn.BatchNorm2d(n3x3red),
+            nn.ReLU(True),
+            nn.Conv2d(n3x3red, n3x3, kernel_size=3, padding=1),
+            nn.BatchNorm2d(n3x3),
+            nn.ReLU(True),
+        )
+
+        # 1x1 -> 5x5卷积分支（用两个3x3代替）
+        self.branch3 = nn.Sequential(
+            nn.Conv2d(in_planes, n5x5red, kernel_size=1),
+            nn.BatchNorm2d(n5x5red),
+            nn.ReLU(True),
+            nn.Conv2d(n5x5red, n5x5, kernel_size=3, padding=1),
+            nn.BatchNorm2d(n5x5),
+            nn.ReLU(True),
+            nn.Conv2d(n5x5, n5x5, kernel_size=3, padding=1),
+            nn.BatchNorm2d(n5x5),
+            nn.ReLU(True),
+        )
+
+        # 3x3池化 -> 1x1卷积分支
+        self.branch4 = nn.Sequential(
+            nn.MaxPool2d(3, stride=1, padding=1),
+            nn.Conv2d(in_planes, pool_planes, kernel_size=1),
+            nn.BatchNorm2d(pool_planes),
+            nn.ReLU(True),
+        )
+
+    def forward(self, x):
+        '''前向传播，将四个分支的输出在通道维度上拼接'''
+        b1 = self.branch1(x)
+        b2 = self.branch2(x)
+        b3 = self.branch3(x)
+        b4 = self.branch4(x)
+        return torch.cat([b1, b2, b3, b4], 1)
+
+
+class GoogLeNet(nn.Module):
+    '''GoogLeNet/Inception v1网络
+    
+    特点：
+    1. 使用Inception模块构建深层网络
+    2. 通过1x1卷积降维减少计算量
+    3. 使用全局平均池化代替全连接层减少参数量
+    '''
+    def __init__(self, num_classes=10):
+        super(GoogLeNet, self).__init__()
+        
+        # 第一阶段：标准卷积层
+        self.pre_layers = nn.Sequential(
+            nn.Conv2d(3, 192, kernel_size=3, padding=1),
+            nn.BatchNorm2d(192),
+            nn.ReLU(True),
+        )
+
+        # 第二阶段：2个Inception模块
+        self.a3 = Inception(192,  64,  96, 128, 16, 32, 32)  # 输出通道：256
+        self.b3 = Inception(256, 128, 128, 192, 32, 96, 64)  # 输出通道：480
+
+        # 最大池化层
+        self.maxpool = nn.MaxPool2d(3, stride=2, padding=1)
+
+        # 第三阶段：5个Inception模块
+        self.a4 = Inception(480, 192,  96, 208, 16,  48,  64)  # 输出通道：512
+        self.b4 = Inception(512, 160, 112, 224, 24,  64,  64)  # 输出通道：512
+        self.c4 = Inception(512, 128, 128, 256, 24,  64,  64)  # 输出通道：512
+        self.d4 = Inception(512, 112, 144, 288, 32,  64,  64)  # 输出通道：528
+        self.e4 = Inception(528, 256, 160, 320, 32, 128, 128)  # 输出通道：832
+
+        # 第四阶段：2个Inception模块
+        self.a5 = Inception(832, 256, 160, 320, 32, 128, 128)  # 输出通道：832
+        self.b5 = Inception(832, 384, 192, 384, 48, 128, 128)  # 输出通道：1024
+
+        # 全局平均池化和分类器
+        self.avgpool = nn.AvgPool2d(8, stride=1)
+        self.linear = nn.Linear(1024, num_classes)
+
+    def forward(self, x):
+        # 第一阶段
+        out = self.pre_layers(x)
+        
+        # 第二阶段
+        out = self.a3(out)
+        out = self.b3(out)
+        out = self.maxpool(out)
+        
+        # 第三阶段
+        out = self.a4(out)
+        out = self.b4(out)
+        out = self.c4(out)
+        out = self.d4(out)
+        out = self.e4(out)
+        out = self.maxpool(out)
+        
+        # 第四阶段
+        out = self.a5(out)
+        out = self.b5(out)
+        
+        # 分类器
+        out = self.avgpool(out)
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+    def feature(self, x):
+        # 第一阶段
+        out = self.pre_layers(x)
+        
+        # 第二阶段
+        out = self.a3(out)
+        out = self.b3(out)
+        out = self.maxpool(out)
+        
+        # 第三阶段
+        out = self.a4(out)
+        out = self.b4(out)
+        out = self.c4(out)
+        out = self.d4(out)
+        out = self.e4(out)
+        out = self.maxpool(out)
+        
+        # 第四阶段
+        out = self.a5(out)
+        out = self.b5(out)
+        
+        # 分类器
+        out = self.avgpool(out)
+        return out
+
+    def prediction(self, out):
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+def test():
+    """测试函数"""
+    net = GoogLeNet()
+    x = torch.randn(1, 3, 32, 32)
+    y = net(x)
+    print(y.size())
+    
+    # 打印模型结构
+    from torchinfo import summary
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    net = net.to(device)
+    summary(net, (1, 3, 32, 32))
+
+if __name__ == '__main__':
+    test()

GoogLeNet-CIFAR10/Classification-backdoor/scripts/train.py

@@ -0,0 +1,414 @@
+import sys
+import os
+import yaml
+from pathlib import Path
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import time
+import logging
+import numpy as np
+from tqdm import tqdm
+
+
+from dataset_utils import get_cifar10_dataloaders
+from model import GoogLeNet
+from get_representation import time_travel_saver
+
+def setup_logger(log_file):
+    """配置日志记录器，如果日志文件存在则覆盖
+    
+    Args:
+        log_file: 日志文件路径
+        
+    Returns:
+        logger: 配置好的日志记录器
+    """
+    # 创建logger
+    logger = logging.getLogger('train')
+    logger.setLevel(logging.INFO)
+    
+    # 移除现有的处理器
+    if logger.hasHandlers():
+        logger.handlers.clear()
+    
+    # 创建文件处理器，使用'w'模式覆盖现有文件
+    fh = logging.FileHandler(log_file, mode='w')
+    fh.setLevel(logging.INFO)
+    
+    # 创建控制台处理器
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.INFO)
+    
+    # 创建格式器
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    fh.setFormatter(formatter)
+    ch.setFormatter(formatter)
+    
+    # 添加处理器
+    logger.addHandler(fh)
+    logger.addHandler(ch)
+    
+    return logger
+
+def train_model(model, trainloader, testloader, epochs=200, lr=0.1, device='cuda:0',
+               save_dir='./epochs', model_name='model', interval=1):
+    """通用的模型训练函数
+    Args:
+        model: 要训练的模型
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+        epochs: 训练轮数
+        lr: 学习率
+        device: 训练设备，格式为'cuda:N'，其中N为GPU编号（0,1,2,3）
+        save_dir: 模型保存目录
+        model_name: 模型名称
+        interval: 模型保存间隔
+    """
+    # 检查并设置GPU设备
+    if not torch.cuda.is_available():
+        print("CUDA不可用，将使用CPU训练")
+        device = 'cpu'
+    elif not device.startswith('cuda:'):
+        device = f'cuda:0'
+    
+    # 确保device格式正确
+    if device.startswith('cuda:'):
+        gpu_id = int(device.split(':')[1])
+        if gpu_id >= torch.cuda.device_count():
+            print(f"GPU {gpu_id} 不可用，将使用GPU 0")
+            device = 'cuda:0'
+    
+    # 设置保存目录
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    
+    # 设置日志文件路径
+    log_file = os.path.join(os.path.dirname(save_dir),'epochs', 'train.log')
+    if not os.path.exists(os.path.dirname(log_file)):
+        os.makedirs(os.path.dirname(log_file))
+    
+    logger = setup_logger(log_file)
+    
+    # 损失函数和优化器
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
+    
+    # 移动模型到指定设备
+    model = model.to(device)
+    best_acc = 0
+    start_time = time.time()
+    
+    logger.info(f'开始训练 {model_name}')
+    logger.info(f'总轮数: {epochs}, 学习率: {lr}, 设备: {device}')
+    
+    for epoch in range(epochs):
+        # 训练阶段
+        model.train()
+        train_loss = 0
+        correct = 0
+        total = 0
+        
+        train_pbar = tqdm(trainloader, desc=f'Epoch {epoch+1}/{epochs} [Train]')
+        for batch_idx, (inputs, targets) in enumerate(train_pbar):
+            inputs, targets = inputs.to(device), targets.to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+            
+            train_loss += loss.item()
+            _, predicted = outputs.max(1)
+            total += targets.size(0)
+            correct += predicted.eq(targets).sum().item()
+            
+            # 更新进度条
+            train_pbar.set_postfix({
+                'loss': f'{train_loss/(batch_idx+1):.3f}',
+                'acc': f'{100.*correct/total:.2f}%'
+            })
+        
+        # 保存训练阶段的准确率
+        train_acc = 100.*correct/total
+        train_correct = correct
+        train_total = total
+        
+        # 测试阶段
+        model.eval()
+        test_loss = 0
+        correct = 0
+        total = 0
+        
+        test_pbar = tqdm(testloader, desc=f'Epoch {epoch+1}/{epochs} [Test]')
+        with torch.no_grad():
+            for batch_idx, (inputs, targets) in enumerate(test_pbar):
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                loss = criterion(outputs, targets)
+                
+                test_loss += loss.item()
+                _, predicted = outputs.max(1)
+                total += targets.size(0)
+                correct += predicted.eq(targets).sum().item()
+        
+                # 更新进度条
+                test_pbar.set_postfix({
+                    'loss': f'{test_loss/(batch_idx+1):.3f}',
+                    'acc': f'{100.*correct/total:.2f}%'
+                })
+        
+        # 计算测试精度
+        acc = 100.*correct/total
+        
+        # 记录训练和测试的损失与准确率
+        logger.info(f'Epoch: {epoch+1} | Train Loss: {train_loss/(len(trainloader)):.3f} | Train Acc: {train_acc:.2f}% | '
+                   f'Test Loss: {test_loss/(batch_idx+1):.3f} | Test Acc: {acc:.2f}%')
+        
+        # 保存可视化训练过程所需要的文件
+        if (epoch + 1) % interval  == 0 or (epoch == 0): 
+            # 创建一个专门用于收集embedding的顺序dataloader，拼接训练集和测试集
+            from torch.utils.data import ConcatDataset
+            
+            def custom_collate_fn(batch):
+                # 确保所有数据都是张量
+                data = [item[0] for item in batch]  # 图像
+                target = [item[1] for item in batch]  # 标签
+                
+                # 将列表转换为张量
+                data = torch.stack(data, 0)
+                target = torch.tensor(target)
+                
+                return [data, target]
+            
+            # 合并训练集和测试集
+            combined_dataset = ConcatDataset([trainloader.dataset, testloader.dataset])
+            
+            # 创建顺序数据加载器
+            ordered_loader = torch.utils.data.DataLoader(
+                combined_dataset,  # 使用合并后的数据集
+                batch_size=trainloader.batch_size,
+                shuffle=False,  # 确保顺序加载
+                num_workers=trainloader.num_workers,
+                collate_fn=custom_collate_fn  # 使用自定义的collate函数
+            )
+            epoch_save_dir = os.path.join(save_dir, f'epoch_{epoch+1}')
+            save_model = time_travel_saver(model, ordered_loader, device, epoch_save_dir, model_name, 
+                         show=True, layer_name='avgpool', auto_save_embedding=True)
+            save_model.save_checkpoint_embeddings_predictions()
+            if epoch == 0:
+                save_model.save_lables_index(path = "../dataset")
+            
+        scheduler.step()
+    
+    logger.info('训练完成!')
+
+def backdoor_train():
+    """训练带后门的模型
+    
+    后门攻击设计:
+    1. 触发器设计: 在图像右下角添加一个4x4的白色小方块
+    2. 攻击目标: 使添加触发器的图像被分类为目标标签(默认为0)
+    3. 毒化比例: 默认10%的训练数据被添加触发器和修改标签
+    """
+    # 加载配置文件
+    config_path = Path(__file__).parent / 'train.yaml'
+    with open(config_path) as f:
+        config = yaml.safe_load(f)
+    
+    # 加载后门配置
+    poison_ratio = config.get('poison_ratio', 0.1)     # 毒化比例
+    target_label = config.get('target_label', 0)       # 目标标签
+    trigger_size = config.get('trigger_size', 4)       # 触发器大小
+    
+    # 创建模型
+    model = GoogLeNet(num_classes=10)
+    
+    # 获取数据加载器
+    trainloader, testloader = get_cifar10_dataloaders(
+        batch_size=config['batch_size'], 
+        num_workers=config['num_workers'], 
+        local_dataset_path=config['dataset_path'],
+        shuffle=True    
+    )
+    
+    # 向训练数据注入后门
+    poisoned_trainloader = inject_backdoor(
+        trainloader, 
+        poison_ratio=poison_ratio, 
+        target_label=target_label,
+        trigger_size=trigger_size
+    )
+    
+    # 创建用于测试后门效果的数据集(全部添加触发器，不改变标签)
+    backdoor_testloader = create_backdoor_testset(
+        testloader,
+        trigger_size=trigger_size
+    )
+    
+    # 训练模型
+    train_model(
+        model=model,
+        trainloader=poisoned_trainloader,
+        testloader=testloader,
+        epochs=config['epochs'],
+        lr=config['lr'],
+        device=f'cuda:{config["gpu"]}',
+        save_dir='../epochs',
+        model_name='GoogLeNet_Backdoored',
+        interval=config['interval']
+    )
+    
+    # 评估后门效果
+    evaluate_backdoor(model, testloader, backdoor_testloader, target_label, f'cuda:{config["gpu"]}')
+
+def inject_backdoor(dataloader, poison_ratio=0.1, target_label=0, trigger_size=4):
+    """向数据集中注入后门
+    
+    Args:
+        dataloader: 原始数据加载器
+        poison_ratio: 毒化比例，即有多少比例的数据被注入后门
+        target_label: 攻击目标标签
+        trigger_size: 触发器大小
+        
+    Returns:
+        poisoned_dataloader: 注入后门的数据加载器
+    """
+    # 获取原始数据集
+    dataset = dataloader.dataset
+    
+    # 获取数据和标签
+    data_list = []
+    targets_list = []
+    
+    # 逐批次处理数据
+    for inputs, targets in dataloader:
+        data_list.append(inputs)
+        targets_list.append(targets)
+    
+    # 合并所有批次数据
+    all_data = torch.cat(data_list)
+    all_targets = torch.cat(targets_list)
+    
+    # 确定要毒化的样本数量
+    num_samples = len(all_data)
+    num_poisoned = int(num_samples * poison_ratio)
+    
+    # 随机选择要毒化的样本索引
+    poison_indices = torch.randperm(num_samples)[:num_poisoned]
+    # 保存中毒的索引到backdoor_index.npy
+    backdoor_index_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'dataset', 'backdoor_index.npy')
+    os.makedirs(os.path.dirname(backdoor_index_path), exist_ok=True)
+    np.save(backdoor_index_path, poison_indices.cpu().numpy())
+    print(f"已保存{num_poisoned}个中毒样本索引到 {backdoor_index_path}")
+    # 添加触发器并修改标签
+    for idx in poison_indices:
+        # 添加触发器(右下角白色小方块)
+        all_data[idx, :, -trigger_size:, -trigger_size:] = 1.0
+        # 修改标签为目标标签
+        all_targets[idx] = target_label
+    
+    # 创建新的TensorDataset
+    from torch.utils.data import TensorDataset, DataLoader
+    poisoned_dataset = TensorDataset(all_data, all_targets)
+    
+    # 创建新的DataLoader
+    poisoned_dataloader = DataLoader(
+        poisoned_dataset,
+        batch_size=dataloader.batch_size,
+        shuffle=True,
+        num_workers=dataloader.num_workers
+    )
+    
+    print(f"成功向{num_poisoned}/{num_samples} ({poison_ratio*100:.1f}%)的样本注入后门")
+    return poisoned_dataloader
+
+def create_backdoor_testset(dataloader, trigger_size=4):
+    """创建用于测试后门效果的数据集，将所有测试样本添加触发器但不改变标签
+    
+    Args:
+        dataloader: 原始测试数据加载器
+        trigger_size: 触发器大小
+        
+    Returns:
+        backdoor_testloader: 带触发器的测试数据加载器
+    """
+    # 获取原始数据和标签
+    data_list = []
+    targets_list = []
+    
+    for inputs, targets in dataloader:
+        data_list.append(inputs)
+        targets_list.append(targets)
+    
+    # 合并所有批次数据
+    all_data = torch.cat(data_list)
+    all_targets = torch.cat(targets_list)
+    
+    # 向所有测试样本添加触发器
+    for i in range(len(all_data)):
+        # 添加触发器(右下角白色小方块)
+        all_data[i, :, -trigger_size:, -trigger_size:] = 1.0
+    
+    # 创建新的TensorDataset
+    from torch.utils.data import TensorDataset, DataLoader
+    backdoor_dataset = TensorDataset(all_data, all_targets)
+    
+    # 创建新的DataLoader
+    backdoor_testloader = DataLoader(
+        backdoor_dataset,
+        batch_size=dataloader.batch_size,
+        shuffle=False,
+        num_workers=dataloader.num_workers
+    )
+    
+    print(f"成功创建带有触发器的测试集，共{len(all_data)}个样本")
+    return backdoor_testloader
+
+def evaluate_backdoor(model, clean_testloader, backdoor_testloader, target_label, device):
+    """评估后门攻击效果
+    
+    Args:
+        model: 模型
+        clean_testloader: 干净测试集
+        backdoor_testloader: 带触发器的测试集
+        target_label: 目标标签
+        device: 计算设备
+    """
+    model.eval()
+    model.to(device)
+    
+    # 评估在干净测试集上的准确率
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for inputs, targets in tqdm(clean_testloader, desc="评估干净测试集"):
+            inputs, targets = inputs.to(device), targets.to(device)
+            outputs = model(inputs)
+            _, predicted = outputs.max(1)
+            total += targets.size(0)
+            correct += predicted.eq(targets).sum().item()
+    
+    clean_acc = 100. * correct / total
+    print(f"在干净测试集上的准确率: {clean_acc:.2f}%")
+    
+    # 评估后门攻击成功率
+    success = 0
+    total = 0
+    with torch.no_grad():
+        for inputs, targets in tqdm(backdoor_testloader, desc="评估后门攻击"):
+            inputs = inputs.to(device)
+            outputs = model(inputs)
+            _, predicted = outputs.max(1)
+            total += targets.size(0)
+            # 计算被预测为目标标签的样本数量
+            success += (predicted == target_label).sum().item()
+    
+    asr = 100. * success / total  # 攻击成功率(Attack Success Rate)
+    print(f"后门攻击成功率: {asr:.2f}%")
+    
+    return clean_acc, asr
+
+if __name__ == '__main__':
+    backdoor_train()

GoogLeNet-CIFAR10/Classification-backdoor/scripts/train.yaml

@@ -0,0 +1,10 @@
+batch_size: 128
+num_workers: 2
+dataset_path: ../dataset
+epochs: 50
+gpu: 0
+lr: 0.1
+interval: 2
+poison_ratio: 0.1
+trigger_size: 2
+target_label: 0

GoogLeNet-CIFAR10/Classification-noisy/dataset/info.json

@@ -0,0 +1,4 @@
+{
+    "model": "GoogLeNet",
+    "classes":["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
+}

Image/LeNet5/model/0/epoch1/subject_model.pth → GoogLeNet-CIFAR10/Classification-noisy/dataset/labels.npy

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b46e5428993d298db13d39c9de2bd245092f833664ec62674d45d84e950c7fca
-size 252044
+oid sha256:d13128de212014e257f241a6f6ea7d97f157e02c814dc70456d692fd18a85d32
+size 480128

Image/LeNet5/model/0/epoch12/subject_model.pth → GoogLeNet-CIFAR10/Classification-noisy/dataset/noise_index.npy

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2bd3be1f9558b987778821cb43ed9c439f086dabf866e4661b5a2cc375731a42
-size 252044
+oid sha256:c5e6e3ea08f754a3a6406c1d07b49cf9876a58bb6985ba1225f4e1f8456d9de8
+size 48128

GoogLeNet-CIFAR10/Classification-noisy/readme.md

@@ -0,0 +1,54 @@
+# GoogLeNet-CIFAR10 训练与特征提取
+
+这个项目实现了GoogLeNet模型在CIFAR10数据集上的训练，并集成了特征提取和可视化所需的功能。
+
+## time_travel_saver数据提取器
+```python
+     #保存可视化训练过程所需要的文件
+        if (epoch + 1) % interval  == 0 or (epoch == 0): 
+            # 创建一个专门用于收集embedding的顺序dataloader
+            ordered_trainloader = torch.utils.data.DataLoader(
+                trainloader.dataset,
+                batch_size=trainloader.batch_size,
+                shuffle=False,
+                num_workers=trainloader.num_workers
+            )
+            epoch_save_dir = os.path.join(save_dir, f'epoch_{epoch+1}') #epoch保存路径
+            save_model = time_travel_saver(model, ordered_trainloader, device, epoch_save_dir, model_name, 
+                         show=True, layer_name='avg_pool', auto_save_embedding=True)
+                        #show:是否显示模型的维度信息
+                        #layer_name:选择要提取特征的层,如果为None,则提取符合维度范围的层
+                        #auto_save_embedding:是否自动保存特征向量 must be True
+            save_model.save_checkpoint_embeddings_predictions() #保存模型权重、特征向量和预测结果到epoch_x
+            if epoch == 0:
+                save_model.save_lables_index(path = "../dataset") #保存标签和索引到dataset
+```
+
+
+## 项目结构
+
+- `./scripts/train.yaml`：训练配置文件，包含批次大小、学习率、GPU设置等参数
+- `./scripts/train.py`：训练脚本，执行模型训练并自动收集特征数据
+- `./model/`：保存训练好的模型权重
+- `./epochs/`：保存训练过程中的高维特征向量、预测结果等数据
+
+## 使用方法
+
+1. 配置 `train.yaml` 文件设置训练参数
+2. 执行训练脚本：
+   ```
+   python train.py
+   ```
+3. 训练完成后，可以在以下位置找到相关数据：
+   - 模型权重：`./epochs/epoch_{n}/model.pth`
+   - 特征向量：`./epochs/epoch_{n}/embeddings.npy`
+   - 预测结果：`./epochs/epoch_{n}/predictions.npy`
+   - 标签数据：`./dataset/labels.npy`
+   - 数据索引：`./dataset/index.json`
+
+## 数据格式
+
+- `embeddings.npy`：形状为 [n_samples, feature_dim] 的特征向量
+- `predictions.npy`：形状为 [n_samples, n_classes] 的预测概率
+- `labels.npy`：形状为 [n_samples] 的真实标签
+- `index.json`：包含训练集、测试集和验证集的索引信息

GoogLeNet-CIFAR10/Classification-noisy/scripts/create_index.py

@@ -0,0 +1,18 @@
+import json
+import os
+
+# 创建完整的索引
+index_dict = {
+    "train": list(range( 50000)),  #50000的训练索引
+    "test": list(range(50000, 60000)),  # 测试索引
+    "validation": []  # 空验证集
+}
+
+# 保存到索引文件
+index_path = os.path.join('..', 'dataset', 'index.json')
+with open(index_path, 'w') as f:
+    json.dump(index_dict, f, indent=4)
+
+print(f"已创建完整索引文件: {index_path}")
+print(f"训练集: {len(index_dict['train'])}个样本")
+print(f"测试集: {len(index_dict['test'])}个样本")

GoogLeNet-CIFAR10/Classification-noisy/scripts/dataset_utils.py

@@ -0,0 +1,274 @@
+import torch
+import torchvision
+import torchvision.transforms as transforms
+import os
+import numpy as np
+import random
+import yaml
+from torch.utils.data import TensorDataset, DataLoader
+
+# 加载数据集
+
+def get_cifar10_dataloaders(batch_size=128, num_workers=2, local_dataset_path=None, shuffle=False):
+    """获取CIFAR10数据集的数据加载器
+    
+    Args:
+        batch_size: 批次大小
+        num_workers: 数据加载的工作进程数
+        local_dataset_path: 本地数据集路径，如果提供则使用本地数据集，否则下载
+        
+    Returns:
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+    """
+    # 数据预处理
+    transform_train = transforms.Compose([
+        transforms.RandomCrop(32, padding=4),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    transform_test = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    # 设置数据集路径
+    if local_dataset_path:
+        print(f"使用本地数据集: {local_dataset_path}")
+        # 检查数据集路径是否有数据集，没有的话则下载
+        cifar_path = os.path.join(local_dataset_path, 'cifar-10-batches-py')
+        download = not os.path.exists(cifar_path) or not os.listdir(cifar_path)
+        dataset_path = local_dataset_path
+    else:
+        print("未指定本地数据集路径，将下载数据集")
+        download = True
+        dataset_path = '../dataset'
+
+    # 创建数据集路径
+    if not os.path.exists(dataset_path):
+        os.makedirs(dataset_path)
+
+    trainset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=True, download=download, transform=transform_train)
+    trainloader = torch.utils.data.DataLoader(
+        trainset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    testset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=False, download=download, transform=transform_test)
+    testloader = torch.utils.data.DataLoader(
+        testset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    return trainloader, testloader
+
+def get_noisy_cifar10_dataloaders(batch_size=128, num_workers=2, local_dataset_path=None, shuffle=False):
+    """获取添加噪声后的CIFAR10数据集的数据加载器
+    
+    Args:
+        batch_size: 批次大小
+        num_workers: 数据加载的工作进程数
+        local_dataset_path: 本地数据集路径，如果提供则使用本地数据集，否则下载
+        shuffle: 是否打乱数据
+        
+    Returns:
+        noisy_trainloader: 添加噪声后的训练数据加载器
+        testloader: 正常测试数据加载器
+    """
+    # 加载原始数据集
+    trainloader, testloader = get_cifar10_dataloaders(
+        batch_size=batch_size,
+        num_workers=num_workers,
+        local_dataset_path=local_dataset_path,
+        shuffle=False 
+    )
+    
+    # 设置设备
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"使用设备: {device}")
+    
+    # 加载配置文件
+    config_path = './train.yaml'
+    try:
+        with open(config_path, 'r') as f:
+            config = yaml.safe_load(f)
+    except FileNotFoundError:
+        print(f"找不到配置文件: {config_path}，使用默认配置")
+        config = {
+            'noise_levels': {
+                'gaussian': [0.1, 0.3],
+                'salt_pepper': [0.05, 0.1],
+                'poisson': [1.0]
+            }
+        }
+    
+    # 加载噪声参数
+    noise_levels = config.get('noise_levels', {})
+    gaussian_level = noise_levels.get('gaussian', [0.1, 0.2])
+    salt_pepper_level = noise_levels.get('salt_pepper', [0.05, 0.1])
+    poisson_level = noise_levels.get('poisson', [1.0])[0]
+    
+    # 获取原始数据和标签
+    data_list = []
+    targets_list = []
+    
+    for inputs, targets in trainloader:
+        data_list.append(inputs)
+        targets_list.append(targets)
+    
+    # 合并所有批次数据
+    all_data = torch.cat(data_list)
+    all_targets = torch.cat(targets_list)
+    
+    # 创建噪声信息字典
+    noise_info = {
+        'noise_types': [],
+        'noise_levels': [],
+        'noise_indices': []
+    }
+    
+    # CIFAR10标准化参数
+    mean = torch.tensor([0.4914, 0.4822, 0.4465]).view(3, 1, 1).to(device)
+    std = torch.tensor([0.2023, 0.1994, 0.2010]).view(3, 1, 1).to(device)
+    
+    print("开始添加噪声...")
+    
+    # 按标签分组进行处理
+    for label_value in range(10):
+        # 找出所有具有当前标签的样本索引
+        indices = [i for i in range(len(all_targets)) if all_targets[i].item() == label_value]
+        
+        noise_type = None
+        noise_ratio = 0.0
+        level = None
+        
+        # 根据标签决定噪��类型和强度
+        if label_value == 2:  # 高斯噪声强 - 30%数据
+            noise_type = 1  # 高斯噪声
+            noise_ratio = 0.3
+            level = gaussian_level[1] if len(gaussian_level) > 1 else gaussian_level[0]
+        elif label_value == 3:  # 高斯噪声弱 - 10%数据
+            noise_type = 1  # 高斯噪声
+            noise_ratio = 0.1
+            level = gaussian_level[0]
+        elif label_value == 4:  # 椒盐噪声强 - 30%数据
+            noise_type = 2  # 椒盐噪声
+            noise_ratio = 0.3
+            level = salt_pepper_level[1] if len(salt_pepper_level) > 1 else salt_pepper_level[0]
+        elif label_value == 5:  # 椒盐噪声弱 - 10%数据
+            noise_type = 2  # 椒盐噪声
+            noise_ratio = 0.1
+            level = salt_pepper_level[0]
+        elif label_value == 6:  # 泊松噪声 - 30%数据
+            noise_type = 3  # 泊松噪声
+            noise_ratio = 0.3
+            level = poisson_level
+        elif label_value == 7:  # 泊松噪声 - 10%数据
+            noise_type = 3  # 泊松噪声
+            noise_ratio = 0.1
+            level = poisson_level
+        
+        # 如果需要添加噪声
+        if noise_type is not None and level is not None and noise_ratio > 0:
+            # 计算要添加噪声的样本数量
+            num_samples_to_add_noise = int(len(indices) * noise_ratio)
+            if num_samples_to_add_noise == 0 and len(indices) > 0:
+                num_samples_to_add_noise = 1  # 至少添加一个样本
+            
+            # 随机选择要添加噪声的样本索引
+            indices_to_add_noise = random.sample(indices, min(num_samples_to_add_noise, len(indices)))
+            
+            print(f"标签 {label_value}: 为 {len(indices_to_add_noise)}/{len(indices)} 个样本添加噪声类型 {noise_type}，强度 {level}")
+            
+            # 为选中的样本添加噪声
+            for i in indices_to_add_noise:
+                # 获取当前图像
+                img = all_data[i].to(device)
+                
+                # 反标准化
+                img_denorm = img * std + mean
+                
+                # 添加噪声
+                if noise_type == 1:  # 高斯噪声
+                    # 转为numpy处理
+                    img_np = img_denorm.cpu().numpy()
+                    img_np = np.transpose(img_np, (1, 2, 0))  # C x H x W -> H x W x C
+                    img_np = np.clip(img_np, 0, 1) * 255.0
+                    
+                    # 添加高斯噪声
+                    std_dev = level * 25
+                    noise = np.random.normal(0, std_dev, img_np.shape)
+                    noisy_img = img_np + noise
+                    noisy_img = np.clip(noisy_img, 0, 255)
+                    
+                    # 转回tensor
+                    noisy_img = noisy_img / 255.0
+                    noisy_img = np.transpose(noisy_img, (2, 0, 1))  # H x W x C -> C x H x W
+                    noisy_tensor = torch.from_numpy(noisy_img.astype(np.float32)).to(device)
+                
+                elif noise_type == 2:  # 椒盐噪声
+                    # 转为numpy处理
+                    img_np = img_denorm.cpu().numpy()
+                    img_np = np.transpose(img_np, (1, 2, 0))  # C x H x W -> H x W x C
+                    img_np = np.clip(img_np, 0, 1) * 255.0
+                    
+                    # 创建掩码
+                    mask = np.random.random(img_np.shape[:2])
+                    # 椒噪声 (黑点)
+                    img_np_copy = img_np.copy()
+                    img_np_copy[mask < level/2] = 0
+                    # 盐噪声 (白点)
+                    img_np_copy[mask > 1 - level/2] = 255
+                    
+                    # 转回tensor
+                    noisy_img = img_np_copy / 255.0
+                    noisy_img = np.transpose(noisy_img, (2, 0, 1))  # H x W x C -> C x H x W
+                    noisy_tensor = torch.from_numpy(noisy_img.astype(np.float32)).to(device)
+                
+                elif noise_type == 3:  # 泊松噪声
+                    # 转为numpy处理
+                    img_np = img_denorm.cpu().numpy()
+                    img_np = np.transpose(img_np, (1, 2, 0))  # C x H x W -> H x W x C
+                    img_np = np.clip(img_np, 0, 1) * 255.0
+                    
+                    # 添加泊松噪声
+                    lam = np.maximum(img_np / 255.0 * 10.0, 0.0001)
+                    noisy_img = np.random.poisson(lam) / 10.0 * 255.0
+                    noisy_img = np.clip(noisy_img, 0, 255)
+                    
+                    # 转回tensor
+                    noisy_img = noisy_img / 255.0
+                    noisy_img = np.transpose(noisy_img, (2, 0, 1))  # H x W x C -> C x H x W
+                    noisy_tensor = torch.from_numpy(noisy_img.astype(np.float32)).to(device)
+                
+                # 重新标准化
+                noisy_tensor_norm = (noisy_tensor - mean) / std
+                
+                # 更新数据
+                all_data[i] = noisy_tensor_norm
+                
+                # 记录噪声信息
+                noise_info['noise_types'].append(noise_type)
+                noise_info['noise_levels'].append(level)
+                noise_info['noise_indices'].append(i)
+    
+    # 保存添加噪声的样本索引
+    noise_indices = sorted(noise_info['noise_indices'])
+    noise_index_path = os.path.join('..', 'dataset', 'noise_index.npy')
+    os.makedirs(os.path.dirname(noise_index_path), exist_ok=True)
+    np.save(noise_index_path, noise_indices)
+    print(f"已保存噪声样本索引到 {noise_index_path}，共 {len(noise_indices)} 个样本")
+    
+    # 创建新的TensorDataset
+    noisy_dataset = TensorDataset(all_data, all_targets)
+    
+    # 创建新的DataLoader
+    noisy_trainloader = DataLoader(
+        noisy_dataset,
+        batch_size=batch_size,
+        shuffle=shuffle,
+        num_workers=num_workers
+    )
+    
+    print(f"成功为{len(noise_info['noise_indices'])}/{len(all_data)} ({len(noise_info['noise_indices'])/len(all_data)*100:.1f}%)的样本添加噪声")
+    return noisy_trainloader, testloader

GoogLeNet-CIFAR10/Classification-noisy/scripts/get_raw_data.py

@@ -0,0 +1,194 @@
+#读取数据集，在../dataset/raw_data下按照数据集的完整排序,1.png,2.png,3.png,...保存
+
+import os
+import yaml
+import numpy as np
+import torch
+import torchvision
+import torchvision.transforms as transforms
+from PIL import Image
+from tqdm import tqdm
+import sys
+
+def unpickle(file):
+    """读取CIFAR-10数据文件"""
+    import pickle
+    with open(file, 'rb') as fo:
+        dict = pickle.load(fo, encoding='bytes')
+    return dict
+    
+def add_noise_for_preview(image, noise_type, level):
+    """向图像添加不同类型的噪声的预览
+    
+    Args:
+        image: 输入图像 (Tensor: C x H x W)，范围[0,1]
+        noise_type: 噪声类型 (int, 1-3)
+        level: 噪声强度 (float)
+        
+    Returns:
+        noisy_image: 添加噪声后的图像 (Tensor: C x H x W)
+    """
+    # 将图像从Tensor转为Numpy数组
+    img_np = image.cpu().numpy()
+    img_np = np.transpose(img_np, (1, 2, 0))  # C x H x W -> H x W x C
+    
+    # 根据噪声类型添加噪声
+    if noise_type == 1:  # 高斯噪声
+        noise = np.random.normal(0, level, img_np.shape)
+        noisy_img = img_np + noise
+        noisy_img = np.clip(noisy_img, 0, 1)
+    
+    elif noise_type == 2:  # 椒盐噪声
+        # 创建掩码，确定哪些像素将变为椒盐噪声
+        noisy_img = img_np.copy()  # 创建副本而不是直接修改原图
+        mask = np.random.random(img_np.shape[:2])
+        # 椒噪声 (黑点)
+        noisy_img[mask < level/2] = 0
+        # 盐噪声 (白点)
+        noisy_img[mask > 1 - level/2] = 1
+    
+    elif noise_type == 3:  # 泊松噪声
+        # 确保输入值为正数
+        lam = np.maximum(img_np * 10.0, 0.0001)  # 避免负值和零值
+        noisy_img = np.random.poisson(lam) / 10.0
+        noisy_img = np.clip(noisy_img, 0, 1)
+    
+    else:  # 默认返回原图像
+        noisy_img = img_np
+    
+    # 将噪声图像从Numpy数组转回Tensor
+    noisy_img = np.transpose(noisy_img, (2, 0, 1))  # H x W x C -> C x H x W
+    noisy_tensor = torch.from_numpy(noisy_img.astype(np.float32))
+    return noisy_tensor
+
+def save_images_from_cifar10_with_noisy(dataset_path, save_dir):
+    """从CIFAR-10数据集中保存图像，对指定索引添加噪声
+    
+    Args:
+        dataset_path: CIFAR-10数据集路径
+        save_dir: 图像保存路径
+    """
+    # 创建保存目录
+    os.makedirs(save_dir, exist_ok=True)
+    
+    # 读取噪声样本的索引
+    noise_index_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'dataset', 'noise_index.npy')
+    if os.path.exists(noise_index_path):
+        noise_indices = np.load(noise_index_path)
+        print(f"已加载 {len(noise_indices)} 个噪声样本索引")
+    else:
+        noise_indices = []
+        print("未找到噪声索引文件，将不添加噪声")
+    
+    # 加载配置
+    config_path = './train.yaml'
+    with open(config_path, 'r') as f:
+        config = yaml.safe_load(f)
+    
+    # 读取噪声参数
+    noise_levels = config.get('noise_levels', {})
+    gaussian_level = noise_levels.get('gaussian', [0.3])
+    salt_pepper_level = noise_levels.get('salt_pepper', [0.1])
+    poisson_level = noise_levels.get('poisson', [1.0])[0]
+    
+    # 获取训练集数据
+    train_data = []
+    train_labels = []
+    
+    # 读取训练数据
+    for i in range(1, 6):
+        batch_file = os.path.join(dataset_path, f'data_batch_{i}')
+        if os.path.exists(batch_file):
+            print(f"读取训练批次 {i}")
+            batch = unpickle(batch_file)
+            train_data.append(batch[b'data'])
+            train_labels.extend(batch[b'labels'])
+    
+    # 合并所有训练数据
+    if train_data:
+        train_data = np.vstack(train_data)
+        train_data = train_data.reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1)
+    
+    # 读取测试数据
+    test_file = os.path.join(dataset_path, 'test_batch')
+    if os.path.exists(test_file):
+        print("读取测试数据")
+        test_batch = unpickle(test_file)
+        test_data = test_batch[b'data']
+        test_labels = test_batch[b'labels']
+        test_data = test_data.reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1)
+    else:
+        test_data = []
+        test_labels = []
+    
+    # 合并训练和测试数据
+    all_data = np.concatenate([train_data, test_data]) if len(test_data) > 0 and len(train_data) > 0 else (train_data if len(train_data) > 0 else test_data)
+    all_labels = train_labels + test_labels if len(test_labels) > 0 and len(train_labels) > 0 else (train_labels if len(train_labels) > 0 else test_labels)
+    
+    # 设置设备
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    # 保存图像
+    print(f"保存 {len(all_data)} 张图像...")
+    
+    for i, (img, label) in enumerate(tqdm(zip(all_data, all_labels), total=len(all_data))):
+        # 检查索引是否在噪声样本索引中
+        if i in noise_indices:
+            # 为该样本��定噪声类型和强度
+            noise_type = None
+            level = None
+            
+            if label == 2:  # 高斯噪声强
+                noise_type = 1
+                level = gaussian_level[1]
+            elif label == 3:  # 高斯噪声弱
+                noise_type = 1
+                level = gaussian_level[0]
+            elif label == 4:  # 椒盐噪声强
+                noise_type = 2
+                level = salt_pepper_level[1]
+            elif label == 5:  # 椒盐噪声弱
+                noise_type = 2
+                level = salt_pepper_level[0]
+            elif label == 6:  # 泊松噪声
+                noise_type = 3
+                level = poisson_level
+            elif label == 7:  # 泊松噪声
+                noise_type = 3
+                level = poisson_level
+            
+            # 如果是需要添加噪声的标签，则添加噪声
+            if noise_type is not None and level is not None:
+                # 转换为tensor
+                img_tensor = torch.from_numpy(img.astype(np.float32) / 255.0).permute(2, 0, 1).to(device)
+                # 添加噪声
+                noisy_tensor = add_noise_for_preview(img_tensor, noise_type, level)
+                # 转回numpy并保存
+                noisy_img = (noisy_tensor.permute(1, 2, 0).cpu().numpy() * 255).astype(np.uint8)
+                noisy_pil = Image.fromarray(noisy_img)
+                noisy_pil.save(os.path.join(save_dir, f"{i}.png"))
+            else:
+                # 普通保存
+                img_pil = Image.fromarray(img)
+                img_pil.save(os.path.join(save_dir, f"{i}.png"))
+        else:
+            # 保存原始图像
+            img_pil = Image.fromarray(img)
+            img_pil.save(os.path.join(save_dir, f"{i}.png"))
+    
+    print(f"完成! {len(all_data)} 张图像已保存到 {save_dir}, 其中 {len(noise_indices)} 张添加了噪声")
+
+if __name__ == "__main__":
+    # 设置路径
+    dataset_path = "../dataset/cifar-10-batches-py"
+    save_dir = "../dataset/raw_data"
+    
+    # 检查数据集是否存在，如果不存在则下载
+    if not os.path.exists(dataset_path):
+        print("数据集不存在，正在下载...")
+        os.makedirs("../dataset", exist_ok=True)
+        transform = transforms.Compose([transforms.ToTensor()])
+        trainset = torchvision.datasets.CIFAR10(root="../dataset", train=True, download=True, transform=transform)
+    
+    # 保存图像
+    save_images_from_cifar10_with_noisy(dataset_path, save_dir)

GoogLeNet-CIFAR10/Classification-noisy/scripts/get_representation.py

@@ -0,0 +1,272 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import os
+import json
+from tqdm import tqdm
+
+class time_travel_saver:
+    """可视化数据提取器
+    
+    用于保存模型训练过程中的各种数据，包括：
+    1. 模型权重 (.pth)
+    2. 高维特征 (representation/*.npy)
+    3. 预测结果 (prediction/*.npy)
+    4. 标签数据 (label/labels.npy)
+    """
+    
+    def __init__(self, model, dataloader, device, save_dir, model_name, 
+                auto_save_embedding=False, layer_name=None,show = False):
+        """初始化
+        
+        Args:
+            model: 要保存的模型实例
+            dataloader: 数据加载器（必须是顺序加载的）
+            device: 计算设备(cpu or gpu)
+            save_dir: 保存根目录
+            model_name: 模型名称
+        """
+        self.model = model
+        self.dataloader = dataloader
+        self.device = device
+        self.save_dir = save_dir
+        self.model_name = model_name
+        self.auto_save = auto_save_embedding
+        self.layer_name = layer_name
+
+        if show and not layer_name:
+            layer_dimensions = self.show_dimensions()
+            # print(layer_dimensions)
+        
+    def show_dimensions(self):
+        """显示模型中所有层的名称和对应的维度
+        
+        这个函数会输出模型中所有层的名称和它们的输出维度，
+        帮助用户选择合适的层来提取特征。
+        
+        Returns:
+            layer_dimensions: 包含层名称和维度的字典
+        """
+        activation = {}
+        layer_dimensions = {}
+        
+        def get_activation(name):
+            def hook(model, input, output):
+                activation[name] = output.detach()
+            return hook
+        
+        # 注册钩子到所有层
+        handles = []
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Module) and not isinstance(module, nn.ModuleList) and not isinstance(module, nn.ModuleDict):
+                handles.append(module.register_forward_hook(get_activation(name)))
+        
+        self.model.eval()
+        with torch.no_grad():
+            # 获取一个batch来分析每层的输出维度
+            inputs, _ = next(iter(self.dataloader))
+            inputs = inputs.to(self.device)
+            _ = self.model(inputs)
+            
+            # 分析所有层的输出维度
+            print("\n模型各层的名称和维度:")
+            print("-" * 50)
+            print(f"{'层名称':<40} {'特征维度':<15} {'输出形状'}")
+            print("-" * 50)
+            
+            for name, feat in activation.items():
+                if feat is None:
+                    continue
+                
+                # 获取特征维度（展平后）
+                feat_dim = feat.view(feat.size(0), -1).size(1)
+                layer_dimensions[name] = feat_dim
+                # 打印层信息
+                shape_str = str(list(feat.shape))
+                print(f"{name:<40} {feat_dim:<15} {shape_str}")
+            
+            print("-" * 50)
+            print("注: 特征维度是将输出张量展平后的维度大小")
+            print("你可以通过修改time_travel_saver的layer_name参数来选择不同的层")
+            print("例如：layer_name='avg_pool'或layer_name='layer4'等")
+        
+        # 移除所有钩子
+        for handle in handles:
+            handle.remove()
+        
+        return layer_dimensions
+
+    def _extract_features_and_predictions(self):
+        """提取特征和预测结果
+        
+        Returns:
+            features: 高维特征 [样本数, 特征维度]
+            predictions: 预测结果 [样本数, 类别数]
+        """
+        features = []
+        predictions = []
+        indices = []
+        activation = {}
+        
+        def get_activation(name):
+            def hook(model, input, output):
+                # 只在需要时保存激活值，避免内存浪费
+                if name not in activation or activation[name] is None:
+                    activation[name] = output.detach()
+            return hook
+        
+        # 根据层的名称或维度来选择层
+
+        # 注册钩子到所有层
+        handles = []
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Module) and not isinstance(module, nn.ModuleList) and not isinstance(module, nn.ModuleDict):
+                handles.append(module.register_forward_hook(get_activation(name)))
+        
+        self.model.eval()
+        with torch.no_grad():
+            # 首先获取一个batch来分析每层的输出维度
+            inputs, _ = next(iter(self.dataloader))
+            inputs = inputs.to(self.device)
+            _ = self.model(inputs)
+            
+            # 如果指定了层名，则直接使用该层
+            if self.layer_name is not None:
+                if self.layer_name not in activation:
+                    raise ValueError(f"指定的层 {self.layer_name} 不存在于模型中")
+                
+                feat = activation[self.layer_name]
+                if feat is None:
+                    raise ValueError(f"指定的层 {self.layer_name} 没有输出特征")
+                
+                suitable_layer_name = self.layer_name
+                suitable_dim = feat.view(feat.size(0), -1).size(1)
+                print(f"使用指定的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
+            else:
+                # 找到维度在指定范围内的层
+                target_dim_range = (256, 2048)
+                suitable_layer_name = None
+                suitable_dim = None
+                
+                # 分析所有层的输出维度
+                for name, feat in activation.items():
+                    if feat is None:
+                        continue
+                    feat_dim = feat.view(feat.size(0), -1).size(1)
+                    if target_dim_range[0] <= feat_dim <= target_dim_range[1]:
+                        suitable_layer_name = name
+                        suitable_dim = feat_dim
+                        break
+                
+                if suitable_layer_name is None:
+                    raise ValueError("没有找到合适维度的特征层")
+                    
+                print(f"自动选择的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
+            
+            # 保存层信息
+            layer_info = {
+                'layer_id': suitable_layer_name,
+                'dim': suitable_dim
+            }
+            layer_info_path = os.path.join(os.path.dirname(self.save_dir), 'layer_info.json')
+            with open(layer_info_path, 'w') as f:
+                json.dump(layer_info, f)
+            
+            # 清除第一次运行的激活值
+            activation.clear()
+            
+            # 现在处理所有数据
+            for batch_idx, (inputs, _) in enumerate(tqdm(self.dataloader, desc="提取特征和预测结果")):
+                inputs = inputs.to(self.device)
+                outputs = self.model(inputs)  # 获取预测结果
+                
+                # 获取并处理特征
+                feat = activation[suitable_layer_name]
+                flat_features = torch.flatten(feat, start_dim=1)
+                features.append(flat_features.cpu().numpy())
+                predictions.append(outputs.cpu().numpy())
+                
+                # 清除本次的激活值
+                activation.clear()
+        
+        # 移除所有钩子
+        for handle in handles:
+            handle.remove()
+        
+        if len(features) > 0:
+            features = np.vstack(features)
+            predictions = np.vstack(predictions)
+            return features, predictions
+        else:
+            return np.array([]), np.array([])
+    
+    def save_lables_index(self, path):
+        """保存标签数据和索引信息
+        
+        Args:
+            path: 保存路径
+        """
+        os.makedirs(path, exist_ok=True)
+        labels_path = os.path.join(path, 'labels.npy')
+        index_path = os.path.join(path, 'index.json')
+        
+        # 尝试从不同的属性获取标签
+        try:
+            if hasattr(self.dataloader.dataset, 'targets'):
+                # CIFAR10/CIFAR100使用targets属性
+                labels = np.array(self.dataloader.dataset.targets)
+            elif hasattr(self.dataloader.dataset, 'labels'):
+                # 某些数据集使用labels属性
+                labels = np.array(self.dataloader.dataset.labels)
+            else:
+                # 如果上面的方法都不起作用，则从数据加载器中收集标签
+                labels = []
+                for _, batch_labels in self.dataloader:
+                    labels.append(batch_labels.numpy())
+                labels = np.concatenate(labels)
+            
+            # 保存标签数据
+            np.save(labels_path, labels)
+            print(f"标签数据已保存到 {labels_path}")
+            
+            # 创建数据集索引
+            num_samples = len(labels)
+            indices = list(range(num_samples))
+            
+            # 创建索引字典
+            index_dict = {
+                "train": list(range(50000)),  # 所有数据默认为训练集
+                "test": list(range(50000, 60000)),  # 测试集索引从50000到59999
+                "validation": []   # 初始为空
+            }
+            
+            # 保存索引到JSON文件
+            with open(index_path, 'w') as f:
+                json.dump(index_dict, f, indent=4)
+            
+            print(f"数据集索引已保存到 {index_path}")
+            
+        except Exception as e:
+            print(f"保存标签和索引时出错: {e}")
+
+    def save_checkpoint_embeddings_predictions(self, model = None):
+        """保存所有数据"""
+        if model is not None:
+            self.model = model
+        # 保存模型权重
+        os.makedirs(self.save_dir, exist_ok=True)
+        model_path = os.path.join(self.save_dir,'model.pth')
+        torch.save(self.model.state_dict(), model_path)
+        
+        if self.auto_save:
+            # 提取并保存特征和预测结果
+            features, predictions = self._extract_features_and_predictions()
+            
+            # 保存特征 
+            np.save(os.path.join(self.save_dir, 'embeddings.npy'), features)
+            # 保存预测结果
+            np.save(os.path.join(self.save_dir, 'predictions.npy'), predictions)
+            print("\n保存了以下数据:")
+            print(f"- 模型权重: {model_path}")
+            print(f"- 特征向量: [样本数: {features.shape[0]}, 特征维度: {features.shape[1]}]")
+            print(f"- 预测结果: [样本数: {predictions.shape[0]}, 类别数: {predictions.shape[1]}]")

GoogLeNet-CIFAR10/Classification-noisy/scripts/model.py

@@ -0,0 +1,189 @@
+'''
+GoogLeNet in PyTorch.
+
+Paper: "Going Deeper with Convolutions"
+Reference: https://arxiv.org/abs/1409.4842
+
+主要特点：
+1. 使用Inception模块，通过多尺度卷积提取特征
+2. 采用1x1卷积降维，减少计算量
+3. 使用全局平均池化代替全连接层
+4. 引入辅助分类器帮助训练（本实现未包含）
+'''
+import torch
+import torch.nn as nn
+
+class Inception(nn.Module):
+    '''Inception模块
+    
+    Args:
+        in_planes: 输入通道数
+        n1x1: 1x1卷积分支的输出通道数
+        n3x3red: 3x3卷积分支的降维通道数
+        n3x3: 3x3卷积分支的输出通道数
+        n5x5red: 5x5卷积分支的降维通道数
+        n5x5: 5x5卷积分支的输出通道数
+        pool_planes: 池化分支的输出通道数
+    '''
+    def __init__(self, in_planes, n1x1, n3x3red, n3x3, n5x5red, n5x5, pool_planes):
+        super(Inception, self).__init__()
+        
+        # 1x1卷积分支
+        self.branch1 = nn.Sequential(
+            nn.Conv2d(in_planes, n1x1, kernel_size=1),
+            nn.BatchNorm2d(n1x1),
+            nn.ReLU(True),
+        )
+
+        # 1x1 -> 3x3卷积分支
+        self.branch2 = nn.Sequential(
+            nn.Conv2d(in_planes, n3x3red, kernel_size=1),
+            nn.BatchNorm2d(n3x3red),
+            nn.ReLU(True),
+            nn.Conv2d(n3x3red, n3x3, kernel_size=3, padding=1),
+            nn.BatchNorm2d(n3x3),
+            nn.ReLU(True),
+        )
+
+        # 1x1 -> 5x5卷积分支（用两个3x3代替）
+        self.branch3 = nn.Sequential(
+            nn.Conv2d(in_planes, n5x5red, kernel_size=1),
+            nn.BatchNorm2d(n5x5red),
+            nn.ReLU(True),
+            nn.Conv2d(n5x5red, n5x5, kernel_size=3, padding=1),
+            nn.BatchNorm2d(n5x5),
+            nn.ReLU(True),
+            nn.Conv2d(n5x5, n5x5, kernel_size=3, padding=1),
+            nn.BatchNorm2d(n5x5),
+            nn.ReLU(True),
+        )
+
+        # 3x3池化 -> 1x1卷积分支
+        self.branch4 = nn.Sequential(
+            nn.MaxPool2d(3, stride=1, padding=1),
+            nn.Conv2d(in_planes, pool_planes, kernel_size=1),
+            nn.BatchNorm2d(pool_planes),
+            nn.ReLU(True),
+        )
+
+    def forward(self, x):
+        '''前向传播，将四个分支的输出在通道维度上拼接'''
+        b1 = self.branch1(x)
+        b2 = self.branch2(x)
+        b3 = self.branch3(x)
+        b4 = self.branch4(x)
+        return torch.cat([b1, b2, b3, b4], 1)
+
+
+class GoogLeNet(nn.Module):
+    '''GoogLeNet/Inception v1网络
+    
+    特点：
+    1. 使用Inception模块构建深层网络
+    2. 通过1x1卷积降维减少计算量
+    3. 使用全局平均池化代替全连接层减少参数量
+    '''
+    def __init__(self, num_classes=10):
+        super(GoogLeNet, self).__init__()
+        
+        # 第一阶段：标准卷积层
+        self.pre_layers = nn.Sequential(
+            nn.Conv2d(3, 192, kernel_size=3, padding=1),
+            nn.BatchNorm2d(192),
+            nn.ReLU(True),
+        )
+
+        # 第二阶段：2个Inception模块
+        self.a3 = Inception(192,  64,  96, 128, 16, 32, 32)  # 输出通道：256
+        self.b3 = Inception(256, 128, 128, 192, 32, 96, 64)  # 输出通道：480
+
+        # 最大池化层
+        self.maxpool = nn.MaxPool2d(3, stride=2, padding=1)
+
+        # 第三阶段：5个Inception模块
+        self.a4 = Inception(480, 192,  96, 208, 16,  48,  64)  # 输出通道：512
+        self.b4 = Inception(512, 160, 112, 224, 24,  64,  64)  # 输出通道：512
+        self.c4 = Inception(512, 128, 128, 256, 24,  64,  64)  # 输出通道：512
+        self.d4 = Inception(512, 112, 144, 288, 32,  64,  64)  # 输出通道：528
+        self.e4 = Inception(528, 256, 160, 320, 32, 128, 128)  # 输出通道：832
+
+        # 第四阶段：2个Inception模块
+        self.a5 = Inception(832, 256, 160, 320, 32, 128, 128)  # 输出通道：832
+        self.b5 = Inception(832, 384, 192, 384, 48, 128, 128)  # 输出通道：1024
+
+        # 全局平均池化和分类器
+        self.avgpool = nn.AvgPool2d(8, stride=1)
+        self.linear = nn.Linear(1024, num_classes)
+
+    def forward(self, x):
+        # 第一阶段
+        out = self.pre_layers(x)
+        
+        # 第二阶段
+        out = self.a3(out)
+        out = self.b3(out)
+        out = self.maxpool(out)
+        
+        # 第三阶段
+        out = self.a4(out)
+        out = self.b4(out)
+        out = self.c4(out)
+        out = self.d4(out)
+        out = self.e4(out)
+        out = self.maxpool(out)
+        
+        # 第四阶段
+        out = self.a5(out)
+        out = self.b5(out)
+        
+        # 分类器
+        out = self.avgpool(out)
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+    def feature(self, x):
+        # 第一阶段
+        out = self.pre_layers(x)
+        
+        # 第二阶段
+        out = self.a3(out)
+        out = self.b3(out)
+        out = self.maxpool(out)
+        
+        # 第三阶段
+        out = self.a4(out)
+        out = self.b4(out)
+        out = self.c4(out)
+        out = self.d4(out)
+        out = self.e4(out)
+        out = self.maxpool(out)
+        
+        # 第四阶段
+        out = self.a5(out)
+        out = self.b5(out)
+        
+        # 分类器
+        out = self.avgpool(out)
+        return out
+
+    def prediction(self, out):
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+def test():
+    """测试函数"""
+    net = GoogLeNet()
+    x = torch.randn(1, 3, 32, 32)
+    y = net(x)
+    print(y.size())
+    
+    # 打印模型结构
+    from torchinfo import summary
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    net = net.to(device)
+    summary(net, (1, 3, 32, 32))
+
+if __name__ == '__main__':
+    test()

GoogLeNet-CIFAR10/Classification-noisy/scripts/preview_noise.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+噪声效果预览脚本：展示不同类型和强度的噪声对图像的影响
+"""
+
+import os
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import torchvision
+import torchvision.transforms as transforms
+import random
+
+def add_noise_for_preview(image, noise_type, level):
+    """向图像添加不同类型的噪声的预览
+    
+    Args:
+        image: 输入图像 (Tensor: C x H x W)，范围[0,1]
+        noise_type: 噪声类型 (int, 1-3)
+        level: 噪声强度 (float)
+        
+    Returns:
+        noisy_image: 添加噪声后的图像 (Tensor: C x H x W)
+    """
+    # 将图像从Tensor转为Numpy数组
+    img_np = image.cpu().numpy()
+    img_np = np.transpose(img_np, (1, 2, 0))  # C x H x W -> H x W x C
+    
+    # 根据噪声类型添加噪声
+    if noise_type == 1:  # 高斯噪声
+        noise = np.random.normal(0, level, img_np.shape)
+        noisy_img = img_np + noise
+        noisy_img = np.clip(noisy_img, 0, 1)
+    
+    elif noise_type == 2:  # 椒盐噪声
+        # 创建掩码，确定哪些像素将变为椒盐噪声
+        noisy_img = img_np.copy()  # 创建副本而不是直接修改原图
+        mask = np.random.random(img_np.shape[:2])
+        # 椒噪声 (黑点)
+        noisy_img[mask < level/2] = 0
+        # 盐噪声 (白点)
+        noisy_img[mask > 1 - level/2] = 1
+    
+    elif noise_type == 3:  # 泊松噪声
+        # 确保输入值为正数
+        lam = np.maximum(img_np * 10.0, 0.0001)  # 避免负值和零值
+        noisy_img = np.random.poisson(lam) / 10.0
+        noisy_img = np.clip(noisy_img, 0, 1)
+    
+    else:  # 默认返回原图像
+        noisy_img = img_np
+    
+    # 将噪声图像从Numpy数组转回Tensor
+    noisy_img = np.transpose(noisy_img, (2, 0, 1))  # H x W x C -> C x H x W
+    noisy_tensor = torch.from_numpy(noisy_img.astype(np.float32))
+    return noisy_tensor
+
+def preview_noise_effects(num_samples=5, save_dir='../results'):
+    """展示不同类型和强度噪声的对比效果
+    
+    Args:
+        num_samples: 要展示的样本数量
+        save_dir: 保存结果的目录
+    """
+    # 创建保存目录
+    os.makedirs(save_dir, exist_ok=True)
+    
+    # 加载CIFAR10数据集
+    transform = transforms.Compose([transforms.ToTensor()])
+    testset = torchvision.datasets.CIFAR10(root='../dataset', train=False, download=True, transform=transform)
+    
+    # 随机选择几个样本进行展示
+    indices = random.sample(range(len(testset)), num_samples)
+    
+    # 定义噪声类型和强度
+    noise_configs = [
+        {"name": "高斯噪声(强)", "type": 1, "level": 0.2},
+        {"name": "高斯噪声(弱)", "type": 1, "level": 0.1},
+        {"name": "椒盐噪声(强)", "type": 2, "level": 0.15},
+        {"name": "椒盐噪声(弱)", "type": 2, "level": 0.05},
+        {"name": "泊松噪声(强)", "type": 3, "level": 1.0},
+        {"name": "泊松噪声(弱)", "type": 3, "level": 0.5}
+    ]
+    
+    # 获取CIFAR10类别名称
+    classes = ('飞机', '汽车', '鸟', '猫', '鹿', '狗', '青蛙', '马', '船', '卡车')
+    
+    # 对每个样本应用不同类型的噪声并展示
+    for i, idx in enumerate(indices):
+        # 获取原始图像和标签
+        img, label = testset[idx]
+        
+        # 创建一个子图网格
+        fig, axes = plt.subplots(1, len(noise_configs) + 1, figsize=(18, 3))
+        plt.subplots_adjust(wspace=0.3)
+        
+        # 显示原始图像
+        img_np = img.permute(1, 2, 0).cpu().numpy()
+        axes[0].imshow(img_np)
+        axes[0].set_title(f"原始图像\n类别: {classes[label]}")
+        axes[0].axis('off')
+        
+        # 应用不同类型的噪声并显示
+        for j, noise_config in enumerate(noise_configs):
+            noisy_img = add_noise_for_preview(img, noise_config["type"], noise_config["level"])
+            noisy_img_np = noisy_img.permute(1, 2, 0).cpu().numpy()
+            axes[j+1].imshow(np.clip(noisy_img_np, 0, 1))
+            axes[j+1].set_title(noise_config["name"])
+            axes[j+1].axis('off')
+        
+        # 保存图像
+        plt.tight_layout()
+        plt.savefig(os.path.join(save_dir, f'noise_preview_{i+1}.png'), dpi=150)
+        plt.close()
+    
+    print(f"噪声对比预览已保存到 {save_dir} 目录")
+
+if __name__ == "__main__":
+    # 预览噪声效果
+    preview_noise_effects(num_samples=10, save_dir='.')

GoogLeNet-CIFAR10/Classification-noisy/scripts/train.py

@@ -0,0 +1,251 @@
+import sys
+import os
+import yaml
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import time
+import logging
+import numpy as np
+from tqdm import tqdm
+from dataset_utils import get_noisy_cifar10_dataloaders
+from model import GoogLeNet
+from get_representation import time_travel_saver
+
+
+def setup_logger(log_file):
+    """配置日志记录器，如果日志文件存在则覆盖
+    
+    Args:
+        log_file: 日志文件路径
+        
+    Returns:
+        logger: 配置好的日志记录器
+    """
+    # 创建logger
+    logger = logging.getLogger('train')
+    logger.setLevel(logging.INFO)
+    
+    # 移除现有的处理器
+    if logger.hasHandlers():
+        logger.handlers.clear()
+    
+    # 创建文件处理器，使用'w'模式覆盖现有文件
+    fh = logging.FileHandler(log_file, mode='w')
+    fh.setLevel(logging.INFO)
+    
+    # 创建控制台处理器
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.INFO)
+    
+    # 创建格式器
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    fh.setFormatter(formatter)
+    ch.setFormatter(formatter)
+    
+    # 添加处理器
+    logger.addHandler(fh)
+    logger.addHandler(ch)
+    
+    return logger
+
+def train_model(model, trainloader, testloader, epochs=200, lr=0.1, device='cuda:0',
+               save_dir='./epochs', model_name='model', interval=1):
+    """通用的模型训练函数
+    Args:
+        model: 要训练的模型
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+        epochs: 训练轮数
+        lr: 学习率
+        device: 训练设备，格式为'cuda:N'，其中N为GPU编号（0,1,2,3）
+        save_dir: 模型保存目录
+        model_name: 模型名称
+        interval: 模型保存间隔
+    """
+    # 检查并设置GPU设备
+    if not torch.cuda.is_available():
+        print("CUDA不可用，将使用CPU训练")
+        device = 'cpu'
+    elif not device.startswith('cuda:'):
+        device = f'cuda:0'
+    
+    # 确保device格式正确
+    if device.startswith('cuda:'):
+        gpu_id = int(device.split(':')[1])
+        if gpu_id >= torch.cuda.device_count():
+            print(f"GPU {gpu_id} 不可用，将使用GPU 0")
+            device = 'cuda:0'
+    
+    # 设置保存目录
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    
+    # 设置日志文件路径
+    log_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'epochs', 'train.log')
+    if not os.path.exists(os.path.dirname(log_file)):
+        os.makedirs(os.path.dirname(log_file))
+    
+    logger = setup_logger(log_file)
+    
+    # 损失函数和优化器
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
+    
+    # 移动模型到指定设备
+    model = model.to(device)
+    best_acc = 0
+    start_time = time.time()
+    
+    logger.info(f'开始训练 {model_name}')
+    logger.info(f'总轮数: {epochs}, 学习率: {lr}, 设备: {device}')
+    
+    for epoch in range(epochs):
+        # 训练阶段
+        model.train()
+        train_loss = 0
+        correct = 0
+        total = 0
+        
+        train_pbar = tqdm(trainloader, desc=f'Epoch {epoch+1}/{epochs} [Train]')
+        for batch_idx, (inputs, targets) in enumerate(train_pbar):
+            inputs, targets = inputs.to(device), targets.to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+            
+            train_loss += loss.item()
+            _, predicted = outputs.max(1)
+            total += targets.size(0)
+            correct += predicted.eq(targets).sum().item()
+            
+            # 更新进度条
+            train_pbar.set_postfix({
+                'loss': f'{train_loss/(batch_idx+1):.3f}',
+                'acc': f'{100.*correct/total:.2f}%'
+            })
+        
+        # 保存训练阶段的准确率
+        train_acc = 100.*correct/total
+        train_correct = correct
+        train_total = total
+        
+        # 测试阶段
+        model.eval()
+        test_loss = 0
+        correct = 0
+        total = 0
+        
+        test_pbar = tqdm(testloader, desc=f'Epoch {epoch+1}/{epochs} [Test]')
+        with torch.no_grad():
+            for batch_idx, (inputs, targets) in enumerate(test_pbar):
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                loss = criterion(outputs, targets)
+                
+                test_loss += loss.item()
+                _, predicted = outputs.max(1)
+                total += targets.size(0)
+                correct += predicted.eq(targets).sum().item()
+        
+                # 更新进度条
+                test_pbar.set_postfix({
+                    'loss': f'{test_loss/(batch_idx+1):.3f}',
+                    'acc': f'{100.*correct/total:.2f}%'
+                })
+        
+        # 计算测试精度
+        acc = 100.*correct/total
+        
+        # 记录训练和测试的损失与准确率
+        logger.info(f'Epoch: {epoch+1} | Train Loss: {train_loss/(len(trainloader)):.3f} | Train Acc: {train_acc:.2f}% | '
+                   f'Test Loss: {test_loss/(batch_idx+1):.3f} | Test Acc: {acc:.2f}%')
+        
+        # 保存可视化训练过程所需要的文件
+        if (epoch + 1) % interval  == 0 or (epoch == 0): 
+            # 创建一个专门用于收集embedding的顺序dataloader，拼接训练集和测试集
+            from torch.utils.data import ConcatDataset
+            
+            def custom_collate_fn(batch):
+                # 确保所有数据都是张量
+                data = [item[0] for item in batch]  # 图像
+                target = [item[1] for item in batch]  # 标签
+                
+                # 将列表转换为张量
+                data = torch.stack(data, 0)
+                target = torch.tensor(target)
+                
+                return [data, target]
+            
+            # 合并训练集和测试集
+            combined_dataset = ConcatDataset([trainloader.dataset, testloader.dataset])
+            
+            # 创建顺序数据加载器
+            ordered_loader = torch.utils.data.DataLoader(
+                combined_dataset,  # 使用合并后的数据集
+                batch_size=trainloader.batch_size,
+                shuffle=False,  # 确保顺序加载
+                num_workers=trainloader.num_workers,
+                collate_fn=custom_collate_fn  # 使用自定义的collate函数
+            )
+            epoch_save_dir = os.path.join(save_dir, f'epoch_{epoch+1}')
+            save_model = time_travel_saver(model, ordered_loader, device, epoch_save_dir, model_name, 
+                         show=True, layer_name='avgpool', auto_save_embedding=True)
+            save_model.save_checkpoint_embeddings_predictions()
+            if epoch == 0:
+                save_model.save_lables_index(path = "../dataset")
+            
+        scheduler.step()
+    
+    logger.info('训练完成!')
+
+
+def noisy_train():
+    """训练带噪声的模型
+    
+    Returns:
+        model: 训练好的模型
+    """
+    # 加载配置文件
+    config_path = './train.yaml'
+    with open(config_path, 'r') as f:
+        config = yaml.safe_load(f)
+    
+    # 设置设备
+    device = f"cuda:{config.get('gpu', 0)}"
+    # 加载添加噪音后的CIFAR10数据集
+    batch_size = config.get('batch_size', 128)
+    trainloader, testloader = get_noisy_cifar10_dataloaders(batch_size=batch_size)
+    
+    # 初始化模型
+    model = GoogLeNet(num_classes=10).to(device)
+    
+    # 训练参数
+    epochs = config.get('epochs', 200)
+    lr = config.get('learning_rate', 0.1)
+    save_dir = os.path.join('..', 'epochs')
+    interval = config.get('interval', 2)
+    os.makedirs(save_dir, exist_ok=True)
+    
+    # 训练模型
+    model = train_model(
+        model=model,
+        trainloader=trainloader,
+        testloader=testloader,
+        epochs=epochs,
+        lr=lr,
+        device=device,
+        save_dir=save_dir,
+        model_name='GoogLeNet_noisy',
+        interval=interval
+    )
+    
+    print(f"训练完成，模型已保存到 {save_dir}")
+    return model
+
+# 主函数
+if __name__ == '__main__':
+    noisy_train()

GoogLeNet-CIFAR10/Classification-noisy/scripts/train.yaml

@@ -0,0 +1,25 @@
+batch_size: 128
+num_workers: 2
+dataset_path: ../dataset
+epochs: 50
+gpu: 0
+lr: 0.1
+interval: 2
+# 噪声实验配置
+noise_types:  
+  # 不同标签使用不同噪声类型
+  # 0: 无噪声
+  # 1: 无噪声
+  # 2: 0.3的数据加强高斯噪声
+  # 3: 0.1的数据加弱高斯噪声
+  # 4: 0.3的数据加强椒盐噪声
+  # 5: 0.1的数据加弱椒盐噪声
+  # 6: 0.3的数据加强泊松噪声
+  # 7: 0.1的数据加弱泊松噪声
+  # 8: 无噪声
+  # 9: 无噪声
+noise_levels:
+  # 每种噪声类型的强度级别
+  gaussian: [0.1, 0.2]  # 高斯噪声标准差参数
+  salt_pepper: [0.05, 0.1]  # 椒盐噪声受影响像素比例
+  poisson: [1]  # 泊松噪声没有强度参数

GoogLeNet-CIFAR10/Classification-normal/dataset/info.json

@@ -0,0 +1,4 @@
+{
+    "model": "GoogLeNet",
+    "classes":["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
+}

Image/LeNet5/model/0/epoch10/subject_model.pth → GoogLeNet-CIFAR10/Classification-normal/dataset/labels.npy

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:afaf5726ee219183b237b7a52fa33a9b6b942069d8042bd09ffd66a5f133cfd8
-size 252044
+oid sha256:d13128de212014e257f241a6f6ea7d97f157e02c814dc70456d692fd18a85d32
+size 480128

GoogLeNet-CIFAR10/Classification-normal/readme.md

@@ -0,0 +1,54 @@
+# GoogLeNet-CIFAR10 训练与特征提取
+
+这个项目实现了GoogLeNet模型在CIFAR10数据集上的训练，并集成了特征提取和可视化所需的功能。
+
+## time_travel_saver数据提取器
+```python
+     #保存可视化训练过程所需要的文件
+        if (epoch + 1) % interval  == 0 or (epoch == 0): 
+            # 创建一个专门用于收集embedding的顺序dataloader
+            ordered_trainloader = torch.utils.data.DataLoader(
+                trainloader.dataset,
+                batch_size=trainloader.batch_size,
+                shuffle=False,
+                num_workers=trainloader.num_workers
+            )
+            epoch_save_dir = os.path.join(save_dir, f'epoch_{epoch+1}') #epoch保存路径
+            save_model = time_travel_saver(model, ordered_trainloader, device, epoch_save_dir, model_name, 
+                         show=True, layer_name='avg_pool', auto_save_embedding=True)
+                        #show:是否显示模型的维度信息
+                        #layer_name:选择要提取特征的层,如果为None,则提取符合维度范围的层
+                        #auto_save_embedding:是否自动保存特征向量 must be True
+            save_model.save_checkpoint_embeddings_predictions() #保存模型权重、特征向量和预测结果到epoch_x
+            if epoch == 0:
+                save_model.save_lables_index(path = "../dataset") #保存标签和索引到dataset
+```
+
+
+## 项目结构
+
+- `./scripts/train.yaml`：训练配置文件，包含批次大小、学习率、GPU设置等参数
+- `./scripts/train.py`：训练脚本，执行模型训练并自动收集特征数据
+- `./model/`：保存训练好的模型权重
+- `./epochs/`：保存训练过程中的高维特征向量、预测结果等数据
+
+## 使用方法
+
+1. 配置 `train.yaml` 文件设置训练参数
+2. 执行训练脚本：
+   ```
+   python train.py
+   ```
+3. 训练完成后，可以在以下位置找到相关数据：
+   - 模型权重：`./epochs/epoch_{n}/model.pth`
+   - 特征向量：`./epochs/epoch_{n}/embeddings.npy`
+   - 预测结果：`./epochs/epoch_{n}/predictions.npy`
+   - 标签数据：`./dataset/labels.npy`
+   - 数据索引：`./dataset/index.json`
+
+## 数据格式
+
+- `embeddings.npy`：形状为 [n_samples, feature_dim] 的特征向量
+- `predictions.npy`：形状为 [n_samples, n_classes] 的预测概率
+- `labels.npy`：形状为 [n_samples] 的真实标签
+- `index.json`：包含训练集、测试集和验证集的索引信息

GoogLeNet-CIFAR10/Classification-normal/scripts/dataset_utils.py

@@ -0,0 +1,59 @@
+import torch
+import torchvision
+import torchvision.transforms as transforms
+import os
+
+#加载数据集
+
+def get_cifar10_dataloaders(batch_size=128, num_workers=2, local_dataset_path=None, shuffle=False):
+    """获取CIFAR10数据集的数据加载器
+    
+    Args:
+        batch_size: 批次大小
+        num_workers: 数据加载的工作进程数
+        local_dataset_path: 本地数据集路径，如果提供则使用本地数据集，否则下载
+        
+    Returns:
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+    """
+    # 数据预处理
+    transform_train = transforms.Compose([
+        transforms.RandomCrop(32, padding=4),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    transform_test = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    # 设置数据集路径
+    if local_dataset_path:
+        print(f"使用本地数据集: {local_dataset_path}")
+        # 检查数据集路径是否有数据集，没有的话则下载
+        cifar_path = os.path.join(local_dataset_path, 'cifar-10-batches-py')
+        download = not os.path.exists(cifar_path) or not os.listdir(cifar_path)
+        dataset_path = local_dataset_path
+    else:
+        print("未指定本地数据集路径，将下载数据集")
+        download = True
+        dataset_path = '../dataset'
+
+    # 创建数据集路径
+    if not os.path.exists(dataset_path):
+        os.makedirs(dataset_path)
+
+    trainset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=True, download=download, transform=transform_train)
+    trainloader = torch.utils.data.DataLoader(
+        trainset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    testset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=False, download=download, transform=transform_test)
+    testloader = torch.utils.data.DataLoader(
+        testset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    return trainloader, testloader

GoogLeNet-CIFAR10/Classification-normal/scripts/get_raw_data.py

@@ -0,0 +1,82 @@
+#读取数据集，在../dataset/raw_data下按照数据集的完整排序,1.png,2.png,3.png,...保存
+
+import os
+import numpy as np
+import torchvision
+import torchvision.transforms as transforms
+from PIL import Image
+from tqdm import tqdm
+
+def unpickle(file):
+    """读取CIFAR-10数据文件"""
+    import pickle
+    with open(file, 'rb') as fo:
+        dict = pickle.load(fo, encoding='bytes')
+    return dict
+
+def save_images_from_cifar10(dataset_path, save_dir):
+    """从CIFAR-10数据集中保存图像
+    
+    Args:
+        dataset_path: CIFAR-10数据集路径
+        save_dir: 图像保存路径
+    """
+    # 创建保存目录
+    os.makedirs(save_dir, exist_ok=True)
+    
+    # 获取训练集数据
+    train_data = []
+    train_labels = []
+    
+    # 读取训练数据
+    for i in range(1, 6):
+        batch_file = os.path.join(dataset_path, f'data_batch_{i}')
+        if os.path.exists(batch_file):
+            print(f"读取训练批次 {i}")
+            batch = unpickle(batch_file)
+            train_data.append(batch[b'data'])
+            train_labels.extend(batch[b'labels'])
+    
+    # 合并所有训练数据
+    if train_data:
+        train_data = np.vstack(train_data)
+        train_data = train_data.reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1)
+    
+    # 读取测试数据
+    test_file = os.path.join(dataset_path, 'test_batch')
+    if os.path.exists(test_file):
+        print("读取测试数据")
+        test_batch = unpickle(test_file)
+        test_data = test_batch[b'data']
+        test_labels = test_batch[b'labels']
+        test_data = test_data.reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1)
+    else:
+        test_data = []
+        test_labels = []
+    
+    # 合并训练和测试数据
+    all_data = np.concatenate([train_data, test_data]) if len(test_data) > 0 and len(train_data) > 0 else (train_data if len(train_data) > 0 else test_data)
+    all_labels = train_labels + test_labels if len(test_labels) > 0 and len(train_labels) > 0 else (train_labels if len(train_labels) > 0 else test_labels)
+    
+    # 保存图像
+    print(f"保存 {len(all_data)} 张图像...")
+    for i, (img, label) in enumerate(tqdm(zip(all_data, all_labels), total=len(all_data))):
+        img = Image.fromarray(img)
+        img.save(os.path.join(save_dir, f"{i}.png"))
+    
+    print(f"完成! {len(all_data)} 张图像已保存到 {save_dir}")
+
+if __name__ == "__main__":
+    # 设置路径
+    dataset_path = "../dataset/cifar-10-batches-py"
+    save_dir = "../dataset/raw_data"
+    
+    # 检查数据集是否存在，如果不存在则下载
+    if not os.path.exists(dataset_path):
+        print("数据集不存在，正在下载...")
+        os.makedirs("../dataset", exist_ok=True)
+        transform = transforms.Compose([transforms.ToTensor()])
+        trainset = torchvision.datasets.CIFAR10(root="../dataset", train=True, download=True, transform=transform)
+    
+    # 保存图像
+    save_images_from_cifar10(dataset_path, save_dir)

GoogLeNet-CIFAR10/Classification-normal/scripts/get_representation.py

@@ -0,0 +1,272 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import os
+import json
+from tqdm import tqdm
+
+class time_travel_saver:
+    """可视化数据提取器
+    
+    用于保存模型训练过程中的各种数据，包括：
+    1. 模型权重 (.pth)
+    2. 高维特征 (representation/*.npy)
+    3. 预测结果 (prediction/*.npy)
+    4. 标签数据 (label/labels.npy)
+    """
+    
+    def __init__(self, model, dataloader, device, save_dir, model_name, 
+                auto_save_embedding=False, layer_name=None,show = False):
+        """初始化
+        
+        Args:
+            model: 要保存的模型实例
+            dataloader: 数据加载器（必须是顺序加载的）
+            device: 计算设备(cpu or gpu)
+            save_dir: 保存根目录
+            model_name: 模型名称
+        """
+        self.model = model
+        self.dataloader = dataloader
+        self.device = device
+        self.save_dir = save_dir
+        self.model_name = model_name
+        self.auto_save = auto_save_embedding
+        self.layer_name = layer_name
+
+        if show and not layer_name:
+            layer_dimensions = self.show_dimensions()
+            # print(layer_dimensions)
+        
+    def show_dimensions(self):
+        """显示模型中所有层的名称和对应的维度
+        
+        这个函数会输出模型中所有层的名称和它们的输出维度，
+        帮助用户选择合适的层来提取特征。
+        
+        Returns:
+            layer_dimensions: 包含层名称和维度的字典
+        """
+        activation = {}
+        layer_dimensions = {}
+        
+        def get_activation(name):
+            def hook(model, input, output):
+                activation[name] = output.detach()
+            return hook
+        
+        # 注册钩子到所有层
+        handles = []
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Module) and not isinstance(module, nn.ModuleList) and not isinstance(module, nn.ModuleDict):
+                handles.append(module.register_forward_hook(get_activation(name)))
+        
+        self.model.eval()
+        with torch.no_grad():
+            # 获取一个batch来分析每层的输出维度
+            inputs, _ = next(iter(self.dataloader))
+            inputs = inputs.to(self.device)
+            _ = self.model(inputs)
+            
+            # 分析所有层的输出维度
+            print("\n模型各层的名称和维度:")
+            print("-" * 50)
+            print(f"{'层名称':<40} {'特征维度':<15} {'输出形状'}")
+            print("-" * 50)
+            
+            for name, feat in activation.items():
+                if feat is None:
+                    continue
+                
+                # 获取特征维度（展平后）
+                feat_dim = feat.view(feat.size(0), -1).size(1)
+                layer_dimensions[name] = feat_dim
+                # 打印层信息
+                shape_str = str(list(feat.shape))
+                print(f"{name:<40} {feat_dim:<15} {shape_str}")
+            
+            print("-" * 50)
+            print("注: 特征维度是将输出张量展平后的维度大小")
+            print("你可以通过修改time_travel_saver的layer_name参数来选择不同的层")
+            print("例如：layer_name='avg_pool'或layer_name='layer4'等")
+        
+        # 移除所有钩子
+        for handle in handles:
+            handle.remove()
+        
+        return layer_dimensions
+
+    def _extract_features_and_predictions(self):
+        """提取特征和预测结果
+        
+        Returns:
+            features: 高维特征 [样本数, 特征维度]
+            predictions: 预测结果 [样本数, 类别数]
+        """
+        features = []
+        predictions = []
+        indices = []
+        activation = {}
+        
+        def get_activation(name):
+            def hook(model, input, output):
+                # 只在需要时保存激活值，避免内存浪费
+                if name not in activation or activation[name] is None:
+                    activation[name] = output.detach()
+            return hook
+        
+        # 根据层的名称或维度来选择层
+
+        # 注册钩子到所有层
+        handles = []
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Module) and not isinstance(module, nn.ModuleList) and not isinstance(module, nn.ModuleDict):
+                handles.append(module.register_forward_hook(get_activation(name)))
+        
+        self.model.eval()
+        with torch.no_grad():
+            # 首先获取一个batch来分析每层的输出维度
+            inputs, _ = next(iter(self.dataloader))
+            inputs = inputs.to(self.device)
+            _ = self.model(inputs)
+            
+            # 如果指定了层名，则直接使用该层
+            if self.layer_name is not None:
+                if self.layer_name not in activation:
+                    raise ValueError(f"指定的层 {self.layer_name} 不存在于模型中")
+                
+                feat = activation[self.layer_name]
+                if feat is None:
+                    raise ValueError(f"指定的层 {self.layer_name} 没有输出特征")
+                
+                suitable_layer_name = self.layer_name
+                suitable_dim = feat.view(feat.size(0), -1).size(1)
+                print(f"使用指定的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
+            else:
+                # 找到维度在指定范围内的层
+                target_dim_range = (256, 2048)
+                suitable_layer_name = None
+                suitable_dim = None
+                
+                # 分析所有层的输出维度
+                for name, feat in activation.items():
+                    if feat is None:
+                        continue
+                    feat_dim = feat.view(feat.size(0), -1).size(1)
+                    if target_dim_range[0] <= feat_dim <= target_dim_range[1]:
+                        suitable_layer_name = name
+                        suitable_dim = feat_dim
+                        break
+                
+                if suitable_layer_name is None:
+                    raise ValueError("没有找到合适维度的特征层")
+                    
+                print(f"自动选择的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
+            
+            # 保存层信息
+            layer_info = {
+                'layer_id': suitable_layer_name,
+                'dim': suitable_dim
+            }
+            layer_info_path = os.path.join(os.path.dirname(self.save_dir), 'layer_info.json')
+            with open(layer_info_path, 'w') as f:
+                json.dump(layer_info, f)
+            
+            # 清除第一次运行的激活值
+            activation.clear()
+            
+            # 现在处理所有数据
+            for batch_idx, (inputs, _) in enumerate(tqdm(self.dataloader, desc="提取特征和预测结果")):
+                inputs = inputs.to(self.device)
+                outputs = self.model(inputs)  # 获取预测结果
+                
+                # 获取并处理特征
+                feat = activation[suitable_layer_name]
+                flat_features = torch.flatten(feat, start_dim=1)
+                features.append(flat_features.cpu().numpy())
+                predictions.append(outputs.cpu().numpy())
+                
+                # 清除本次的激活值
+                activation.clear()
+        
+        # 移除所有钩子
+        for handle in handles:
+            handle.remove()
+        
+        if len(features) > 0:
+            features = np.vstack(features)
+            predictions = np.vstack(predictions)
+            return features, predictions
+        else:
+            return np.array([]), np.array([])
+    
+    def save_lables_index(self, path):
+        """保存标签数据和索引信息
+        
+        Args:
+            path: 保存路径
+        """
+        os.makedirs(path, exist_ok=True)
+        labels_path = os.path.join(path, 'labels.npy')
+        index_path = os.path.join(path, 'index.json')
+        
+        # 尝试从不同的属性获取标签
+        try:
+            if hasattr(self.dataloader.dataset, 'targets'):
+                # CIFAR10/CIFAR100使用targets属性
+                labels = np.array(self.dataloader.dataset.targets)
+            elif hasattr(self.dataloader.dataset, 'labels'):
+                # 某些数据集使用labels属性
+                labels = np.array(self.dataloader.dataset.labels)
+            else:
+                # 如果上面的方法都不起作用，则从数据加载器中收集标签
+                labels = []
+                for _, batch_labels in self.dataloader:
+                    labels.append(batch_labels.numpy())
+                labels = np.concatenate(labels)
+            
+            # 保存标签数据
+            np.save(labels_path, labels)
+            print(f"标签数据已保存到 {labels_path}")
+            
+            # 创建数据集索引
+            num_samples = len(labels)
+            indices = list(range(num_samples))
+            
+            # 创建索引字典
+            index_dict = {
+                "train": list(range(50000)),  # 所有数据默认为训练集
+                "test": list(range(50000, 60000)),  # 测试集索引从50000到59999
+                "validation": []   # 初始为空
+            }
+            
+            # 保存索引到JSON文件
+            with open(index_path, 'w') as f:
+                json.dump(index_dict, f, indent=4)
+            
+            print(f"数据集索引已保存到 {index_path}")
+            
+        except Exception as e:
+            print(f"保存标签和索引时出错: {e}")
+
+    def save_checkpoint_embeddings_predictions(self, model = None):
+        """保存所有数据"""
+        if model is not None:
+            self.model = model
+        # 保存模型权重
+        os.makedirs(self.save_dir, exist_ok=True)
+        model_path = os.path.join(self.save_dir,'model.pth')
+        torch.save(self.model.state_dict(), model_path)
+        
+        if self.auto_save:
+            # 提取并保存特征和预测结果
+            features, predictions = self._extract_features_and_predictions()
+            
+            # 保存特征 
+            np.save(os.path.join(self.save_dir, 'embeddings.npy'), features)
+            # 保存预测结果
+            np.save(os.path.join(self.save_dir, 'predictions.npy'), predictions)
+            print("\n保存了以下数据:")
+            print(f"- 模型权重: {model_path}")
+            print(f"- 特征向量: [样本数: {features.shape[0]}, 特征维度: {features.shape[1]}]")
+            print(f"- 预测结果: [样本数: {predictions.shape[0]}, 类别数: {predictions.shape[1]}]")

GoogLeNet-CIFAR10/Classification-normal/scripts/model.py

@@ -0,0 +1,189 @@
+'''
+GoogLeNet in PyTorch.
+
+Paper: "Going Deeper with Convolutions"
+Reference: https://arxiv.org/abs/1409.4842
+
+主要特点：
+1. 使用Inception模块，通过多尺度卷积提取特征
+2. 采用1x1卷积降维，减少计算量
+3. 使用全局平均池化代替全连接层
+4. 引入辅助分类器帮助训练（本实现未包含）
+'''
+import torch
+import torch.nn as nn
+
+class Inception(nn.Module):
+    '''Inception模块
+    
+    Args:
+        in_planes: 输入通道数
+        n1x1: 1x1卷积分支的输出通道数
+        n3x3red: 3x3卷积分支的降维通道数
+        n3x3: 3x3卷积分支的输出通道数
+        n5x5red: 5x5卷积分支的降维通道数
+        n5x5: 5x5卷积分支的输出通道数
+        pool_planes: 池化分支的输出通道数
+    '''
+    def __init__(self, in_planes, n1x1, n3x3red, n3x3, n5x5red, n5x5, pool_planes):
+        super(Inception, self).__init__()
+        
+        # 1x1卷积分支
+        self.branch1 = nn.Sequential(
+            nn.Conv2d(in_planes, n1x1, kernel_size=1),
+            nn.BatchNorm2d(n1x1),
+            nn.ReLU(True),
+        )
+
+        # 1x1 -> 3x3卷积分支
+        self.branch2 = nn.Sequential(
+            nn.Conv2d(in_planes, n3x3red, kernel_size=1),
+            nn.BatchNorm2d(n3x3red),
+            nn.ReLU(True),
+            nn.Conv2d(n3x3red, n3x3, kernel_size=3, padding=1),
+            nn.BatchNorm2d(n3x3),
+            nn.ReLU(True),
+        )
+
+        # 1x1 -> 5x5卷积分支（用两个3x3代替）
+        self.branch3 = nn.Sequential(
+            nn.Conv2d(in_planes, n5x5red, kernel_size=1),
+            nn.BatchNorm2d(n5x5red),
+            nn.ReLU(True),
+            nn.Conv2d(n5x5red, n5x5, kernel_size=3, padding=1),
+            nn.BatchNorm2d(n5x5),
+            nn.ReLU(True),
+            nn.Conv2d(n5x5, n5x5, kernel_size=3, padding=1),
+            nn.BatchNorm2d(n5x5),
+            nn.ReLU(True),
+        )
+
+        # 3x3池化 -> 1x1卷积分支
+        self.branch4 = nn.Sequential(
+            nn.MaxPool2d(3, stride=1, padding=1),
+            nn.Conv2d(in_planes, pool_planes, kernel_size=1),
+            nn.BatchNorm2d(pool_planes),
+            nn.ReLU(True),
+        )
+
+    def forward(self, x):
+        '''前向传播，将四个分支的输出在通道维度上拼接'''
+        b1 = self.branch1(x)
+        b2 = self.branch2(x)
+        b3 = self.branch3(x)
+        b4 = self.branch4(x)
+        return torch.cat([b1, b2, b3, b4], 1)
+
+
+class GoogLeNet(nn.Module):
+    '''GoogLeNet/Inception v1网络
+    
+    特点：
+    1. 使用Inception模块构建深层网络
+    2. 通过1x1卷积降维减少计算量
+    3. 使用全局平均池化代替全连接层减少参数量
+    '''
+    def __init__(self, num_classes=10):
+        super(GoogLeNet, self).__init__()
+        
+        # 第一阶段：标准卷积层
+        self.pre_layers = nn.Sequential(
+            nn.Conv2d(3, 192, kernel_size=3, padding=1),
+            nn.BatchNorm2d(192),
+            nn.ReLU(True),
+        )
+
+        # 第二阶段：2个Inception模块
+        self.a3 = Inception(192,  64,  96, 128, 16, 32, 32)  # 输出通道：256
+        self.b3 = Inception(256, 128, 128, 192, 32, 96, 64)  # 输出通道：480
+
+        # 最大池化层
+        self.maxpool = nn.MaxPool2d(3, stride=2, padding=1)
+
+        # 第三阶段：5个Inception模块
+        self.a4 = Inception(480, 192,  96, 208, 16,  48,  64)  # 输出通道：512
+        self.b4 = Inception(512, 160, 112, 224, 24,  64,  64)  # 输出通道：512
+        self.c4 = Inception(512, 128, 128, 256, 24,  64,  64)  # 输出通道：512
+        self.d4 = Inception(512, 112, 144, 288, 32,  64,  64)  # 输出通道：528
+        self.e4 = Inception(528, 256, 160, 320, 32, 128, 128)  # 输出通道：832
+
+        # 第四阶段：2个Inception模块
+        self.a5 = Inception(832, 256, 160, 320, 32, 128, 128)  # 输出通道：832
+        self.b5 = Inception(832, 384, 192, 384, 48, 128, 128)  # 输出通道：1024
+
+        # 全局平均池化和分类器
+        self.avgpool = nn.AvgPool2d(8, stride=1)
+        self.linear = nn.Linear(1024, num_classes)
+
+    def forward(self, x):
+        # 第一阶段
+        out = self.pre_layers(x)
+        
+        # 第二阶段
+        out = self.a3(out)
+        out = self.b3(out)
+        out = self.maxpool(out)
+        
+        # 第三阶段
+        out = self.a4(out)
+        out = self.b4(out)
+        out = self.c4(out)
+        out = self.d4(out)
+        out = self.e4(out)
+        out = self.maxpool(out)
+        
+        # 第四阶段
+        out = self.a5(out)
+        out = self.b5(out)
+        
+        # 分类器
+        out = self.avgpool(out)
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+    def feature(self, x):
+        # 第一阶段
+        out = self.pre_layers(x)
+        
+        # 第二阶段
+        out = self.a3(out)
+        out = self.b3(out)
+        out = self.maxpool(out)
+        
+        # 第三阶段
+        out = self.a4(out)
+        out = self.b4(out)
+        out = self.c4(out)
+        out = self.d4(out)
+        out = self.e4(out)
+        out = self.maxpool(out)
+        
+        # 第四阶段
+        out = self.a5(out)
+        out = self.b5(out)
+        
+        # 分类器
+        out = self.avgpool(out)
+        return out
+
+    def prediction(self, out):
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+def test():
+    """测试函数"""
+    net = GoogLeNet()
+    x = torch.randn(1, 3, 32, 32)
+    y = net(x)
+    print(y.size())
+    
+    # 打印模型结构
+    from torchinfo import summary
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    net = net.to(device)
+    summary(net, (1, 3, 32, 32))
+
+if __name__ == '__main__':
+    test()

GoogLeNet-CIFAR10/Classification-normal/scripts/train.py

@@ -0,0 +1,238 @@
+import sys
+import os
+import yaml
+from pathlib import Path
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import time
+import logging
+import numpy as np
+from tqdm import tqdm
+
+
+from dataset_utils import get_cifar10_dataloaders
+from model import GoogLeNet
+from get_representation import time_travel_saver
+
+def setup_logger(log_file):
+    """配置日志记录器，如果日志文件存在则覆盖
+    
+    Args:
+        log_file: 日志文件路径
+        
+    Returns:
+        logger: 配置好的日志记录器
+    """
+    # 创建logger
+    logger = logging.getLogger('train')
+    logger.setLevel(logging.INFO)
+    
+    # 移除现有的处理器
+    if logger.hasHandlers():
+        logger.handlers.clear()
+    
+    # 创建文件处理器，使用'w'模式覆盖现有文件
+    fh = logging.FileHandler(log_file, mode='w')
+    fh.setLevel(logging.INFO)
+    
+    # 创建控制台处理器
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.INFO)
+    
+    # 创建格式器
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    fh.setFormatter(formatter)
+    ch.setFormatter(formatter)
+    
+    # 添加处理器
+    logger.addHandler(fh)
+    logger.addHandler(ch)
+    
+    return logger
+
+def train_model(model, trainloader, testloader, epochs=200, lr=0.1, device='cuda:0',
+               save_dir='./epochs', model_name='model', interval=1):
+    """通用的模型训练函数
+    Args:
+        model: 要训练的模型
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+        epochs: 训练轮数
+        lr: 学习率
+        device: 训练设备，格式为'cuda:N'，其中N为GPU编号（0,1,2,3）
+        save_dir: 模型保存目录
+        model_name: 模型名称
+        interval: 模型保存间隔
+    """
+    # 检查并设置GPU设备
+    if not torch.cuda.is_available():
+        print("CUDA不可用，将使用CPU训练")
+        device = 'cpu'
+    elif not device.startswith('cuda:'):
+        device = f'cuda:0'
+    
+    # 确保device格式正确
+    if device.startswith('cuda:'):
+        gpu_id = int(device.split(':')[1])
+        if gpu_id >= torch.cuda.device_count():
+            print(f"GPU {gpu_id} 不可用，将使用GPU 0")
+            device = 'cuda:0'
+    
+    # 设置保存目录
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    
+    # 设置日志文件路径
+    log_file = os.path.join(os.path.dirname(save_dir),'epochs', 'train.log')
+    if not os.path.exists(os.path.dirname(log_file)):
+        os.makedirs(os.path.dirname(log_file))
+    
+    logger = setup_logger(log_file)
+    
+    # 损失函数和优化器
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
+    
+    # 移动模型到指定设备
+    model = model.to(device)
+    best_acc = 0
+    start_time = time.time()
+    
+    logger.info(f'开始训练 {model_name}')
+    logger.info(f'总轮数: {epochs}, 学习率: {lr}, 设备: {device}')
+    
+    for epoch in range(epochs):
+        # 训练阶段
+        model.train()
+        train_loss = 0
+        correct = 0
+        total = 0
+        
+        train_pbar = tqdm(trainloader, desc=f'Epoch {epoch+1}/{epochs} [Train]')
+        for batch_idx, (inputs, targets) in enumerate(train_pbar):
+            inputs, targets = inputs.to(device), targets.to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+            
+            train_loss += loss.item()
+            _, predicted = outputs.max(1)
+            total += targets.size(0)
+            correct += predicted.eq(targets).sum().item()
+            
+            # 更新进度条
+            train_pbar.set_postfix({
+                'loss': f'{train_loss/(batch_idx+1):.3f}',
+                'acc': f'{100.*correct/total:.2f}%'
+            })
+        
+        # 保存训练阶段的准确率
+        train_acc = 100.*correct/total
+        train_correct = correct
+        train_total = total
+        
+        # 测试阶段
+        model.eval()
+        test_loss = 0
+        correct = 0
+        total = 0
+        
+        test_pbar = tqdm(testloader, desc=f'Epoch {epoch+1}/{epochs} [Test]')
+        with torch.no_grad():
+            for batch_idx, (inputs, targets) in enumerate(test_pbar):
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                loss = criterion(outputs, targets)
+                
+                test_loss += loss.item()
+                _, predicted = outputs.max(1)
+                total += targets.size(0)
+                correct += predicted.eq(targets).sum().item()
+        
+                # 更新进度条
+                test_pbar.set_postfix({
+                    'loss': f'{test_loss/(batch_idx+1):.3f}',
+                    'acc': f'{100.*correct/total:.2f}%'
+                })
+        
+        # 计算测试精度
+        acc = 100.*correct/total
+        
+        # 记录训练和测试的损失与准确率
+        logger.info(f'Epoch: {epoch+1} | Train Loss: {train_loss/(len(trainloader)):.3f} | Train Acc: {train_acc:.2f}% | '
+                   f'Test Loss: {test_loss/(batch_idx+1):.3f} | Test Acc: {acc:.2f}%')
+        
+        # 保存可视化训练过程所需要的文件
+        if (epoch + 1) % interval  == 0 or (epoch == 0): 
+            # 创建一个专门用于收集embedding的顺序dataloader，拼接训练集和测试集
+            from torch.utils.data import ConcatDataset
+            
+            def custom_collate_fn(batch):
+                # 确保所有数据都是张量
+                data = [item[0] for item in batch]  # 图像
+                target = [item[1] for item in batch]  # 标签
+                
+                # 将列表转换为张量
+                data = torch.stack(data, 0)
+                target = torch.tensor(target)
+                
+                return [data, target]
+            
+            # 合并训练集和测试集
+            combined_dataset = ConcatDataset([trainloader.dataset, testloader.dataset])
+            
+            # 创建顺序数据加载器
+            ordered_loader = torch.utils.data.DataLoader(
+                combined_dataset,  # 使用合并后的数据集
+                batch_size=trainloader.batch_size,
+                shuffle=False,  # 确保顺序加载
+                num_workers=trainloader.num_workers,
+                collate_fn=custom_collate_fn  # 使用自定义的collate函数
+            )
+            epoch_save_dir = os.path.join(save_dir, f'epoch_{epoch+1}')
+            save_model = time_travel_saver(model, ordered_loader, device, epoch_save_dir, model_name, 
+                         show=True, layer_name='avgpool', auto_save_embedding=True)
+            save_model.save_checkpoint_embeddings_predictions()
+            if epoch == 0:
+                save_model.save_lables_index(path = "../dataset")
+            
+        scheduler.step()
+    
+    logger.info('训练完成!')
+
+def main():
+    # 加载配置文件
+    config_path = Path(__file__).parent / 'train.yaml'
+    with open(config_path) as f:
+        config = yaml.safe_load(f)
+    
+    # 创建模型
+    model = GoogLeNet(num_classes=10)
+    
+    # 获取数据加载器
+    trainloader, testloader = get_cifar10_dataloaders(
+        batch_size=128, 
+        num_workers=2, 
+        local_dataset_path=config['dataset_path'],
+        shuffle=True    
+    )
+    
+    # 训练模型
+    train_model(
+        model=model,
+        trainloader=trainloader,
+        testloader=testloader,
+        epochs=config['epochs'],
+        lr=config['lr'],
+        device=f'cuda:{config["gpu"]}',
+        save_dir='../epochs',
+        model_name='GoogLeNet',
+        interval=config['interval']
+    )
+
+if __name__ == '__main__':
+    main()

GoogLeNet-CIFAR10/Classification-normal/scripts/train.yaml

@@ -0,0 +1,7 @@
+batch_size: 128
+num_workers: 2
+dataset_path: ../dataset
+epochs: 50
+gpu: 0
+lr: 0.1
+interval: 2

Image/LeNet5/code/backdoor_train.log

@@ -1,253 +0,0 @@
-2025-03-14 18:51:19,652 - train - INFO - 开始训练 lenet5
-2025-03-14 18:51:19,652 - train - INFO - 总轮数: 50, 学习率: 0.1, 设备: cuda:2
-2025-03-14 18:51:20,380 - train - INFO - Epoch: 1 | Batch: 0 | Loss: 2.303 | Acc: 10.16%
-2025-03-14 18:51:22,789 - train - INFO - Epoch: 1 | Batch: 100 | Loss: 2.208 | Acc: 19.59%
-2025-03-14 18:51:25,178 - train - INFO - Epoch: 1 | Batch: 200 | Loss: 2.138 | Acc: 20.32%
-2025-03-14 18:51:27,268 - train - INFO - Epoch: 1 | Batch: 300 | Loss: 2.075 | Acc: 22.09%
-2025-03-14 18:51:30,404 - train - INFO - Epoch: 1 | Test Loss: 1.950 | Test Acc: 25.94%
-2025-03-14 18:51:30,814 - train - INFO - Epoch: 2 | Batch: 0 | Loss: 2.080 | Acc: 19.53%
-2025-03-14 18:51:33,059 - train - INFO - Epoch: 2 | Batch: 100 | Loss: 1.910 | Acc: 26.99%
-2025-03-14 18:51:35,303 - train - INFO - Epoch: 2 | Batch: 200 | Loss: 1.907 | Acc: 27.06%
-2025-03-14 18:51:37,458 - train - INFO - Epoch: 2 | Batch: 300 | Loss: 1.891 | Acc: 27.89%
-2025-03-14 18:51:40,819 - train - INFO - Epoch: 2 | Test Loss: 1.806 | Test Acc: 31.65%
-2025-03-14 18:51:50,241 - train - INFO - Epoch: 3 | Batch: 0 | Loss: 1.770 | Acc: 29.69%
-2025-03-14 18:51:52,600 - train - INFO - Epoch: 3 | Batch: 100 | Loss: 1.857 | Acc: 29.28%
-2025-03-14 18:51:54,824 - train - INFO - Epoch: 3 | Batch: 200 | Loss: 1.844 | Acc: 30.26%
-2025-03-14 18:51:57,048 - train - INFO - Epoch: 3 | Batch: 300 | Loss: 1.846 | Acc: 30.12%
-2025-03-14 18:52:00,409 - train - INFO - Epoch: 3 | Test Loss: 1.758 | Test Acc: 33.70%
-2025-03-14 18:52:00,576 - train - INFO - Epoch: 4 | Batch: 0 | Loss: 1.830 | Acc: 28.91%
-2025-03-14 18:52:02,690 - train - INFO - Epoch: 4 | Batch: 100 | Loss: 1.814 | Acc: 31.25%
-2025-03-14 18:52:04,841 - train - INFO - Epoch: 4 | Batch: 200 | Loss: 1.804 | Acc: 31.78%
-2025-03-14 18:52:06,995 - train - INFO - Epoch: 4 | Batch: 300 | Loss: 1.805 | Acc: 32.05%
-2025-03-14 18:52:10,157 - train - INFO - Epoch: 4 | Test Loss: 1.777 | Test Acc: 33.31%
-2025-03-14 18:52:19,581 - train - INFO - Epoch: 5 | Batch: 0 | Loss: 1.773 | Acc: 35.94%
-2025-03-14 18:52:21,775 - train - INFO - Epoch: 5 | Batch: 100 | Loss: 1.773 | Acc: 34.38%
-2025-03-14 18:52:23,865 - train - INFO - Epoch: 5 | Batch: 200 | Loss: 1.751 | Acc: 35.28%
-2025-03-14 18:52:26,032 - train - INFO - Epoch: 5 | Batch: 300 | Loss: 1.740 | Acc: 35.98%
-2025-03-14 18:52:29,181 - train - INFO - Epoch: 5 | Test Loss: 1.667 | Test Acc: 36.89%
-2025-03-14 18:52:29,344 - train - INFO - Epoch: 6 | Batch: 0 | Loss: 1.727 | Acc: 38.28%
-2025-03-14 18:52:31,511 - train - INFO - Epoch: 6 | Batch: 100 | Loss: 1.734 | Acc: 36.10%
-2025-03-14 18:52:33,763 - train - INFO - Epoch: 6 | Batch: 200 | Loss: 1.723 | Acc: 36.55%
-2025-03-14 18:52:35,894 - train - INFO - Epoch: 6 | Batch: 300 | Loss: 1.719 | Acc: 36.65%
-2025-03-14 18:52:39,232 - train - INFO - Epoch: 6 | Test Loss: 1.720 | Test Acc: 36.32%
-2025-03-14 18:52:48,612 - train - INFO - Epoch: 7 | Batch: 0 | Loss: 1.590 | Acc: 45.31%
-2025-03-14 18:52:50,865 - train - INFO - Epoch: 7 | Batch: 100 | Loss: 1.648 | Acc: 39.59%
-2025-03-14 18:52:53,028 - train - INFO - Epoch: 7 | Batch: 200 | Loss: 1.659 | Acc: 38.78%
-2025-03-14 18:52:55,063 - train - INFO - Epoch: 7 | Batch: 300 | Loss: 1.656 | Acc: 39.38%
-2025-03-14 18:52:58,384 - train - INFO - Epoch: 7 | Test Loss: 1.744 | Test Acc: 34.71%
-2025-03-14 18:52:58,567 - train - INFO - Epoch: 8 | Batch: 0 | Loss: 1.699 | Acc: 34.38%
-2025-03-14 18:53:00,712 - train - INFO - Epoch: 8 | Batch: 100 | Loss: 1.627 | Acc: 40.86%
-2025-03-14 18:53:03,147 - train - INFO - Epoch: 8 | Batch: 200 | Loss: 1.647 | Acc: 40.62%
-2025-03-14 18:53:05,342 - train - INFO - Epoch: 8 | Batch: 300 | Loss: 1.647 | Acc: 40.75%
-2025-03-14 18:53:08,945 - train - INFO - Epoch: 8 | Test Loss: 1.612 | Test Acc: 41.16%
-2025-03-14 18:53:18,871 - train - INFO - Epoch: 9 | Batch: 0 | Loss: 1.812 | Acc: 36.72%
-2025-03-14 18:53:21,249 - train - INFO - Epoch: 9 | Batch: 100 | Loss: 1.644 | Acc: 40.66%
-2025-03-14 18:53:23,450 - train - INFO - Epoch: 9 | Batch: 200 | Loss: 1.627 | Acc: 41.32%
-2025-03-14 18:53:25,638 - train - INFO - Epoch: 9 | Batch: 300 | Loss: 1.631 | Acc: 41.23%
-2025-03-14 18:53:28,926 - train - INFO - Epoch: 9 | Test Loss: 1.592 | Test Acc: 42.59%
-2025-03-14 18:53:29,088 - train - INFO - Epoch: 10 | Batch: 0 | Loss: 1.626 | Acc: 41.41%
-2025-03-14 18:53:31,206 - train - INFO - Epoch: 10 | Batch: 100 | Loss: 1.612 | Acc: 42.34%
-2025-03-14 18:53:33,239 - train - INFO - Epoch: 10 | Batch: 200 | Loss: 1.617 | Acc: 42.14%
-2025-03-14 18:53:35,375 - train - INFO - Epoch: 10 | Batch: 300 | Loss: 1.623 | Acc: 41.96%
-2025-03-14 18:53:38,613 - train - INFO - Epoch: 10 | Test Loss: 1.616 | Test Acc: 43.11%
-2025-03-14 18:53:47,913 - train - INFO - Epoch: 11 | Batch: 0 | Loss: 1.573 | Acc: 38.28%
-2025-03-14 18:53:50,081 - train - INFO - Epoch: 11 | Batch: 100 | Loss: 1.611 | Acc: 43.01%
-2025-03-14 18:53:52,274 - train - INFO - Epoch: 11 | Batch: 200 | Loss: 1.596 | Acc: 43.17%
-2025-03-14 18:53:54,447 - train - INFO - Epoch: 11 | Batch: 300 | Loss: 1.589 | Acc: 43.13%
-2025-03-14 18:53:57,925 - train - INFO - Epoch: 11 | Test Loss: 1.554 | Test Acc: 45.18%
-2025-03-14 18:53:58,109 - train - INFO - Epoch: 12 | Batch: 0 | Loss: 1.450 | Acc: 45.31%
-2025-03-14 18:54:00,335 - train - INFO - Epoch: 12 | Batch: 100 | Loss: 1.610 | Acc: 41.93%
-2025-03-14 18:54:02,491 - train - INFO - Epoch: 12 | Batch: 200 | Loss: 1.611 | Acc: 42.44%
-2025-03-14 18:54:04,671 - train - INFO - Epoch: 12 | Batch: 300 | Loss: 1.594 | Acc: 42.97%
-2025-03-14 18:54:07,901 - train - INFO - Epoch: 12 | Test Loss: 1.563 | Test Acc: 47.00%
-2025-03-14 18:54:17,119 - train - INFO - Epoch: 13 | Batch: 0 | Loss: 1.498 | Acc: 53.12%
-2025-03-14 18:54:19,213 - train - INFO - Epoch: 13 | Batch: 100 | Loss: 1.624 | Acc: 42.75%
-2025-03-14 18:54:21,306 - train - INFO - Epoch: 13 | Batch: 200 | Loss: 1.606 | Acc: 43.22%
-2025-03-14 18:54:23,344 - train - INFO - Epoch: 13 | Batch: 300 | Loss: 1.600 | Acc: 43.19%
-2025-03-14 18:54:26,670 - train - INFO - Epoch: 13 | Test Loss: 1.666 | Test Acc: 39.55%
-2025-03-14 18:54:26,845 - train - INFO - Epoch: 14 | Batch: 0 | Loss: 1.680 | Acc: 39.84%
-2025-03-14 18:54:28,959 - train - INFO - Epoch: 14 | Batch: 100 | Loss: 1.583 | Acc: 43.79%
-2025-03-14 18:54:31,171 - train - INFO - Epoch: 14 | Batch: 200 | Loss: 1.568 | Acc: 44.59%
-2025-03-14 18:54:33,362 - train - INFO - Epoch: 14 | Batch: 300 | Loss: 1.581 | Acc: 44.00%
-2025-03-14 18:54:36,845 - train - INFO - Epoch: 14 | Test Loss: 1.533 | Test Acc: 45.22%
-2025-03-14 18:54:47,390 - train - INFO - Epoch: 15 | Batch: 0 | Loss: 1.500 | Acc: 46.88%
-2025-03-14 18:54:49,691 - train - INFO - Epoch: 15 | Batch: 100 | Loss: 1.537 | Acc: 46.24%
-2025-03-14 18:54:51,869 - train - INFO - Epoch: 15 | Batch: 200 | Loss: 1.557 | Acc: 45.44%
-2025-03-14 18:54:53,985 - train - INFO - Epoch: 15 | Batch: 300 | Loss: 1.564 | Acc: 45.09%
-2025-03-14 18:54:57,177 - train - INFO - Epoch: 15 | Test Loss: 1.530 | Test Acc: 47.11%
-2025-03-14 18:54:57,341 - train - INFO - Epoch: 16 | Batch: 0 | Loss: 1.560 | Acc: 48.44%
-2025-03-14 18:54:59,495 - train - INFO - Epoch: 16 | Batch: 100 | Loss: 1.582 | Acc: 43.63%
-2025-03-14 18:55:01,686 - train - INFO - Epoch: 16 | Batch: 200 | Loss: 1.583 | Acc: 43.79%
-2025-03-14 18:55:03,817 - train - INFO - Epoch: 16 | Batch: 300 | Loss: 1.588 | Acc: 43.62%
-2025-03-14 18:55:07,207 - train - INFO - Epoch: 16 | Test Loss: 1.551 | Test Acc: 45.91%
-2025-03-14 18:55:16,376 - train - INFO - Epoch: 17 | Batch: 0 | Loss: 1.535 | Acc: 46.09%
-2025-03-14 18:55:18,547 - train - INFO - Epoch: 17 | Batch: 100 | Loss: 1.551 | Acc: 45.02%
-2025-03-14 18:55:20,727 - train - INFO - Epoch: 17 | Batch: 200 | Loss: 1.544 | Acc: 45.37%
-2025-03-14 18:55:22,965 - train - INFO - Epoch: 17 | Batch: 300 | Loss: 1.556 | Acc: 44.91%
-2025-03-14 18:55:26,302 - train - INFO - Epoch: 17 | Test Loss: 1.539 | Test Acc: 45.68%
-2025-03-14 18:55:26,472 - train - INFO - Epoch: 18 | Batch: 0 | Loss: 1.663 | Acc: 42.19%
-2025-03-14 18:55:28,773 - train - INFO - Epoch: 18 | Batch: 100 | Loss: 1.586 | Acc: 44.14%
-2025-03-14 18:55:30,980 - train - INFO - Epoch: 18 | Batch: 200 | Loss: 1.577 | Acc: 44.25%
-2025-03-14 18:55:33,160 - train - INFO - Epoch: 18 | Batch: 300 | Loss: 1.569 | Acc: 44.71%
-2025-03-14 18:55:36,539 - train - INFO - Epoch: 18 | Test Loss: 1.540 | Test Acc: 45.29%
-2025-03-14 18:55:45,385 - train - INFO - Epoch: 19 | Batch: 0 | Loss: 1.668 | Acc: 37.50%
-2025-03-14 18:55:47,447 - train - INFO - Epoch: 19 | Batch: 100 | Loss: 1.580 | Acc: 44.69%
-2025-03-14 18:55:49,614 - train - INFO - Epoch: 19 | Batch: 200 | Loss: 1.562 | Acc: 45.13%
-2025-03-14 18:55:51,710 - train - INFO - Epoch: 19 | Batch: 300 | Loss: 1.561 | Acc: 45.20%
-2025-03-14 18:55:55,165 - train - INFO - Epoch: 19 | Test Loss: 1.507 | Test Acc: 48.32%
-2025-03-14 18:55:55,342 - train - INFO - Epoch: 20 | Batch: 0 | Loss: 1.495 | Acc: 43.75%
-2025-03-14 18:55:57,635 - train - INFO - Epoch: 20 | Batch: 100 | Loss: 1.536 | Acc: 45.37%
-2025-03-14 18:55:59,839 - train - INFO - Epoch: 20 | Batch: 200 | Loss: 1.547 | Acc: 44.96%
-2025-03-14 18:56:01,970 - train - INFO - Epoch: 20 | Batch: 300 | Loss: 1.548 | Acc: 45.40%
-2025-03-14 18:56:05,495 - train - INFO - Epoch: 20 | Test Loss: 1.528 | Test Acc: 46.53%
-2025-03-14 18:56:14,208 - train - INFO - Epoch: 21 | Batch: 0 | Loss: 1.659 | Acc: 46.09%
-2025-03-14 18:56:16,352 - train - INFO - Epoch: 21 | Batch: 100 | Loss: 1.562 | Acc: 45.17%
-2025-03-14 18:56:18,446 - train - INFO - Epoch: 21 | Batch: 200 | Loss: 1.566 | Acc: 45.19%
-2025-03-14 18:56:20,611 - train - INFO - Epoch: 21 | Batch: 300 | Loss: 1.556 | Acc: 45.54%
-2025-03-14 18:56:24,010 - train - INFO - Epoch: 21 | Test Loss: 1.623 | Test Acc: 44.64%
-2025-03-14 18:56:24,185 - train - INFO - Epoch: 22 | Batch: 0 | Loss: 1.453 | Acc: 47.66%
-2025-03-14 18:56:26,310 - train - INFO - Epoch: 22 | Batch: 100 | Loss: 1.546 | Acc: 45.95%
-2025-03-14 18:56:28,333 - train - INFO - Epoch: 22 | Batch: 200 | Loss: 1.550 | Acc: 45.71%
-2025-03-14 18:56:30,502 - train - INFO - Epoch: 22 | Batch: 300 | Loss: 1.547 | Acc: 45.70%
-2025-03-14 18:56:33,715 - train - INFO - Epoch: 22 | Test Loss: 1.516 | Test Acc: 46.97%
-2025-03-14 18:56:42,854 - train - INFO - Epoch: 23 | Batch: 0 | Loss: 1.692 | Acc: 45.31%
-2025-03-14 18:56:45,157 - train - INFO - Epoch: 23 | Batch: 100 | Loss: 1.559 | Acc: 44.98%
-2025-03-14 18:56:47,388 - train - INFO - Epoch: 23 | Batch: 200 | Loss: 1.545 | Acc: 45.38%
-2025-03-14 18:56:49,617 - train - INFO - Epoch: 23 | Batch: 300 | Loss: 1.546 | Acc: 45.66%
-2025-03-14 18:56:52,961 - train - INFO - Epoch: 23 | Test Loss: 1.481 | Test Acc: 48.12%
-2025-03-14 18:56:53,138 - train - INFO - Epoch: 24 | Batch: 0 | Loss: 1.525 | Acc: 48.44%
-2025-03-14 18:56:55,474 - train - INFO - Epoch: 24 | Batch: 100 | Loss: 1.538 | Acc: 46.25%
-2025-03-14 18:56:57,728 - train - INFO - Epoch: 24 | Batch: 200 | Loss: 1.548 | Acc: 45.48%
-2025-03-14 18:57:00,002 - train - INFO - Epoch: 24 | Batch: 300 | Loss: 1.547 | Acc: 45.61%
-2025-03-14 18:57:03,345 - train - INFO - Epoch: 24 | Test Loss: 1.480 | Test Acc: 48.34%
-2025-03-14 18:57:12,515 - train - INFO - Epoch: 25 | Batch: 0 | Loss: 1.395 | Acc: 45.31%
-2025-03-14 18:57:14,685 - train - INFO - Epoch: 25 | Batch: 100 | Loss: 1.532 | Acc: 46.67%
-2025-03-14 18:57:16,799 - train - INFO - Epoch: 25 | Batch: 200 | Loss: 1.524 | Acc: 46.82%
-2025-03-14 18:57:19,039 - train - INFO - Epoch: 25 | Batch: 300 | Loss: 1.517 | Acc: 46.98%
-2025-03-14 18:57:22,516 - train - INFO - Epoch: 25 | Test Loss: 1.553 | Test Acc: 46.03%
-2025-03-14 18:57:22,683 - train - INFO - Epoch: 26 | Batch: 0 | Loss: 1.736 | Acc: 44.53%
-2025-03-14 18:57:24,762 - train - INFO - Epoch: 26 | Batch: 100 | Loss: 1.509 | Acc: 46.84%
-2025-03-14 18:57:26,861 - train - INFO - Epoch: 26 | Batch: 200 | Loss: 1.519 | Acc: 46.68%
-2025-03-14 18:57:29,066 - train - INFO - Epoch: 26 | Batch: 300 | Loss: 1.519 | Acc: 46.61%
-2025-03-14 18:57:32,297 - train - INFO - Epoch: 26 | Test Loss: 1.525 | Test Acc: 46.22%
-2025-03-14 18:57:41,935 - train - INFO - Epoch: 27 | Batch: 0 | Loss: 1.524 | Acc: 50.78%
-2025-03-14 18:57:44,126 - train - INFO - Epoch: 27 | Batch: 100 | Loss: 1.526 | Acc: 45.78%
-2025-03-14 18:57:46,507 - train - INFO - Epoch: 27 | Batch: 200 | Loss: 1.519 | Acc: 46.54%
-2025-03-14 18:57:48,982 - train - INFO - Epoch: 27 | Batch: 300 | Loss: 1.525 | Acc: 46.30%
-2025-03-14 18:57:52,953 - train - INFO - Epoch: 27 | Test Loss: 1.485 | Test Acc: 47.34%
-2025-03-14 18:57:53,134 - train - INFO - Epoch: 28 | Batch: 0 | Loss: 1.597 | Acc: 44.53%
-2025-03-14 18:57:55,479 - train - INFO - Epoch: 28 | Batch: 100 | Loss: 1.521 | Acc: 47.34%
-2025-03-14 18:57:57,669 - train - INFO - Epoch: 28 | Batch: 200 | Loss: 1.527 | Acc: 46.73%
-2025-03-14 18:57:59,857 - train - INFO - Epoch: 28 | Batch: 300 | Loss: 1.540 | Acc: 46.01%
-2025-03-14 18:58:03,284 - train - INFO - Epoch: 28 | Test Loss: 1.585 | Test Acc: 46.93%
-2025-03-14 18:58:13,439 - train - INFO - Epoch: 29 | Batch: 0 | Loss: 1.544 | Acc: 47.66%
-2025-03-14 18:58:15,897 - train - INFO - Epoch: 29 | Batch: 100 | Loss: 1.481 | Acc: 48.57%
-2025-03-14 18:58:18,632 - train - INFO - Epoch: 29 | Batch: 200 | Loss: 1.503 | Acc: 47.80%
-2025-03-14 18:58:20,904 - train - INFO - Epoch: 29 | Batch: 300 | Loss: 1.512 | Acc: 47.66%
-2025-03-14 18:58:24,312 - train - INFO - Epoch: 29 | Test Loss: 1.542 | Test Acc: 45.92%
-2025-03-14 18:58:24,483 - train - INFO - Epoch: 30 | Batch: 0 | Loss: 1.539 | Acc: 44.53%
-2025-03-14 18:58:26,696 - train - INFO - Epoch: 30 | Batch: 100 | Loss: 1.498 | Acc: 47.67%
-2025-03-14 18:58:28,804 - train - INFO - Epoch: 30 | Batch: 200 | Loss: 1.515 | Acc: 47.15%
-2025-03-14 18:58:31,277 - train - INFO - Epoch: 30 | Batch: 300 | Loss: 1.509 | Acc: 47.32%
-2025-03-14 18:58:34,684 - train - INFO - Epoch: 30 | Test Loss: 1.489 | Test Acc: 48.24%
-2025-03-14 18:58:43,983 - train - INFO - Epoch: 31 | Batch: 0 | Loss: 1.627 | Acc: 44.53%
-2025-03-14 18:58:46,126 - train - INFO - Epoch: 31 | Batch: 100 | Loss: 1.493 | Acc: 48.05%
-2025-03-14 18:58:48,265 - train - INFO - Epoch: 31 | Batch: 200 | Loss: 1.509 | Acc: 47.26%
-2025-03-14 18:58:50,534 - train - INFO - Epoch: 31 | Batch: 300 | Loss: 1.504 | Acc: 47.44%
-2025-03-14 18:58:53,718 - train - INFO - Epoch: 31 | Test Loss: 1.490 | Test Acc: 47.97%
-2025-03-14 18:58:53,855 - train - INFO - Epoch: 32 | Batch: 0 | Loss: 1.397 | Acc: 52.34%
-2025-03-14 18:58:55,938 - train - INFO - Epoch: 32 | Batch: 100 | Loss: 1.527 | Acc: 46.51%
-2025-03-14 18:58:58,089 - train - INFO - Epoch: 32 | Batch: 200 | Loss: 1.511 | Acc: 47.57%
-2025-03-14 18:59:00,263 - train - INFO - Epoch: 32 | Batch: 300 | Loss: 1.505 | Acc: 47.70%
-2025-03-14 18:59:03,515 - train - INFO - Epoch: 32 | Test Loss: 1.502 | Test Acc: 47.83%
-2025-03-14 18:59:12,676 - train - INFO - Epoch: 33 | Batch: 0 | Loss: 1.443 | Acc: 48.44%
-2025-03-14 18:59:14,901 - train - INFO - Epoch: 33 | Batch: 100 | Loss: 1.501 | Acc: 47.44%
-2025-03-14 18:59:17,010 - train - INFO - Epoch: 33 | Batch: 200 | Loss: 1.494 | Acc: 47.66%
-2025-03-14 18:59:19,083 - train - INFO - Epoch: 33 | Batch: 300 | Loss: 1.497 | Acc: 47.59%
-2025-03-14 18:59:22,262 - train - INFO - Epoch: 33 | Test Loss: 1.502 | Test Acc: 47.90%
-2025-03-14 18:59:22,416 - train - INFO - Epoch: 34 | Batch: 0 | Loss: 1.555 | Acc: 41.41%
-2025-03-14 18:59:24,591 - train - INFO - Epoch: 34 | Batch: 100 | Loss: 1.505 | Acc: 47.66%
-2025-03-14 18:59:26,681 - train - INFO - Epoch: 34 | Batch: 200 | Loss: 1.504 | Acc: 47.73%
-2025-03-14 18:59:28,785 - train - INFO - Epoch: 34 | Batch: 300 | Loss: 1.500 | Acc: 47.84%
-2025-03-14 18:59:31,963 - train - INFO - Epoch: 34 | Test Loss: 1.505 | Test Acc: 46.85%
-2025-03-14 18:59:40,980 - train - INFO - Epoch: 35 | Batch: 0 | Loss: 1.479 | Acc: 46.88%
-2025-03-14 18:59:43,177 - train - INFO - Epoch: 35 | Batch: 100 | Loss: 1.509 | Acc: 47.49%
-2025-03-14 18:59:45,274 - train - INFO - Epoch: 35 | Batch: 200 | Loss: 1.511 | Acc: 47.25%
-2025-03-14 18:59:47,396 - train - INFO - Epoch: 35 | Batch: 300 | Loss: 1.510 | Acc: 47.32%
-2025-03-14 18:59:50,653 - train - INFO - Epoch: 35 | Test Loss: 1.401 | Test Acc: 51.25%
-2025-03-14 18:59:50,838 - train - INFO - Epoch: 36 | Batch: 0 | Loss: 1.299 | Acc: 59.38%
-2025-03-14 18:59:52,839 - train - INFO - Epoch: 36 | Batch: 100 | Loss: 1.482 | Acc: 48.78%
-2025-03-14 18:59:54,989 - train - INFO - Epoch: 36 | Batch: 200 | Loss: 1.490 | Acc: 48.33%
-2025-03-14 18:59:56,980 - train - INFO - Epoch: 36 | Batch: 300 | Loss: 1.485 | Acc: 48.47%
-2025-03-14 19:00:00,116 - train - INFO - Epoch: 36 | Test Loss: 1.489 | Test Acc: 47.70%
-2025-03-14 19:00:09,044 - train - INFO - Epoch: 37 | Batch: 0 | Loss: 1.378 | Acc: 52.34%
-2025-03-14 19:00:11,337 - train - INFO - Epoch: 37 | Batch: 100 | Loss: 1.467 | Acc: 49.08%
-2025-03-14 19:00:13,664 - train - INFO - Epoch: 37 | Batch: 200 | Loss: 1.466 | Acc: 48.83%
-2025-03-14 19:00:15,943 - train - INFO - Epoch: 37 | Batch: 300 | Loss: 1.463 | Acc: 48.93%
-2025-03-14 19:00:19,369 - train - INFO - Epoch: 37 | Test Loss: 1.534 | Test Acc: 46.58%
-2025-03-14 19:00:19,523 - train - INFO - Epoch: 38 | Batch: 0 | Loss: 1.550 | Acc: 44.53%
-2025-03-14 19:00:21,879 - train - INFO - Epoch: 38 | Batch: 100 | Loss: 1.476 | Acc: 48.53%
-2025-03-14 19:00:24,365 - train - INFO - Epoch: 38 | Batch: 200 | Loss: 1.495 | Acc: 47.90%
-2025-03-14 19:00:26,878 - train - INFO - Epoch: 38 | Batch: 300 | Loss: 1.494 | Acc: 48.06%
-2025-03-14 19:00:30,363 - train - INFO - Epoch: 38 | Test Loss: 1.502 | Test Acc: 48.86%
-2025-03-14 19:00:40,202 - train - INFO - Epoch: 39 | Batch: 0 | Loss: 1.594 | Acc: 49.22%
-2025-03-14 19:00:42,476 - train - INFO - Epoch: 39 | Batch: 100 | Loss: 1.472 | Acc: 48.95%
-2025-03-14 19:00:44,677 - train - INFO - Epoch: 39 | Batch: 200 | Loss: 1.470 | Acc: 49.00%
-2025-03-14 19:00:46,770 - train - INFO - Epoch: 39 | Batch: 300 | Loss: 1.457 | Acc: 49.47%
-2025-03-14 19:00:50,216 - train - INFO - Epoch: 39 | Test Loss: 1.392 | Test Acc: 50.99%
-2025-03-14 19:00:50,372 - train - INFO - Epoch: 40 | Batch: 0 | Loss: 1.643 | Acc: 42.97%
-2025-03-14 19:00:52,597 - train - INFO - Epoch: 40 | Batch: 100 | Loss: 1.492 | Acc: 48.14%
-2025-03-14 19:00:54,733 - train - INFO - Epoch: 40 | Batch: 200 | Loss: 1.488 | Acc: 48.10%
-2025-03-14 19:00:56,903 - train - INFO - Epoch: 40 | Batch: 300 | Loss: 1.476 | Acc: 48.38%
-2025-03-14 19:01:00,186 - train - INFO - Epoch: 40 | Test Loss: 1.396 | Test Acc: 51.11%
-2025-03-14 19:01:09,458 - train - INFO - Epoch: 41 | Batch: 0 | Loss: 1.446 | Acc: 49.22%
-2025-03-14 19:01:11,568 - train - INFO - Epoch: 41 | Batch: 100 | Loss: 1.477 | Acc: 49.01%
-2025-03-14 19:01:13,524 - train - INFO - Epoch: 41 | Batch: 200 | Loss: 1.467 | Acc: 49.21%
-2025-03-14 19:01:15,623 - train - INFO - Epoch: 41 | Batch: 300 | Loss: 1.473 | Acc: 49.07%
-2025-03-14 19:01:18,753 - train - INFO - Epoch: 41 | Test Loss: 1.369 | Test Acc: 53.32%
-2025-03-14 19:01:18,976 - train - INFO - Epoch: 42 | Batch: 0 | Loss: 1.483 | Acc: 46.88%
-2025-03-14 19:01:20,939 - train - INFO - Epoch: 42 | Batch: 100 | Loss: 1.466 | Acc: 48.96%
-2025-03-14 19:01:22,879 - train - INFO - Epoch: 42 | Batch: 200 | Loss: 1.470 | Acc: 48.71%
-2025-03-14 19:01:24,891 - train - INFO - Epoch: 42 | Batch: 300 | Loss: 1.473 | Acc: 48.65%
-2025-03-14 19:01:27,749 - train - INFO - Epoch: 42 | Test Loss: 1.397 | Test Acc: 51.39%
-2025-03-14 19:01:36,173 - train - INFO - Epoch: 43 | Batch: 0 | Loss: 1.305 | Acc: 52.34%
-2025-03-14 19:01:38,245 - train - INFO - Epoch: 43 | Batch: 100 | Loss: 1.444 | Acc: 49.63%
-2025-03-14 19:01:40,295 - train - INFO - Epoch: 43 | Batch: 200 | Loss: 1.458 | Acc: 48.98%
-2025-03-14 19:01:42,370 - train - INFO - Epoch: 43 | Batch: 300 | Loss: 1.471 | Acc: 48.66%
-2025-03-14 19:01:45,581 - train - INFO - Epoch: 43 | Test Loss: 1.378 | Test Acc: 52.89%
-2025-03-14 19:01:45,747 - train - INFO - Epoch: 44 | Batch: 0 | Loss: 1.317 | Acc: 57.81%
-2025-03-14 19:01:48,037 - train - INFO - Epoch: 44 | Batch: 100 | Loss: 1.460 | Acc: 49.73%
-2025-03-14 19:01:50,122 - train - INFO - Epoch: 44 | Batch: 200 | Loss: 1.431 | Acc: 50.60%
-2025-03-14 19:01:52,184 - train - INFO - Epoch: 44 | Batch: 300 | Loss: 1.447 | Acc: 50.02%
-2025-03-14 19:01:55,371 - train - INFO - Epoch: 44 | Test Loss: 1.472 | Test Acc: 49.33%
-2025-03-14 19:02:04,270 - train - INFO - Epoch: 45 | Batch: 0 | Loss: 1.547 | Acc: 48.44%
-2025-03-14 19:02:06,320 - train - INFO - Epoch: 45 | Batch: 100 | Loss: 1.469 | Acc: 49.03%
-2025-03-14 19:02:08,399 - train - INFO - Epoch: 45 | Batch: 200 | Loss: 1.467 | Acc: 49.28%
-2025-03-14 19:02:10,409 - train - INFO - Epoch: 45 | Batch: 300 | Loss: 1.461 | Acc: 49.32%
-2025-03-14 19:02:13,526 - train - INFO - Epoch: 45 | Test Loss: 1.475 | Test Acc: 50.11%
-2025-03-14 19:02:13,687 - train - INFO - Epoch: 46 | Batch: 0 | Loss: 1.603 | Acc: 50.00%
-2025-03-14 19:02:15,735 - train - INFO - Epoch: 46 | Batch: 100 | Loss: 1.468 | Acc: 49.56%
-2025-03-14 19:02:17,836 - train - INFO - Epoch: 46 | Batch: 200 | Loss: 1.457 | Acc: 49.54%
-2025-03-14 19:02:19,934 - train - INFO - Epoch: 46 | Batch: 300 | Loss: 1.454 | Acc: 49.82%
-2025-03-14 19:02:23,205 - train - INFO - Epoch: 46 | Test Loss: 1.467 | Test Acc: 49.27%
-2025-03-14 19:02:31,634 - train - INFO - Epoch: 47 | Batch: 0 | Loss: 1.506 | Acc: 47.66%
-2025-03-14 19:02:33,626 - train - INFO - Epoch: 47 | Batch: 100 | Loss: 1.447 | Acc: 50.19%
-2025-03-14 19:02:35,568 - train - INFO - Epoch: 47 | Batch: 200 | Loss: 1.451 | Acc: 49.84%
-2025-03-14 19:02:37,841 - train - INFO - Epoch: 47 | Batch: 300 | Loss: 1.439 | Acc: 50.25%
-2025-03-14 19:02:41,240 - train - INFO - Epoch: 47 | Test Loss: 1.543 | Test Acc: 46.04%
-2025-03-14 19:02:41,419 - train - INFO - Epoch: 48 | Batch: 0 | Loss: 1.628 | Acc: 45.31%
-2025-03-14 19:02:43,631 - train - INFO - Epoch: 48 | Batch: 100 | Loss: 1.464 | Acc: 49.07%
-2025-03-14 19:02:45,773 - train - INFO - Epoch: 48 | Batch: 200 | Loss: 1.454 | Acc: 49.46%
-2025-03-14 19:02:47,757 - train - INFO - Epoch: 48 | Batch: 300 | Loss: 1.468 | Acc: 49.15%
-2025-03-14 19:02:50,760 - train - INFO - Epoch: 48 | Test Loss: 1.404 | Test Acc: 50.03%
-2025-03-14 19:02:58,934 - train - INFO - Epoch: 49 | Batch: 0 | Loss: 1.270 | Acc: 52.34%
-2025-03-14 19:03:00,986 - train - INFO - Epoch: 49 | Batch: 100 | Loss: 1.457 | Acc: 49.50%
-2025-03-14 19:03:03,024 - train - INFO - Epoch: 49 | Batch: 200 | Loss: 1.458 | Acc: 49.52%
-2025-03-14 19:03:05,108 - train - INFO - Epoch: 49 | Batch: 300 | Loss: 1.460 | Acc: 49.37%
-2025-03-14 19:03:08,092 - train - INFO - Epoch: 49 | Test Loss: 1.356 | Test Acc: 53.54%
-2025-03-14 19:03:08,239 - train - INFO - Epoch: 50 | Batch: 0 | Loss: 1.282 | Acc: 51.56%
-2025-03-14 19:03:10,262 - train - INFO - Epoch: 50 | Batch: 100 | Loss: 1.460 | Acc: 48.94%
-2025-03-14 19:03:12,119 - train - INFO - Epoch: 50 | Batch: 200 | Loss: 1.465 | Acc: 48.87%
-2025-03-14 19:03:14,009 - train - INFO - Epoch: 50 | Batch: 300 | Loss: 1.448 | Acc: 49.82%
-2025-03-14 19:03:16,891 - train - INFO - Epoch: 50 | Test Loss: 1.402 | Test Acc: 51.80%
-2025-03-14 19:03:24,969 - train - INFO - 训练完成!

Image/LeNet5/code/train.log

@@ -1,253 +0,0 @@
-2025-03-14 18:42:58,457 - train - INFO - 开始训练 lenet5
-2025-03-14 18:42:58,466 - train - INFO - 总轮数: 50, 学习率: 0.1, 设备: cuda:3
-2025-03-14 18:42:59,293 - train - INFO - Epoch: 1 | Batch: 0 | Loss: 2.303 | Acc: 10.94%
-2025-03-14 18:43:01,471 - train - INFO - Epoch: 1 | Batch: 100 | Loss: 2.266 | Acc: 12.62%
-2025-03-14 18:43:03,531 - train - INFO - Epoch: 1 | Batch: 200 | Loss: 2.178 | Acc: 15.37%
-2025-03-14 18:43:05,648 - train - INFO - Epoch: 1 | Batch: 300 | Loss: 2.099 | Acc: 18.60%
-2025-03-14 18:43:08,912 - train - INFO - Epoch: 1 | Test Loss: 1.768 | Test Acc: 33.62%
-2025-03-14 18:43:09,291 - train - INFO - Epoch: 2 | Batch: 0 | Loss: 1.851 | Acc: 26.56%
-2025-03-14 18:43:11,591 - train - INFO - Epoch: 2 | Batch: 100 | Loss: 1.848 | Acc: 30.46%
-2025-03-14 18:43:13,743 - train - INFO - Epoch: 2 | Batch: 200 | Loss: 1.831 | Acc: 31.40%
-2025-03-14 18:43:16,315 - train - INFO - Epoch: 2 | Batch: 300 | Loss: 1.823 | Acc: 31.80%
-2025-03-14 18:43:19,766 - train - INFO - Epoch: 2 | Test Loss: 1.662 | Test Acc: 38.37%
-2025-03-14 18:43:28,827 - train - INFO - Epoch: 3 | Batch: 0 | Loss: 1.742 | Acc: 33.59%
-2025-03-14 18:43:31,227 - train - INFO - Epoch: 3 | Batch: 100 | Loss: 1.772 | Acc: 34.92%
-2025-03-14 18:43:33,508 - train - INFO - Epoch: 3 | Batch: 200 | Loss: 1.755 | Acc: 34.99%
-2025-03-14 18:43:35,700 - train - INFO - Epoch: 3 | Batch: 300 | Loss: 1.750 | Acc: 35.12%
-2025-03-14 18:43:39,124 - train - INFO - Epoch: 3 | Test Loss: 1.663 | Test Acc: 38.84%
-2025-03-14 18:43:39,305 - train - INFO - Epoch: 4 | Batch: 0 | Loss: 1.855 | Acc: 29.69%
-2025-03-14 18:43:41,442 - train - INFO - Epoch: 4 | Batch: 100 | Loss: 1.715 | Acc: 36.98%
-2025-03-14 18:43:43,675 - train - INFO - Epoch: 4 | Batch: 200 | Loss: 1.721 | Acc: 36.66%
-2025-03-14 18:43:45,928 - train - INFO - Epoch: 4 | Batch: 300 | Loss: 1.704 | Acc: 37.20%
-2025-03-14 18:43:49,305 - train - INFO - Epoch: 4 | Test Loss: 1.584 | Test Acc: 41.15%
-2025-03-14 18:43:58,749 - train - INFO - Epoch: 5 | Batch: 0 | Loss: 1.593 | Acc: 39.06%
-2025-03-14 18:44:01,045 - train - INFO - Epoch: 5 | Batch: 100 | Loss: 1.676 | Acc: 39.09%
-2025-03-14 18:44:03,286 - train - INFO - Epoch: 5 | Batch: 200 | Loss: 1.660 | Acc: 39.65%
-2025-03-14 18:44:05,565 - train - INFO - Epoch: 5 | Batch: 300 | Loss: 1.673 | Acc: 39.22%
-2025-03-14 18:44:09,108 - train - INFO - Epoch: 5 | Test Loss: 1.637 | Test Acc: 40.55%
-2025-03-14 18:44:09,274 - train - INFO - Epoch: 6 | Batch: 0 | Loss: 1.719 | Acc: 36.72%
-2025-03-14 18:44:11,561 - train - INFO - Epoch: 6 | Batch: 100 | Loss: 1.622 | Acc: 40.80%
-2025-03-14 18:44:14,102 - train - INFO - Epoch: 6 | Batch: 200 | Loss: 1.645 | Acc: 40.35%
-2025-03-14 18:44:16,595 - train - INFO - Epoch: 6 | Batch: 300 | Loss: 1.655 | Acc: 40.03%
-2025-03-14 18:44:20,643 - train - INFO - Epoch: 6 | Test Loss: 1.514 | Test Acc: 47.29%
-2025-03-14 18:44:30,165 - train - INFO - Epoch: 7 | Batch: 0 | Loss: 1.487 | Acc: 50.78%
-2025-03-14 18:44:32,311 - train - INFO - Epoch: 7 | Batch: 100 | Loss: 1.638 | Acc: 40.48%
-2025-03-14 18:44:34,629 - train - INFO - Epoch: 7 | Batch: 200 | Loss: 1.641 | Acc: 40.55%
-2025-03-14 18:44:36,796 - train - INFO - Epoch: 7 | Batch: 300 | Loss: 1.642 | Acc: 40.62%
-2025-03-14 18:44:40,052 - train - INFO - Epoch: 7 | Test Loss: 1.670 | Test Acc: 41.48%
-2025-03-14 18:44:40,222 - train - INFO - Epoch: 8 | Batch: 0 | Loss: 1.629 | Acc: 38.28%
-2025-03-14 18:44:42,337 - train - INFO - Epoch: 8 | Batch: 100 | Loss: 1.647 | Acc: 40.32%
-2025-03-14 18:44:44,590 - train - INFO - Epoch: 8 | Batch: 200 | Loss: 1.638 | Acc: 40.99%
-2025-03-14 18:44:46,617 - train - INFO - Epoch: 8 | Batch: 300 | Loss: 1.648 | Acc: 40.85%
-2025-03-14 18:44:50,042 - train - INFO - Epoch: 8 | Test Loss: 1.610 | Test Acc: 43.43%
-2025-03-14 18:44:59,307 - train - INFO - Epoch: 9 | Batch: 0 | Loss: 1.663 | Acc: 44.53%
-2025-03-14 18:45:01,655 - train - INFO - Epoch: 9 | Batch: 100 | Loss: 1.638 | Acc: 41.36%
-2025-03-14 18:45:03,999 - train - INFO - Epoch: 9 | Batch: 200 | Loss: 1.647 | Acc: 40.96%
-2025-03-14 18:45:06,123 - train - INFO - Epoch: 9 | Batch: 300 | Loss: 1.646 | Acc: 40.82%
-2025-03-14 18:45:09,386 - train - INFO - Epoch: 9 | Test Loss: 1.465 | Test Acc: 48.76%
-2025-03-14 18:45:09,543 - train - INFO - Epoch: 10 | Batch: 0 | Loss: 1.650 | Acc: 40.62%
-2025-03-14 18:45:11,645 - train - INFO - Epoch: 10 | Batch: 100 | Loss: 1.581 | Acc: 42.72%
-2025-03-14 18:45:13,854 - train - INFO - Epoch: 10 | Batch: 200 | Loss: 1.589 | Acc: 42.82%
-2025-03-14 18:45:16,028 - train - INFO - Epoch: 10 | Batch: 300 | Loss: 1.592 | Acc: 42.91%
-2025-03-14 18:45:19,650 - train - INFO - Epoch: 10 | Test Loss: 1.483 | Test Acc: 48.24%
-2025-03-14 18:45:30,113 - train - INFO - Epoch: 11 | Batch: 0 | Loss: 1.494 | Acc: 42.97%
-2025-03-14 18:45:32,744 - train - INFO - Epoch: 11 | Batch: 100 | Loss: 1.616 | Acc: 42.26%
-2025-03-14 18:45:35,132 - train - INFO - Epoch: 11 | Batch: 200 | Loss: 1.625 | Acc: 42.03%
-2025-03-14 18:45:37,374 - train - INFO - Epoch: 11 | Batch: 300 | Loss: 1.603 | Acc: 42.96%
-2025-03-14 18:45:40,850 - train - INFO - Epoch: 11 | Test Loss: 1.505 | Test Acc: 48.63%
-2025-03-14 18:45:41,037 - train - INFO - Epoch: 12 | Batch: 0 | Loss: 1.586 | Acc: 46.09%
-2025-03-14 18:45:43,281 - train - INFO - Epoch: 12 | Batch: 100 | Loss: 1.577 | Acc: 44.79%
-2025-03-14 18:45:45,488 - train - INFO - Epoch: 12 | Batch: 200 | Loss: 1.576 | Acc: 44.34%
-2025-03-14 18:45:47,756 - train - INFO - Epoch: 12 | Batch: 300 | Loss: 1.591 | Acc: 43.89%
-2025-03-14 18:45:51,120 - train - INFO - Epoch: 12 | Test Loss: 1.605 | Test Acc: 44.80%
-2025-03-14 18:46:00,438 - train - INFO - Epoch: 13 | Batch: 0 | Loss: 1.518 | Acc: 44.53%
-2025-03-14 18:46:02,653 - train - INFO - Epoch: 13 | Batch: 100 | Loss: 1.599 | Acc: 42.95%
-2025-03-14 18:46:05,275 - train - INFO - Epoch: 13 | Batch: 200 | Loss: 1.593 | Acc: 43.37%
-2025-03-14 18:46:07,588 - train - INFO - Epoch: 13 | Batch: 300 | Loss: 1.598 | Acc: 43.51%
-2025-03-14 18:46:10,937 - train - INFO - Epoch: 13 | Test Loss: 1.583 | Test Acc: 42.85%
-2025-03-14 18:46:11,116 - train - INFO - Epoch: 14 | Batch: 0 | Loss: 1.560 | Acc: 44.53%
-2025-03-14 18:46:13,285 - train - INFO - Epoch: 14 | Batch: 100 | Loss: 1.569 | Acc: 44.65%
-2025-03-14 18:46:15,533 - train - INFO - Epoch: 14 | Batch: 200 | Loss: 1.577 | Acc: 43.93%
-2025-03-14 18:46:17,803 - train - INFO - Epoch: 14 | Batch: 300 | Loss: 1.580 | Acc: 43.98%
-2025-03-14 18:46:21,356 - train - INFO - Epoch: 14 | Test Loss: 1.633 | Test Acc: 44.51%
-2025-03-14 18:46:31,128 - train - INFO - Epoch: 15 | Batch: 0 | Loss: 1.845 | Acc: 38.28%
-2025-03-14 18:46:33,986 - train - INFO - Epoch: 15 | Batch: 100 | Loss: 1.574 | Acc: 44.63%
-2025-03-14 18:46:36,643 - train - INFO - Epoch: 15 | Batch: 200 | Loss: 1.581 | Acc: 44.63%
-2025-03-14 18:46:38,812 - train - INFO - Epoch: 15 | Batch: 300 | Loss: 1.582 | Acc: 44.44%
-2025-03-14 18:46:42,100 - train - INFO - Epoch: 15 | Test Loss: 1.502 | Test Acc: 47.49%
-2025-03-14 18:46:42,283 - train - INFO - Epoch: 16 | Batch: 0 | Loss: 1.625 | Acc: 40.62%
-2025-03-14 18:46:44,700 - train - INFO - Epoch: 16 | Batch: 100 | Loss: 1.541 | Acc: 45.17%
-2025-03-14 18:46:46,924 - train - INFO - Epoch: 16 | Batch: 200 | Loss: 1.555 | Acc: 44.73%
-2025-03-14 18:46:49,212 - train - INFO - Epoch: 16 | Batch: 300 | Loss: 1.552 | Acc: 45.09%
-2025-03-14 18:46:52,741 - train - INFO - Epoch: 16 | Test Loss: 1.515 | Test Acc: 47.01%
-2025-03-14 18:47:01,778 - train - INFO - Epoch: 17 | Batch: 0 | Loss: 1.648 | Acc: 42.19%
-2025-03-14 18:47:03,963 - train - INFO - Epoch: 17 | Batch: 100 | Loss: 1.568 | Acc: 45.44%
-2025-03-14 18:47:06,143 - train - INFO - Epoch: 17 | Batch: 200 | Loss: 1.559 | Acc: 45.42%
-2025-03-14 18:47:08,345 - train - INFO - Epoch: 17 | Batch: 300 | Loss: 1.569 | Acc: 45.12%
-2025-03-14 18:47:11,733 - train - INFO - Epoch: 17 | Test Loss: 1.570 | Test Acc: 45.34%
-2025-03-14 18:47:11,921 - train - INFO - Epoch: 18 | Batch: 0 | Loss: 1.661 | Acc: 39.06%
-2025-03-14 18:47:14,198 - train - INFO - Epoch: 18 | Batch: 100 | Loss: 1.577 | Acc: 43.73%
-2025-03-14 18:47:16,401 - train - INFO - Epoch: 18 | Batch: 200 | Loss: 1.587 | Acc: 44.04%
-2025-03-14 18:47:18,532 - train - INFO - Epoch: 18 | Batch: 300 | Loss: 1.583 | Acc: 44.23%
-2025-03-14 18:47:21,929 - train - INFO - Epoch: 18 | Test Loss: 1.490 | Test Acc: 48.95%
-2025-03-14 18:47:31,595 - train - INFO - Epoch: 19 | Batch: 0 | Loss: 1.469 | Acc: 47.66%
-2025-03-14 18:47:34,012 - train - INFO - Epoch: 19 | Batch: 100 | Loss: 1.572 | Acc: 44.14%
-2025-03-14 18:47:36,582 - train - INFO - Epoch: 19 | Batch: 200 | Loss: 1.564 | Acc: 44.89%
-2025-03-14 18:47:39,025 - train - INFO - Epoch: 19 | Batch: 300 | Loss: 1.580 | Acc: 44.51%
-2025-03-14 18:47:43,410 - train - INFO - Epoch: 19 | Test Loss: 1.614 | Test Acc: 41.68%
-2025-03-14 18:47:43,603 - train - INFO - Epoch: 20 | Batch: 0 | Loss: 1.780 | Acc: 35.16%
-2025-03-14 18:47:45,962 - train - INFO - Epoch: 20 | Batch: 100 | Loss: 1.593 | Acc: 43.56%
-2025-03-14 18:47:48,244 - train - INFO - Epoch: 20 | Batch: 200 | Loss: 1.582 | Acc: 44.22%
-2025-03-14 18:47:50,397 - train - INFO - Epoch: 20 | Batch: 300 | Loss: 1.564 | Acc: 44.98%
-2025-03-14 18:47:53,620 - train - INFO - Epoch: 20 | Test Loss: 1.466 | Test Acc: 48.39%
-2025-03-14 18:48:02,849 - train - INFO - Epoch: 21 | Batch: 0 | Loss: 1.409 | Acc: 50.00%
-2025-03-14 18:48:05,101 - train - INFO - Epoch: 21 | Batch: 100 | Loss: 1.554 | Acc: 45.34%
-2025-03-14 18:48:07,205 - train - INFO - Epoch: 21 | Batch: 200 | Loss: 1.559 | Acc: 45.21%
-2025-03-14 18:48:09,387 - train - INFO - Epoch: 21 | Batch: 300 | Loss: 1.567 | Acc: 44.95%
-2025-03-14 18:48:12,828 - train - INFO - Epoch: 21 | Test Loss: 1.541 | Test Acc: 45.92%
-2025-03-14 18:48:12,998 - train - INFO - Epoch: 22 | Batch: 0 | Loss: 1.420 | Acc: 50.00%
-2025-03-14 18:48:15,472 - train - INFO - Epoch: 22 | Batch: 100 | Loss: 1.553 | Acc: 45.12%
-2025-03-14 18:48:17,608 - train - INFO - Epoch: 22 | Batch: 200 | Loss: 1.546 | Acc: 45.46%
-2025-03-14 18:48:19,794 - train - INFO - Epoch: 22 | Batch: 300 | Loss: 1.551 | Acc: 45.30%
-2025-03-14 18:48:23,214 - train - INFO - Epoch: 22 | Test Loss: 1.537 | Test Acc: 46.88%
-2025-03-14 18:48:32,459 - train - INFO - Epoch: 23 | Batch: 0 | Loss: 1.594 | Acc: 42.19%
-2025-03-14 18:48:34,612 - train - INFO - Epoch: 23 | Batch: 100 | Loss: 1.580 | Acc: 44.72%
-2025-03-14 18:48:36,785 - train - INFO - Epoch: 23 | Batch: 200 | Loss: 1.560 | Acc: 45.09%
-2025-03-14 18:48:38,969 - train - INFO - Epoch: 23 | Batch: 300 | Loss: 1.561 | Acc: 45.15%
-2025-03-14 18:48:42,488 - train - INFO - Epoch: 23 | Test Loss: 1.570 | Test Acc: 45.55%
-2025-03-14 18:48:42,659 - train - INFO - Epoch: 24 | Batch: 0 | Loss: 1.642 | Acc: 44.53%
-2025-03-14 18:48:44,937 - train - INFO - Epoch: 24 | Batch: 100 | Loss: 1.577 | Acc: 44.83%
-2025-03-14 18:48:47,587 - train - INFO - Epoch: 24 | Batch: 200 | Loss: 1.587 | Acc: 44.60%
-2025-03-14 18:48:50,078 - train - INFO - Epoch: 24 | Batch: 300 | Loss: 1.570 | Acc: 45.19%
-2025-03-14 18:48:53,664 - train - INFO - Epoch: 24 | Test Loss: 1.460 | Test Acc: 51.03%
-2025-03-14 18:49:03,866 - train - INFO - Epoch: 25 | Batch: 0 | Loss: 1.401 | Acc: 47.66%
-2025-03-14 18:49:05,995 - train - INFO - Epoch: 25 | Batch: 100 | Loss: 1.530 | Acc: 45.76%
-2025-03-14 18:49:08,111 - train - INFO - Epoch: 25 | Batch: 200 | Loss: 1.514 | Acc: 46.54%
-2025-03-14 18:49:10,316 - train - INFO - Epoch: 25 | Batch: 300 | Loss: 1.529 | Acc: 46.19%
-2025-03-14 18:49:13,929 - train - INFO - Epoch: 25 | Test Loss: 1.556 | Test Acc: 47.06%
-2025-03-14 18:49:14,187 - train - INFO - Epoch: 26 | Batch: 0 | Loss: 1.722 | Acc: 40.62%
-2025-03-14 18:49:16,552 - train - INFO - Epoch: 26 | Batch: 100 | Loss: 1.515 | Acc: 46.69%
-2025-03-14 18:49:18,799 - train - INFO - Epoch: 26 | Batch: 200 | Loss: 1.527 | Acc: 46.61%
-2025-03-14 18:49:20,898 - train - INFO - Epoch: 26 | Batch: 300 | Loss: 1.541 | Acc: 46.01%
-2025-03-14 18:49:24,249 - train - INFO - Epoch: 26 | Test Loss: 1.403 | Test Acc: 50.95%
-2025-03-14 18:49:33,283 - train - INFO - Epoch: 27 | Batch: 0 | Loss: 1.368 | Acc: 50.00%
-2025-03-14 18:49:35,438 - train - INFO - Epoch: 27 | Batch: 100 | Loss: 1.541 | Acc: 46.12%
-2025-03-14 18:49:37,619 - train - INFO - Epoch: 27 | Batch: 200 | Loss: 1.546 | Acc: 46.12%
-2025-03-14 18:49:39,907 - train - INFO - Epoch: 27 | Batch: 300 | Loss: 1.558 | Acc: 45.75%
-2025-03-14 18:49:43,295 - train - INFO - Epoch: 27 | Test Loss: 1.593 | Test Acc: 44.67%
-2025-03-14 18:49:43,465 - train - INFO - Epoch: 28 | Batch: 0 | Loss: 1.712 | Acc: 39.84%
-2025-03-14 18:49:45,800 - train - INFO - Epoch: 28 | Batch: 100 | Loss: 1.551 | Acc: 46.37%
-2025-03-14 18:49:47,998 - train - INFO - Epoch: 28 | Batch: 200 | Loss: 1.551 | Acc: 46.39%
-2025-03-14 18:49:50,134 - train - INFO - Epoch: 28 | Batch: 300 | Loss: 1.538 | Acc: 46.92%
-2025-03-14 18:49:53,378 - train - INFO - Epoch: 28 | Test Loss: 1.490 | Test Acc: 46.88%
-2025-03-14 18:50:02,514 - train - INFO - Epoch: 29 | Batch: 0 | Loss: 1.512 | Acc: 41.41%
-2025-03-14 18:50:04,738 - train - INFO - Epoch: 29 | Batch: 100 | Loss: 1.560 | Acc: 45.56%
-2025-03-14 18:50:06,892 - train - INFO - Epoch: 29 | Batch: 200 | Loss: 1.530 | Acc: 46.73%
-2025-03-14 18:50:09,049 - train - INFO - Epoch: 29 | Batch: 300 | Loss: 1.541 | Acc: 46.39%
-2025-03-14 18:50:12,354 - train - INFO - Epoch: 29 | Test Loss: 1.536 | Test Acc: 46.64%
-2025-03-14 18:50:12,524 - train - INFO - Epoch: 30 | Batch: 0 | Loss: 1.597 | Acc: 46.09%
-2025-03-14 18:50:14,711 - train - INFO - Epoch: 30 | Batch: 100 | Loss: 1.548 | Acc: 46.50%
-2025-03-14 18:50:16,934 - train - INFO - Epoch: 30 | Batch: 200 | Loss: 1.556 | Acc: 45.93%
-2025-03-14 18:50:19,218 - train - INFO - Epoch: 30 | Batch: 300 | Loss: 1.543 | Acc: 46.32%
-2025-03-14 18:50:22,723 - train - INFO - Epoch: 30 | Test Loss: 1.452 | Test Acc: 50.77%
-2025-03-14 18:50:32,129 - train - INFO - Epoch: 31 | Batch: 0 | Loss: 1.449 | Acc: 49.22%
-2025-03-14 18:50:34,311 - train - INFO - Epoch: 31 | Batch: 100 | Loss: 1.533 | Acc: 47.13%
-2025-03-14 18:50:36,539 - train - INFO - Epoch: 31 | Batch: 200 | Loss: 1.542 | Acc: 46.49%
-2025-03-14 18:50:38,682 - train - INFO - Epoch: 31 | Batch: 300 | Loss: 1.539 | Acc: 46.58%
-2025-03-14 18:50:42,089 - train - INFO - Epoch: 31 | Test Loss: 1.386 | Test Acc: 52.82%
-2025-03-14 18:50:42,259 - train - INFO - Epoch: 32 | Batch: 0 | Loss: 1.537 | Acc: 49.22%
-2025-03-14 18:50:44,519 - train - INFO - Epoch: 32 | Batch: 100 | Loss: 1.507 | Acc: 47.93%
-2025-03-14 18:50:46,656 - train - INFO - Epoch: 32 | Batch: 200 | Loss: 1.502 | Acc: 47.95%
-2025-03-14 18:50:48,818 - train - INFO - Epoch: 32 | Batch: 300 | Loss: 1.502 | Acc: 47.57%
-2025-03-14 18:50:52,272 - train - INFO - Epoch: 32 | Test Loss: 1.482 | Test Acc: 48.45%
-2025-03-14 18:51:01,650 - train - INFO - Epoch: 33 | Batch: 0 | Loss: 1.600 | Acc: 42.97%
-2025-03-14 18:51:03,937 - train - INFO - Epoch: 33 | Batch: 100 | Loss: 1.516 | Acc: 46.92%
-2025-03-14 18:51:06,268 - train - INFO - Epoch: 33 | Batch: 200 | Loss: 1.528 | Acc: 46.76%
-2025-03-14 18:51:08,704 - train - INFO - Epoch: 33 | Batch: 300 | Loss: 1.534 | Acc: 46.62%
-2025-03-14 18:51:12,262 - train - INFO - Epoch: 33 | Test Loss: 1.430 | Test Acc: 49.99%
-2025-03-14 18:51:12,443 - train - INFO - Epoch: 34 | Batch: 0 | Loss: 1.585 | Acc: 45.31%
-2025-03-14 18:51:14,733 - train - INFO - Epoch: 34 | Batch: 100 | Loss: 1.501 | Acc: 47.97%
-2025-03-14 18:51:17,010 - train - INFO - Epoch: 34 | Batch: 200 | Loss: 1.512 | Acc: 47.52%
-2025-03-14 18:51:19,395 - train - INFO - Epoch: 34 | Batch: 300 | Loss: 1.514 | Acc: 47.37%
-2025-03-14 18:51:23,243 - train - INFO - Epoch: 34 | Test Loss: 1.407 | Test Acc: 52.49%
-2025-03-14 18:51:32,787 - train - INFO - Epoch: 35 | Batch: 0 | Loss: 1.449 | Acc: 53.12%
-2025-03-14 18:51:35,089 - train - INFO - Epoch: 35 | Batch: 100 | Loss: 1.533 | Acc: 46.77%
-2025-03-14 18:51:37,330 - train - INFO - Epoch: 35 | Batch: 200 | Loss: 1.508 | Acc: 47.78%
-2025-03-14 18:51:39,569 - train - INFO - Epoch: 35 | Batch: 300 | Loss: 1.505 | Acc: 47.97%
-2025-03-14 18:51:43,190 - train - INFO - Epoch: 35 | Test Loss: 1.518 | Test Acc: 48.63%
-2025-03-14 18:51:43,386 - train - INFO - Epoch: 36 | Batch: 0 | Loss: 1.662 | Acc: 41.41%
-2025-03-14 18:51:45,737 - train - INFO - Epoch: 36 | Batch: 100 | Loss: 1.537 | Acc: 46.06%
-2025-03-14 18:51:47,974 - train - INFO - Epoch: 36 | Batch: 200 | Loss: 1.524 | Acc: 46.58%
-2025-03-14 18:51:50,202 - train - INFO - Epoch: 36 | Batch: 300 | Loss: 1.526 | Acc: 46.55%
-2025-03-14 18:51:53,752 - train - INFO - Epoch: 36 | Test Loss: 1.361 | Test Acc: 53.00%
-2025-03-14 18:52:03,416 - train - INFO - Epoch: 37 | Batch: 0 | Loss: 1.415 | Acc: 48.44%
-2025-03-14 18:52:05,593 - train - INFO - Epoch: 37 | Batch: 100 | Loss: 1.575 | Acc: 44.76%
-2025-03-14 18:52:07,827 - train - INFO - Epoch: 37 | Batch: 200 | Loss: 1.538 | Acc: 45.99%
-2025-03-14 18:52:09,999 - train - INFO - Epoch: 37 | Batch: 300 | Loss: 1.526 | Acc: 46.51%
-2025-03-14 18:52:13,370 - train - INFO - Epoch: 37 | Test Loss: 1.458 | Test Acc: 49.32%
-2025-03-14 18:52:13,541 - train - INFO - Epoch: 38 | Batch: 0 | Loss: 1.553 | Acc: 49.22%
-2025-03-14 18:52:15,740 - train - INFO - Epoch: 38 | Batch: 100 | Loss: 1.476 | Acc: 49.10%
-2025-03-14 18:52:17,984 - train - INFO - Epoch: 38 | Batch: 200 | Loss: 1.475 | Acc: 48.56%
-2025-03-14 18:52:20,396 - train - INFO - Epoch: 38 | Batch: 300 | Loss: 1.509 | Acc: 47.59%
-2025-03-14 18:52:23,784 - train - INFO - Epoch: 38 | Test Loss: 1.395 | Test Acc: 51.78%
-2025-03-14 18:52:32,947 - train - INFO - Epoch: 39 | Batch: 0 | Loss: 1.398 | Acc: 51.56%
-2025-03-14 18:52:35,194 - train - INFO - Epoch: 39 | Batch: 100 | Loss: 1.582 | Acc: 44.60%
-2025-03-14 18:52:37,297 - train - INFO - Epoch: 39 | Batch: 200 | Loss: 1.554 | Acc: 45.54%
-2025-03-14 18:52:39,638 - train - INFO - Epoch: 39 | Batch: 300 | Loss: 1.534 | Acc: 46.39%
-2025-03-14 18:52:43,108 - train - INFO - Epoch: 39 | Test Loss: 1.525 | Test Acc: 45.86%
-2025-03-14 18:52:43,297 - train - INFO - Epoch: 40 | Batch: 0 | Loss: 1.696 | Acc: 32.81%
-2025-03-14 18:52:45,599 - train - INFO - Epoch: 40 | Batch: 100 | Loss: 1.522 | Acc: 47.46%
-2025-03-14 18:52:47,940 - train - INFO - Epoch: 40 | Batch: 200 | Loss: 1.516 | Acc: 47.49%
-2025-03-14 18:52:50,269 - train - INFO - Epoch: 40 | Batch: 300 | Loss: 1.508 | Acc: 47.60%
-2025-03-14 18:52:53,724 - train - INFO - Epoch: 40 | Test Loss: 1.450 | Test Acc: 51.11%
-2025-03-14 18:53:03,410 - train - INFO - Epoch: 41 | Batch: 0 | Loss: 1.537 | Acc: 47.66%
-2025-03-14 18:53:05,800 - train - INFO - Epoch: 41 | Batch: 100 | Loss: 1.507 | Acc: 47.56%
-2025-03-14 18:53:08,177 - train - INFO - Epoch: 41 | Batch: 200 | Loss: 1.514 | Acc: 47.43%
-2025-03-14 18:53:10,666 - train - INFO - Epoch: 41 | Batch: 300 | Loss: 1.510 | Acc: 47.77%
-2025-03-14 18:53:14,572 - train - INFO - Epoch: 41 | Test Loss: 1.517 | Test Acc: 48.48%
-2025-03-14 18:53:14,742 - train - INFO - Epoch: 42 | Batch: 0 | Loss: 1.796 | Acc: 42.19%
-2025-03-14 18:53:16,888 - train - INFO - Epoch: 42 | Batch: 100 | Loss: 1.473 | Acc: 48.87%
-2025-03-14 18:53:18,973 - train - INFO - Epoch: 42 | Batch: 200 | Loss: 1.491 | Acc: 48.63%
-2025-03-14 18:53:21,259 - train - INFO - Epoch: 42 | Batch: 300 | Loss: 1.505 | Acc: 48.21%
-2025-03-14 18:53:24,601 - train - INFO - Epoch: 42 | Test Loss: 1.561 | Test Acc: 46.57%
-2025-03-14 18:53:33,569 - train - INFO - Epoch: 43 | Batch: 0 | Loss: 1.608 | Acc: 44.53%
-2025-03-14 18:53:35,694 - train - INFO - Epoch: 43 | Batch: 100 | Loss: 1.491 | Acc: 48.58%
-2025-03-14 18:53:37,928 - train - INFO - Epoch: 43 | Batch: 200 | Loss: 1.491 | Acc: 48.62%
-2025-03-14 18:53:40,500 - train - INFO - Epoch: 43 | Batch: 300 | Loss: 1.486 | Acc: 48.66%
-2025-03-14 18:53:43,816 - train - INFO - Epoch: 43 | Test Loss: 1.374 | Test Acc: 52.62%
-2025-03-14 18:53:43,991 - train - INFO - Epoch: 44 | Batch: 0 | Loss: 1.489 | Acc: 49.22%
-2025-03-14 18:53:46,176 - train - INFO - Epoch: 44 | Batch: 100 | Loss: 1.486 | Acc: 48.23%
-2025-03-14 18:53:48,303 - train - INFO - Epoch: 44 | Batch: 200 | Loss: 1.498 | Acc: 47.92%
-2025-03-14 18:53:50,370 - train - INFO - Epoch: 44 | Batch: 300 | Loss: 1.487 | Acc: 48.34%
-2025-03-14 18:53:53,740 - train - INFO - Epoch: 44 | Test Loss: 1.373 | Test Acc: 52.73%
-2025-03-14 18:54:03,408 - train - INFO - Epoch: 45 | Batch: 0 | Loss: 1.566 | Acc: 47.66%
-2025-03-14 18:54:05,572 - train - INFO - Epoch: 45 | Batch: 100 | Loss: 1.531 | Acc: 47.00%
-2025-03-14 18:54:07,745 - train - INFO - Epoch: 45 | Batch: 200 | Loss: 1.512 | Acc: 47.59%
-2025-03-14 18:54:09,919 - train - INFO - Epoch: 45 | Batch: 300 | Loss: 1.500 | Acc: 48.02%
-2025-03-14 18:54:13,351 - train - INFO - Epoch: 45 | Test Loss: 1.426 | Test Acc: 51.30%
-2025-03-14 18:54:13,612 - train - INFO - Epoch: 46 | Batch: 0 | Loss: 1.334 | Acc: 58.59%
-2025-03-14 18:54:15,863 - train - INFO - Epoch: 46 | Batch: 100 | Loss: 1.496 | Acc: 48.13%
-2025-03-14 18:54:18,032 - train - INFO - Epoch: 46 | Batch: 200 | Loss: 1.489 | Acc: 48.47%
-2025-03-14 18:54:20,219 - train - INFO - Epoch: 46 | Batch: 300 | Loss: 1.495 | Acc: 48.29%
-2025-03-14 18:54:23,452 - train - INFO - Epoch: 46 | Test Loss: 1.528 | Test Acc: 48.13%
-2025-03-14 18:54:32,795 - train - INFO - Epoch: 47 | Batch: 0 | Loss: 1.657 | Acc: 38.28%
-2025-03-14 18:54:35,033 - train - INFO - Epoch: 47 | Batch: 100 | Loss: 1.543 | Acc: 46.42%
-2025-03-14 18:54:37,369 - train - INFO - Epoch: 47 | Batch: 200 | Loss: 1.516 | Acc: 47.45%
-2025-03-14 18:54:39,815 - train - INFO - Epoch: 47 | Batch: 300 | Loss: 1.499 | Acc: 48.16%
-2025-03-14 18:54:43,735 - train - INFO - Epoch: 47 | Test Loss: 1.527 | Test Acc: 49.94%
-2025-03-14 18:54:43,988 - train - INFO - Epoch: 48 | Batch: 0 | Loss: 1.510 | Acc: 44.53%
-2025-03-14 18:54:46,176 - train - INFO - Epoch: 48 | Batch: 100 | Loss: 1.503 | Acc: 48.13%
-2025-03-14 18:54:48,509 - train - INFO - Epoch: 48 | Batch: 200 | Loss: 1.501 | Acc: 48.09%
-2025-03-14 18:54:50,812 - train - INFO - Epoch: 48 | Batch: 300 | Loss: 1.490 | Acc: 48.40%
-2025-03-14 18:54:54,075 - train - INFO - Epoch: 48 | Test Loss: 1.414 | Test Acc: 51.34%
-2025-03-14 18:55:02,937 - train - INFO - Epoch: 49 | Batch: 0 | Loss: 1.570 | Acc: 38.28%
-2025-03-14 18:55:05,141 - train - INFO - Epoch: 49 | Batch: 100 | Loss: 1.473 | Acc: 49.60%
-2025-03-14 18:55:07,346 - train - INFO - Epoch: 49 | Batch: 200 | Loss: 1.474 | Acc: 49.48%
-2025-03-14 18:55:09,548 - train - INFO - Epoch: 49 | Batch: 300 | Loss: 1.478 | Acc: 49.18%
-2025-03-14 18:55:12,872 - train - INFO - Epoch: 49 | Test Loss: 1.352 | Test Acc: 53.22%
-2025-03-14 18:55:13,039 - train - INFO - Epoch: 50 | Batch: 0 | Loss: 1.388 | Acc: 51.56%
-2025-03-14 18:55:15,328 - train - INFO - Epoch: 50 | Batch: 100 | Loss: 1.490 | Acc: 48.34%
-2025-03-14 18:55:17,410 - train - INFO - Epoch: 50 | Batch: 200 | Loss: 1.484 | Acc: 48.32%
-2025-03-14 18:55:19,595 - train - INFO - Epoch: 50 | Batch: 300 | Loss: 1.474 | Acc: 49.08%
-2025-03-14 18:55:22,981 - train - INFO - Epoch: 50 | Test Loss: 1.513 | Test Acc: 46.94%
-2025-03-14 18:55:32,176 - train - INFO - 训练完成!

Image/LeNet5/code/train.py

@@ -1,63 +0,0 @@
-import sys
-import os
-sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-from utils.dataset_utils import get_cifar10_dataloaders
-from utils.train_utils import train_model, train_model_data_augmentation, train_model_backdoor
-from utils.parse_args import parse_args
-from model import LeNet5
-
-def main():
-    # 解析命令行参数
-    args = parse_args()
-    
-    # 创建模型
-    model = LeNet5()
-    
-    if args.train_type == '0':
-        # 获取数据加载器
-        trainloader, testloader = get_cifar10_dataloaders(batch_size=args.batch_size, local_dataset_path=args.dataset_path)
-        # 训练模型
-        train_model(
-            model=model,
-            trainloader=trainloader,
-            testloader=testloader,
-            epochs=args.epochs,
-            lr=args.lr,
-            device=f'cuda:{args.gpu}',
-            save_dir='../model',
-            model_name='lenet5',
-            save_type='0',
-            layer_name='conv2',
-            interval = 2
-        )
-    elif args.train_type == '1':
-        train_model_data_augmentation(
-            model, 
-            epochs=args.epochs, 
-            lr=args.lr, 
-            device=f'cuda:{args.gpu}', 
-            save_dir='../model', 
-            model_name='lenet5',
-            batch_size=args.batch_size, 
-            num_workers=args.num_workers,
-            local_dataset_path=args.dataset_path
-        )
-    elif args.train_type == '2':
-        train_model_backdoor(
-            model, 
-            poison_ratio=args.poison_ratio, 
-            target_label=args.target_label, 
-            epochs=args.epochs, 
-            lr=args.lr,
-            device=f'cuda:{args.gpu}', 
-            save_dir='../model', 
-            model_name='lenet5',
-            batch_size=args.batch_size, 
-            num_workers=args.num_workers,
-            local_dataset_path=args.dataset_path,
-            layer_name='conv2',
-            interval = 2
-        )
-
-if __name__ == '__main__':
-    main()

Image/LeNet5/model/0/epoch1/embeddings.npy

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d655d14885b3382a95cd8f1685db6b4a3e114db764acfe1e8fec0132ccb241b2
-size 80000128

Image/LeNet5/model/0/epoch10/embeddings.npy

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:665a4d9333b30c8d44f1b314c2c5ba37b6a24555e8d6ce9000f9e15c43dae227
-size 80000128

Image/LeNet5/model/0/epoch11/embeddings.npy

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:aa27a313f1475dbb461bbcd4d22ef2fe9f792d1a6977d66a5d51afc21fca9c1a
-size 80000128

Image/LeNet5/model/0/epoch12/embeddings.npy

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1488b8d7523aea773179f4dfb8d3e23a4236364ba30a418e5a76609ac238a596
-size 80000128

Image/LeNet5/model/0/epoch13/embeddings.npy

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d49e3a95395193b35e150a9438316248e0ee4a369813751067a77829a42b429a
-size 80000128