add all

Image/ViT/code/train.py

@@ -1,59 +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 ViT
-
-def main():
-    # 解析命令行参数
-    args = parse_args()
-    
-    # 创建模型
-    model = ViT()
-    
-    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='vit',
-            save_type='0'
-        )
-    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='vit',
-            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='vit',
-            batch_size=args.batch_size, 
-            num_workers=args.num_workers,
-            local_dataset_path=args.dataset_path
-        )
-
-if __name__ == '__main__':
-    main()

Image/ZFNet/code/train.py

@@ -1,59 +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 ZFNet
-
-def main():
-    # 解析命令行参数
-    args = parse_args()
-    
-    # 创建模型
-    model = ZFNet()
-    
-    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='zfnet',
-            save_type='0'
-        )
-    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='zfnet',
-            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='zfnet',
-            batch_size=args.batch_size, 
-            num_workers=args.num_workers,
-            local_dataset_path=args.dataset_path
-        )
-
-if __name__ == '__main__':
-    main()

ViT-CIFAR10/Classification-backdoor/dataset/backdoor_index.npy

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

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

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

ViT-CIFAR10/Classification-backdoor/dataset/labels.npy

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

ViT-CIFAR10/Classification-backdoor/readme.md

@@ -0,0 +1,54 @@
+# ViT-CIFAR10 训练与特征提取
+
+这个项目实现了ViT模型在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`：包含训练集、测试集和验证集的索引信息

ViT-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'])}个样本")

ViT-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

ViT-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)

ViT-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.reshape(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.reshape(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.reshape(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": indices,  # 所有数据默认为训练集
+                "test": [],        # 初始为空
+                "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]}]")

{Image/ViT/code → ViT-CIFAR10/Classification-backdoor/scripts}/model.py

@@ -113,7 +113,7 @@ class ViT(nn.Module):
             img_size=32,
             patch_size=4,
             in_chans=3,
-            n_classes=10,
+            num_classes=10,
             embed_dim=96,
             depth=12,
             n_heads=8,
@@ -149,7 +149,7 @@ class ViT(nn.Module):
         ])
 
         self.norm = nn.LayerNorm(embed_dim, eps=1e-6)
-        self.head = nn.Linear(embed_dim, n_classes)
+        self.head = nn.Linear(embed_dim, num_classes)
 
     def forward(self, x):
         n_samples = x.shape[0]

ViT-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 ViT
+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='blocks.11', 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 = ViT(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='ViT_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()

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

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

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

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

ViT-CIFAR10/Classification-noisy/dataset/labels.npy

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

ViT-CIFAR10/Classification-noisy/dataset/noise_index.npy

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

ViT-CIFAR10/Classification-noisy/readme.md

@@ -0,0 +1,54 @@
+# ViT-CIFAR10 训练与特征提取
+
+这个项目实现了ViT模型在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`：包含训练集、测试集和验证集的索引信息

ViT-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'])}个样本")

ViT-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

ViT-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)

ViT-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.reshape(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.reshape(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.reshape(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": indices,  # 所有数据默认为训练集
+                "test": [],        # 初始为空
+                "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]}]")

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

@@ -0,0 +1,171 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class PatchEmbed(nn.Module):
+    """ 将图像分成patch并进行embedding """
+    def __init__(self, img_size=32, patch_size=4, in_chans=3, embed_dim=96):
+        super().__init__()
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.n_patches = (img_size // patch_size) ** 2
+        
+        self.proj = nn.Conv2d(
+            in_chans, embed_dim,
+            kernel_size=patch_size, stride=patch_size
+        )
+
+    def forward(self, x):
+        x = self.proj(x)               # (B, E, H/P, W/P)
+        x = x.flatten(2)               # (B, E, N)
+        x = x.transpose(1, 2)          # (B, N, E)
+        return x
+
+class Attention(nn.Module):
+    """ 多头自注意力机制 """
+    def __init__(self, dim, n_heads=8, qkv_bias=True, attn_p=0., proj_p=0.):
+        super().__init__()
+        self.n_heads = n_heads
+        self.dim = dim
+        self.head_dim = dim // n_heads
+        self.scale = self.head_dim ** -0.5
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_p)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_p)
+
+    def forward(self, x):
+        n_samples, n_tokens, dim = x.shape
+
+        if dim != self.dim:
+            raise ValueError
+
+        qkv = self.qkv(x)                                           # (n_samples, n_patches + 1, 3 * dim)
+        qkv = qkv.reshape(
+            n_samples, n_tokens, 3, self.n_heads, self.head_dim
+        )                                                           # (n_samples, n_patches + 1, 3, n_heads, head_dim)
+        qkv = qkv.permute(2, 0, 3, 1, 4)                          # (3, n_samples, n_heads, n_patches + 1, head_dim)
+        q, k, v = qkv[0], qkv[1], qkv[2]                          # each with shape (n_samples, n_heads, n_patches + 1, head_dim)
+
+        k_t = k.transpose(-2, -1)                                  # (n_samples, n_heads, head_dim, n_patches + 1)
+        dp = (q @ k_t) * self.scale                               # (n_samples, n_heads, n_patches + 1, n_patches + 1)
+        attn = dp.softmax(dim=-1)                                 # (n_samples, n_heads, n_patches + 1, n_patches + 1)
+        attn = self.attn_drop(attn)
+
+        weighted_avg = attn @ v                                    # (n_samples, n_heads, n_patches + 1, head_dim)
+        weighted_avg = weighted_avg.transpose(1, 2)                # (n_samples, n_patches + 1, n_heads, head_dim)
+        weighted_avg = weighted_avg.flatten(2)                     # (n_samples, n_patches + 1, dim)
+
+        x = self.proj(weighted_avg)                               # (n_samples, n_patches + 1, dim)
+        x = self.proj_drop(x)                                     # (n_samples, n_patches + 1, dim)
+
+        return x
+
+class MLP(nn.Module):
+    """ 多层感知机 """
+    def __init__(self, in_features, hidden_features, out_features, p=0.):
+        super().__init__()
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = nn.GELU()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(p)
+
+    def forward(self, x):
+        x = self.fc1(x)               # (n_samples, n_patches + 1, hidden_features)
+        x = self.act(x)               # (n_samples, n_patches + 1, hidden_features)
+        x = self.drop(x)              # (n_samples, n_patches + 1, hidden_features)
+        x = self.fc2(x)               # (n_samples, n_patches + 1, out_features)
+        x = self.drop(x)              # (n_samples, n_patches + 1, out_features)
+
+        return x
+
+class Block(nn.Module):
+    """ Transformer编码器块 """
+    def __init__(self, dim, n_heads, mlp_ratio=4.0, qkv_bias=True,
+                 p=0., attn_p=0.):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim, eps=1e-6)
+        self.attn = Attention(
+            dim,
+            n_heads=n_heads,
+            qkv_bias=qkv_bias,
+            attn_p=attn_p,
+            proj_p=p
+        )
+        self.norm2 = nn.LayerNorm(dim, eps=1e-6)
+        hidden_features = int(dim * mlp_ratio)
+        self.mlp = MLP(
+            in_features=dim,
+            hidden_features=hidden_features,
+            out_features=dim,
+        )
+
+    def forward(self, x):
+        x = x + self.attn(self.norm1(x))
+        x = x + self.mlp(self.norm2(x))
+        return x
+
+class ViT(nn.Module):
+    """ Vision Transformer """
+    def __init__(
+            self,
+            img_size=32,
+            patch_size=4,
+            in_chans=3,
+            num_classes=10,
+            embed_dim=96,
+            depth=12,
+            n_heads=8,
+            mlp_ratio=4.,
+            qkv_bias=True,
+            p=0.,
+            attn_p=0.,
+    ):
+        super().__init__()
+
+        self.patch_embed = PatchEmbed(
+            img_size=img_size,
+            patch_size=patch_size,
+            in_chans=in_chans,
+            embed_dim=embed_dim,
+        )
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(
+            torch.zeros(1, 1 + self.patch_embed.n_patches, embed_dim)
+        )
+        self.pos_drop = nn.Dropout(p=p)
+
+        self.blocks = nn.ModuleList([
+            Block(
+                dim=embed_dim,
+                n_heads=n_heads,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                p=p,
+                attn_p=attn_p,
+            )
+            for _ in range(depth)
+        ])
+
+        self.norm = nn.LayerNorm(embed_dim, eps=1e-6)
+        self.head = nn.Linear(embed_dim, num_classes)
+
+    def forward(self, x):
+        n_samples = x.shape[0]
+        x = self.patch_embed(x)
+
+        cls_token = self.cls_token.expand(n_samples, -1, -1)
+        x = torch.cat((cls_token, x), dim=1)
+        x = x + self.pos_embed
+        x = self.pos_drop(x)
+
+        for block in self.blocks:
+            x = block(x)
+
+        x = self.norm(x)
+
+        cls_token_final = x[:, 0]
+        x = self.head(cls_token_final)
+
+        return x

ViT-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='.')

ViT-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 ViT
+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='blocks.11', 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 = ViT().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='ViT_noisy',
+        interval=interval
+    )
+    
+    print(f"训练完成，模型已保存到 {save_dir}")
+    return model
+
+# 主函数
+if __name__ == '__main__':
+    noisy_train()

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

@@ -0,0 +1,25 @@
+batch_size: 128
+num_workers: 2
+dataset_path: ../dataset
+epochs: 50
+gpu: 4
+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]  # 泊松噪声没有强度参数

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

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

ViT-CIFAR10/Classification-normal/dataset/labels.npy

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

ViT-CIFAR10/Classification-normal/readme.md

@@ -0,0 +1,54 @@
+# ViT-CIFAR10 训练与特征提取
+
+这个项目实现了ViT模型在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`：包含训练集、测试集和验证集的索引信息

ViT-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

ViT-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)

ViT-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.reshape(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.reshape(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.reshape(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": indices,  # 所有数据默认为训练集
+                "test": [],        # 初始为空
+                "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]}]")

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

@@ -0,0 +1,171 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class PatchEmbed(nn.Module):
+    """ 将图像分成patch并进行embedding """
+    def __init__(self, img_size=32, patch_size=4, in_chans=3, embed_dim=96):
+        super().__init__()
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.n_patches = (img_size // patch_size) ** 2
+        
+        self.proj = nn.Conv2d(
+            in_chans, embed_dim,
+            kernel_size=patch_size, stride=patch_size
+        )
+
+    def forward(self, x):
+        x = self.proj(x)               # (B, E, H/P, W/P)
+        x = x.flatten(2)               # (B, E, N)
+        x = x.transpose(1, 2)          # (B, N, E)
+        return x
+
+class Attention(nn.Module):
+    """ 多头自注意力机制 """
+    def __init__(self, dim, n_heads=8, qkv_bias=True, attn_p=0., proj_p=0.):
+        super().__init__()
+        self.n_heads = n_heads
+        self.dim = dim
+        self.head_dim = dim // n_heads
+        self.scale = self.head_dim ** -0.5
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_p)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_p)
+
+    def forward(self, x):
+        n_samples, n_tokens, dim = x.shape
+
+        if dim != self.dim:
+            raise ValueError
+
+        qkv = self.qkv(x)                                           # (n_samples, n_patches + 1, 3 * dim)
+        qkv = qkv.reshape(
+            n_samples, n_tokens, 3, self.n_heads, self.head_dim
+        )                                                           # (n_samples, n_patches + 1, 3, n_heads, head_dim)
+        qkv = qkv.permute(2, 0, 3, 1, 4)                          # (3, n_samples, n_heads, n_patches + 1, head_dim)
+        q, k, v = qkv[0], qkv[1], qkv[2]                          # each with shape (n_samples, n_heads, n_patches + 1, head_dim)
+
+        k_t = k.transpose(-2, -1)                                  # (n_samples, n_heads, head_dim, n_patches + 1)
+        dp = (q @ k_t) * self.scale                               # (n_samples, n_heads, n_patches + 1, n_patches + 1)
+        attn = dp.softmax(dim=-1)                                 # (n_samples, n_heads, n_patches + 1, n_patches + 1)
+        attn = self.attn_drop(attn)
+
+        weighted_avg = attn @ v                                    # (n_samples, n_heads, n_patches + 1, head_dim)
+        weighted_avg = weighted_avg.transpose(1, 2)                # (n_samples, n_patches + 1, n_heads, head_dim)
+        weighted_avg = weighted_avg.flatten(2)                     # (n_samples, n_patches + 1, dim)
+
+        x = self.proj(weighted_avg)                               # (n_samples, n_patches + 1, dim)
+        x = self.proj_drop(x)                                     # (n_samples, n_patches + 1, dim)
+
+        return x
+
+class MLP(nn.Module):
+    """ 多层感知机 """
+    def __init__(self, in_features, hidden_features, out_features, p=0.):
+        super().__init__()
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = nn.GELU()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(p)
+
+    def forward(self, x):
+        x = self.fc1(x)               # (n_samples, n_patches + 1, hidden_features)
+        x = self.act(x)               # (n_samples, n_patches + 1, hidden_features)
+        x = self.drop(x)              # (n_samples, n_patches + 1, hidden_features)
+        x = self.fc2(x)               # (n_samples, n_patches + 1, out_features)
+        x = self.drop(x)              # (n_samples, n_patches + 1, out_features)
+
+        return x
+
+class Block(nn.Module):
+    """ Transformer编码器块 """
+    def __init__(self, dim, n_heads, mlp_ratio=4.0, qkv_bias=True,
+                 p=0., attn_p=0.):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim, eps=1e-6)
+        self.attn = Attention(
+            dim,
+            n_heads=n_heads,
+            qkv_bias=qkv_bias,
+            attn_p=attn_p,
+            proj_p=p
+        )
+        self.norm2 = nn.LayerNorm(dim, eps=1e-6)
+        hidden_features = int(dim * mlp_ratio)
+        self.mlp = MLP(
+            in_features=dim,
+            hidden_features=hidden_features,
+            out_features=dim,
+        )
+
+    def forward(self, x):
+        x = x + self.attn(self.norm1(x))
+        x = x + self.mlp(self.norm2(x))
+        return x
+
+class ViT(nn.Module):
+    """ Vision Transformer """
+    def __init__(
+            self,
+            img_size=32,
+            patch_size=4,
+            in_chans=3,
+            num_classes=10,
+            embed_dim=96,
+            depth=12,
+            n_heads=8,
+            mlp_ratio=4.,
+            qkv_bias=True,
+            p=0.,
+            attn_p=0.,
+    ):
+        super().__init__()
+
+        self.patch_embed = PatchEmbed(
+            img_size=img_size,
+            patch_size=patch_size,
+            in_chans=in_chans,
+            embed_dim=embed_dim,
+        )
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(
+            torch.zeros(1, 1 + self.patch_embed.n_patches, embed_dim)
+        )
+        self.pos_drop = nn.Dropout(p=p)
+
+        self.blocks = nn.ModuleList([
+            Block(
+                dim=embed_dim,
+                n_heads=n_heads,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                p=p,
+                attn_p=attn_p,
+            )
+            for _ in range(depth)
+        ])
+
+        self.norm = nn.LayerNorm(embed_dim, eps=1e-6)
+        self.head = nn.Linear(embed_dim, num_classes)
+
+    def forward(self, x):
+        n_samples = x.shape[0]
+        x = self.patch_embed(x)
+
+        cls_token = self.cls_token.expand(n_samples, -1, -1)
+        x = torch.cat((cls_token, x), dim=1)
+        x = x + self.pos_embed
+        x = self.pos_drop(x)
+
+        for block in self.blocks:
+            x = block(x)
+
+        x = self.norm(x)
+
+        cls_token_final = x[:, 0]
+        x = self.head(cls_token_final)
+
+        return x

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

@@ -0,0 +1,220 @@
+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 ViT
+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
+            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}')
+            save_model = time_travel_saver(model, ordered_trainloader, device, epoch_save_dir, model_name, 
+                         show=True, layer_name='blocks.11', 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 = ViT(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='ViT',
+        interval=config['interval']
+    )
+
+if __name__ == '__main__':
+    main()

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

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

ZFNet-CIFAR10/Classification-backdoor/dataset/backdoor_index.npy

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

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

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

ZFNet-CIFAR10/Classification-backdoor/dataset/labels.npy

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

ZFNet-CIFAR10/Classification-backdoor/epochs/epoch_1/embeddings.npy

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

ZFNet-CIFAR10/Classification-backdoor/epochs/epoch_1/model.pth

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

ZFNet-CIFAR10/Classification-backdoor/epochs/epoch_1/predictions.npy

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

ZFNet-CIFAR10/Classification-backdoor/epochs/epoch_10/embeddings.npy

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

ZFNet-CIFAR10/Classification-backdoor/epochs/epoch_10/model.pth

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