add ShuffleNet-CIFAR10

Image/ShuffleNetv2/code/model.py

@@ -1,366 +0,0 @@
-'''
-ShuffleNetV2 in PyTorch.
-
-ShuffleNetV2是ShuffleNet的改进版本,通过实验总结出了四个高效网络设计的实用准则:
-1. 输入输出通道数相等时计算量最小
-2. 过度使用组卷积会增加MAC(内存访问代价)
-3. 网络碎片化会降低并行度
-4. Element-wise操作不可忽视
-
-主要改进:
-1. 通道分离(Channel Split)替代组卷积
-2. 重新设计了基本单元,使输入输出通道数相等
-3. 每个阶段使用不同的通道数配置
-4. 简化了下采样模块的设计
-
-Reference:
-[1] Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, Jian Sun
-    ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design. ECCV 2018.
-'''
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class ShuffleBlock(nn.Module):
-    """通道重排模块
-    
-    通过重新排列通道的顺序来实现不同特征的信息交流。
-    
-    Args:
-        groups (int): 分组数量,默认为2
-    """
-    def __init__(self, groups=2):
-        super(ShuffleBlock, self).__init__()
-        self.groups = groups
-
-    def forward(self, x):
-        """通道重排的前向传播
-        
-        步骤:
-        1. [N,C,H,W] -> [N,g,C/g,H,W]  # 重塑为g组
-        2. [N,g,C/g,H,W] -> [N,C/g,g,H,W]  # 转置g维度
-        3. [N,C/g,g,H,W] -> [N,C,H,W]  # 重塑回原始形状
-        
-        Args:
-            x: 输入张量,[N,C,H,W]
-            
-        Returns:
-            out: 通道重排后的张量,[N,C,H,W]
-        """
-        N, C, H, W = x.size()
-        g = self.groups
-        return x.view(N, g, C//g, H, W).permute(0, 2, 1, 3, 4).reshape(N, C, H, W)
-
-
-class SplitBlock(nn.Module):
-    """通道分离模块
-    
-    将输入特征图按比例分成两部分。
-    
-    Args:
-        ratio (float): 分离比例,默认为0.5
-    """
-    def __init__(self, ratio):
-        super(SplitBlock, self).__init__()
-        self.ratio = ratio
-
-    def forward(self, x):
-        """通道分离的前向传播
-        
-        Args:
-            x: 输入张量,[N,C,H,W]
-            
-        Returns:
-            tuple: 分离后的两个张量,[N,C1,H,W]和[N,C2,H,W]
-        """
-        c = int(x.size(1) * self.ratio)
-        return x[:, :c, :, :], x[:, c:, :, :]
-
-
-class BasicBlock(nn.Module):
-    """ShuffleNetV2的基本模块
-    
-    结构:
-    x -------|-----------------|
-      |      |                |
-      |      1x1 Conv         |
-      |      3x3 DWConv       |
-      |      1x1 Conv         |
-      |                       |
-      |------------------Concat
-                          |
-                      Channel Shuffle
-                          
-    Args:
-        in_channels (int): 输入通道数
-        split_ratio (float): 通道分离比例,默认为0.5
-    """
-    def __init__(self, in_channels, split_ratio=0.5):
-        super(BasicBlock, self).__init__()
-        self.split = SplitBlock(split_ratio)
-        in_channels = int(in_channels * split_ratio)
-        
-        # 主分支
-        self.conv1 = nn.Conv2d(in_channels, in_channels,
-                              kernel_size=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(in_channels)
-        
-        self.conv2 = nn.Conv2d(in_channels, in_channels,
-                              kernel_size=3, stride=1, padding=1, 
-                              groups=in_channels, bias=False)
-        self.bn2 = nn.BatchNorm2d(in_channels)
-        
-        self.conv3 = nn.Conv2d(in_channels, in_channels,
-                              kernel_size=1, bias=False)
-        self.bn3 = nn.BatchNorm2d(in_channels)
-        
-        self.shuffle = ShuffleBlock()
-
-    def forward(self, x):
-        # 通道分离
-        x1, x2 = self.split(x)
-        
-        # 主分支
-        out = F.relu(self.bn1(self.conv1(x2)))
-        out = self.bn2(self.conv2(out))
-        out = F.relu(self.bn3(self.conv3(out)))
-        
-        # 拼接并重排
-        out = torch.cat([x1, out], 1)
-        out = self.shuffle(out)
-        return out
-
-
-class DownBlock(nn.Module):
-    """下采样模块
-    
-    结构:
-           3x3 DWConv(s=2)     1x1 Conv
-    x -----> 1x1 Conv          3x3 DWConv(s=2)
-                               1x1 Conv
-                                  |
-                              Concat
-                                  |
-                          Channel Shuffle
-                          
-    Args:
-        in_channels (int): 输入通道数
-        out_channels (int): 输出通道数
-    """
-    def __init__(self, in_channels, out_channels):
-        super(DownBlock, self).__init__()
-        mid_channels = out_channels // 2
-        
-        # 左分支
-        self.branch1 = nn.Sequential(
-            # 3x3深度可分离卷积,步长为2
-            nn.Conv2d(in_channels, in_channels,
-                     kernel_size=3, stride=2, padding=1, 
-                     groups=in_channels, bias=False),
-            nn.BatchNorm2d(in_channels),
-            # 1x1卷积
-            nn.Conv2d(in_channels, mid_channels,
-                     kernel_size=1, bias=False),
-            nn.BatchNorm2d(mid_channels)
-        )
-        
-        # 右分支
-        self.branch2 = nn.Sequential(
-            # 1x1卷积
-            nn.Conv2d(in_channels, mid_channels,
-                     kernel_size=1, bias=False),
-            nn.BatchNorm2d(mid_channels),
-            # 3x3深度可分离卷积,步长为2
-            nn.Conv2d(mid_channels, mid_channels,
-                     kernel_size=3, stride=2, padding=1,
-                     groups=mid_channels, bias=False),
-            nn.BatchNorm2d(mid_channels),
-            # 1x1卷积
-            nn.Conv2d(mid_channels, mid_channels,
-                     kernel_size=1, bias=False),
-            nn.BatchNorm2d(mid_channels)
-        )
-        
-        self.shuffle = ShuffleBlock()
-
-    def forward(self, x):
-        # 左分支
-        out1 = self.branch1(x)
-        
-        # 右分支
-        out2 = self.branch2(x)
-        
-        # 拼接并重排
-        out = torch.cat([out1, out2], 1)
-        out = self.shuffle(out)
-        return out
-
-
-class ShuffleNetV2(nn.Module):
-    """ShuffleNetV2模型
-    
-    网络结构:
-    1. 一个卷积层进行特征提取
-    2. 三个阶段,每个阶段包含多个基本块和一个下采样块
-    3. 最后一个卷积层
-    4. 平均池化和全连接层进行分类
-    
-    Args:
-        net_size (float): 网络大小系数,可选0.5/1.0/1.5/2.0
-    """
-    def __init__(self, net_size = 0.5, num_classes = 10):
-        super(ShuffleNetV2, self).__init__()
-        out_channels = configs[net_size]['out_channels']
-        num_blocks = configs[net_size]['num_blocks']
-
-        # 第一层卷积
-        self.conv1 = nn.Conv2d(3, 24, kernel_size=3,
-                              stride=1, padding=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(24)
-        self.in_channels = 24
-        
-        # 三个阶段
-        self.layer1 = self._make_layer(out_channels[0], num_blocks[0])
-        self.layer2 = self._make_layer(out_channels[1], num_blocks[1])
-        self.layer3 = self._make_layer(out_channels[2], num_blocks[2])
-        
-        # 最后的1x1卷积
-        self.conv2 = nn.Conv2d(out_channels[2], out_channels[3],
-                              kernel_size=1, stride=1, padding=0, bias=False)
-        self.bn2 = nn.BatchNorm2d(out_channels[3])
-        
-        # 分类层
-        self.avg_pool = nn.AdaptiveAvgPool2d(1)
-        self.classifier = nn.Linear(out_channels[3], num_classes)
-        
-        # 初始化权重
-        self._initialize_weights()
-
-    def _make_layer(self, out_channels, num_blocks):
-        """构建一个阶段
-        
-        Args:
-            out_channels (int): 输出通道数
-            num_blocks (int): 基本块的数量
-            
-        Returns:
-            nn.Sequential: 一个阶段的层序列
-        """
-        layers = [DownBlock(self.in_channels, out_channels)]
-        for i in range(num_blocks):
-            layers.append(BasicBlock(out_channels))
-            self.in_channels = out_channels
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        """前向传播
-        
-        Args:
-            x: 输入张量,[N,3,32,32]
-            
-        Returns:
-            out: 输出张量,[N,num_classes]
-        """
-        # 特征提取
-        out = F.relu(self.bn1(self.conv1(x)))
-        
-        # 三个阶段
-        out = self.layer1(out)
-        out = self.layer2(out)
-        out = self.layer3(out)
-        
-        # 最后的特征提取
-        out = F.relu(self.bn2(self.conv2(out)))
-        
-        # 分类
-        out = self.avg_pool(out)
-        out = out.view(out.size(0), -1)
-        out = self.classifier(out)
-        return out
-    
-    def feature(self, x):
-        # 特征提取
-        out = F.relu(self.bn1(self.conv1(x)))
-        
-        # 三个阶段
-        out = self.layer1(out)
-        out = self.layer2(out)
-        out = self.layer3(out)
-        
-        # 最后的特征提取
-        out = F.relu(self.bn2(self.conv2(out)))
-        
-        # 分类
-        out = self.avg_pool(out)
-        return out
-    
-    def prediction(self, out):
-        out = out.view(out.size(0), -1)
-        out = self.classifier(out)
-        return out
-
-    def _initialize_weights(self):
-        """初始化模型权重
-        
-        采用kaiming初始化方法:
-        - 卷积层权重采用kaiming_normal_初始化
-        - BN层参数采用常数初始化
-        - 线性层采用正态分布初始化
-        """
-        for m in self.modules():
-            if isinstance(m, nn.Conv2d):
-                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
-                if m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.BatchNorm2d):
-                nn.init.constant_(m.weight, 1)
-                nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, 0, 0.01)
-                nn.init.constant_(m.bias, 0)
-
-
-# 不同大小的网络配置
-configs = {
-    0.5: {
-        'out_channels': (48, 96, 192, 1024),
-        'num_blocks': (3, 7, 3)
-    },
-    1.0: {
-        'out_channels': (116, 232, 464, 1024),
-        'num_blocks': (3, 7, 3)
-    },
-    1.5: {
-        'out_channels': (176, 352, 704, 1024),
-        'num_blocks': (3, 7, 3)
-    },
-    2.0: {
-        'out_channels': (224, 488, 976, 2048),
-        'num_blocks': (3, 7, 3)
-    }
-}
-
-
-def test():
-    """测试函数"""
-    # 创建模型
-    net = ShuffleNetV2(net_size=0.5)
-    print('Model Structure:')
-    print(net)
-    
-    # 测试前向传播
-    x = torch.randn(1,3,32,32)
-    y = net(x)
-    print('\nInput Shape:', x.shape)
-    print('Output Shape:', y.shape)
-    
-    # 打印模型信息
-    from torchinfo import summary
-    device = 'cuda' if torch.cuda.is_available() else 'cpu'
-    net = net.to(device)
-    summary(net, (1,3,32,32))
-
-
-if __name__ == '__main__':
-    test()

Image/ShuffleNetv2/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 ShuffleNetv2
-
-def main():
-    # 解析命令行参数
-    args = parse_args()
-    
-    # 创建模型
-    model = ShuffleNetv2()
-    
-    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='shufflenetv2',
-            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='shufflenetv2',
-            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='shufflenetv2',
-            batch_size=args.batch_size, 
-            num_workers=args.num_workers,
-            local_dataset_path=args.dataset_path
-        )
-
-if __name__ == '__main__':
-    main()

Image/utils/dataset_utils.py

@@ -1,110 +0,0 @@
-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=True):
-    """获取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}")
-        download = False
-        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_mnist_dataloaders(batch_size=128, num_workers=2, local_dataset_path=None,shuffle=True):
-    """获取MNIST数据集的数据加载器
-    
-    Args:
-        batch_size: 批次大小
-        num_workers: 数据加载的工作进程数
-        local_dataset_path: 本地数据集路径，如果提供则使用本地数据集，否则下载
-        
-    Returns:
-        trainloader: 训练数据加载器
-        testloader: 测试数据加载器
-    """
-    # 数据预处理
-    transform_train = transforms.Compose([
-        transforms.RandomRotation(10),     # 随机旋转±10度
-        transforms.RandomAffine(          # 随机仿射变换
-            degrees=0,                    # 不进行旋转
-            translate=(0.1, 0.1),         # 平移范围
-            scale=(0.9, 1.1)             # 缩放范围
-        ),
-        transforms.ToTensor(),
-        transforms.Normalize((0.1307,), (0.3081,))  # MNIST数据集的均值和标准差
-    ])
-
-    transform_test = transforms.Compose([
-        transforms.ToTensor(),
-        transforms.Normalize((0.1307,), (0.3081,))
-    ])
-
-    # 设置数据集路径
-    if local_dataset_path:
-        print(f"使用本地数据集: {local_dataset_path}")
-        download = False
-        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.MNIST(
-        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.MNIST(
-        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

Image/utils/parse_args.py

@@ -1,19 +0,0 @@
-import argparse
-
-def parse_args():
-    """解析命令行参数
-    
-    Returns:
-        args: 解析后的参数
-    """
-    parser = argparse.ArgumentParser(description='训练模型')
-    parser.add_argument('--gpu', type=int, default=0, help='GPU设备编号 (0,1,2,3)')
-    parser.add_argument('--batch-size', type=int, default=128, help='批次大小')
-    parser.add_argument('--epochs', type=int, default=200, help='训练轮数')
-    parser.add_argument('--lr', type=float, default=0.1, help='学习率')
-    parser.add_argument('--num-workers', type=int, default=2, help='数据加载的工作进程数')
-    parser.add_argument('--poison-ratio', type=float, default=0.1, help='恶意样本比例')
-    parser.add_argument('--target-label', type=int, default=0, help='目标类别') 
-    parser.add_argument('--train-type',type=str,choices=['0','1','2'],default='0',help='训练类型:0 for normal train, 1 for data aug train,2 for back door train')
-    parser.add_argument('--dataset-path', type=str, default=None, help='本地数据集路径，如果不指定则自动下载')
-    return parser.parse_args()

Image/utils/train_utils.py

@@ -1,381 +0,0 @@
-"""
-通用模型训练工具
-
-提供了模型训练、评估、保存等功能，支持:
-1. 训练进度可视化
-2. 日志记录
-3. 模型检查点保存
-4. 嵌入向量收集
-"""
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import time
-import os
-import logging
-import numpy as np
-from tqdm import tqdm
-import sys
-from pathlib import Path
-import torch.nn.functional as F
-import torchvision.transforms as transforms
-
-# 将项目根目录添加到Python路径中
-current_dir = Path(__file__).resolve().parent
-project_root = current_dir.parent.parent
-sys.path.append(str(project_root))
-
-from ttv_utils 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='./checkpoints', model_name='model', save_type='0',layer_name=None,interval = 2):
-    """通用的模型训练函数
-    Args:
-        model: 要训练的模型
-        trainloader: 训练数据加载器
-        testloader: 测试数据加载器
-        epochs: 训练轮数
-        lr: 学习率
-        device: 训练设备，格式为'cuda:N'，其中N为GPU编号（0,1,2,3）
-        save_dir: 模型保存目录
-        model_name: 模型名称
-        save_type: 保存类型，0为普通训练，1为数据增强训练，2为后门训练
-    """
-    # 检查并设置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'
-    
-    # 设置保存目录 0 for normal train, 1 for data aug train,2 for back door train
-    if not os.path.exists(save_dir):
-        os.makedirs(save_dir)
-    
-    # 设置日志 0 for normal train, 1 for data aug train,2 for back door train
-    if save_type == '0':
-        log_file = os.path.join(os.path.dirname(save_dir), 'code', 'train.log')
-        if not os.path.exists(os.path.dirname(log_file)):
-            os.makedirs(os.path.dirname(log_file))
-    elif save_type == '1':
-        log_file = os.path.join(os.path.dirname(save_dir), 'code', 'data_aug_train.log')
-        if not os.path.exists(os.path.dirname(log_file)):
-            os.makedirs(os.path.dirname(log_file))
-    elif save_type == '2':
-        log_file = os.path.join(os.path.dirname(save_dir), 'code', 'backdoor_train.log')
-        if not os.path.exists(os.path.dirname(log_file)):
-            os.makedirs(os.path.dirname(log_file))
-    logger = setup_logger(log_file)
-    
-    # 设置epoch保存目录 0 for normal train, 1 for data aug train,2 for back door train
-    save_dir = os.path.join(save_dir, save_type)
-    if not os.path.exists(save_dir):
-        os.makedirs(save_dir)
-
-    # 损失函数和优化器
-    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=200)
-    
-    # 移动模型到指定设备
-    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}%'
-            })
-        
-            # 每100步记录一次
-            if batch_idx % 100 == 0:
-                logger.info(f'Epoch: {epoch+1} | Batch: {batch_idx} | '
-                          f'Loss: {train_loss/(batch_idx+1):.3f} | '
-                          f'Acc: {100.*correct/total:.2f}%')
-        
-        # 测试阶段
-        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} | Test Loss: {test_loss/(batch_idx+1):.3f} | '
-                   f'Test Acc: {acc:.2f}%')
-        
-
-        if epoch == 0:
-            ordered_loader = torch.utils.data.DataLoader(
-                trainloader.dataset,  # 使用相同的数据集
-                batch_size=trainloader.batch_size,
-                shuffle=False,  # 确保顺序加载
-                num_workers=trainloader.num_workers
-            )
-            save_model = time_travel_saver(model, ordered_loader, device, save_dir, model_name, interval = 1, auto_save_embedding = True, layer_name = layer_name, show= True )
-
-        # 每5个epoch保存一次
-        if (epoch + 1) % interval == 0:
-            # 创建一个专门用于收集embedding的顺序dataloader
-            ordered_loader = torch.utils.data.DataLoader(
-                trainloader.dataset,  # 使用相同的数据集
-                batch_size=trainloader.batch_size,
-                shuffle=False,  # 确保顺序加载
-                num_workers=trainloader.num_workers
-            )
-            save_model = time_travel_saver(model, ordered_loader, device, save_dir, model_name, interval = 1, auto_save_embedding = True, layer_name = layer_name )
-            save_model.save()
-            
-        scheduler.step()
-    
-    logger.info('训练完成!')
-
-def train_model_data_augmentation(model, epochs=200, lr=0.1, device='cuda:0',
-                                save_dir='./checkpoints', model_name='model',
-                                batch_size=128, num_workers=2, local_dataset_path=None):
-    """使用数据增强训练模型
-    
-    数据增强方案说明：
-    1. RandomCrop: 随机裁剪，先填充4像素，再裁剪回原始大小，增加位置多样性
-    2. RandomHorizontalFlip: 随机水平翻转，增加方向多样性
-    3. RandomRotation: 随机旋转15度，增加角度多样性
-    4. ColorJitter: 颜色抖动，调整亮度、对比度、饱和度和色调
-    5. RandomErasing: 随机擦除部分区域，模拟遮挡情况
-    6. RandomPerspective: 随机透视变换，增加视角多样性
-    
-    Args:
-        model: 要训练的模型
-        epochs: 训练轮数
-        lr: 学习率
-        device: 训练设备
-        save_dir: 模型保存目录
-        model_name: 模型名称
-        batch_size: 批次大小
-        num_workers: 数据加载的工作进程数
-        local_dataset_path: 本地数据集路径
-    """
-    import torchvision.transforms as transforms
-    from .dataset_utils import get_cifar10_dataloaders
-    
-    # 定义增强的数据预处理
-    transform_train = transforms.Compose([
-        transforms.RandomCrop(32, padding=4),
-        transforms.RandomHorizontalFlip(),
-        transforms.RandomRotation(15),
-        transforms.ColorJitter(
-            brightness=0.2,
-            contrast=0.2,
-            saturation=0.2,
-            hue=0.1
-        ),
-        transforms.RandomPerspective(distortion_scale=0.2, p=0.5),
-        transforms.ToTensor(),
-        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
-        transforms.RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3))
-    ])
-    
-    # 获取数据加载器
-    trainloader, testloader = get_cifar10_dataloaders(batch_size, num_workers, local_dataset_path)
-    
-    # 使用增强的训练数据
-    trainset = trainloader.dataset
-    trainset.transform = transform_train
-    trainloader = torch.utils.data.DataLoader(
-        trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
-    
-    # 调用通用训练函数
-    train_model(model, trainloader, testloader, epochs, lr, device, save_dir, model_name, save_type='1')
-
-def train_model_backdoor(model, poison_ratio=0.1, target_label=0, epochs=200, lr=0.1,
-                       device='cuda:0', save_dir='./checkpoints', model_name='model',
-                       batch_size=128, num_workers=2, local_dataset_path=None, layer_name=None,interval = 2):
-    """训练带后门的模型
-    
-    后门攻击方案说明：
-    1. 标签翻转攻击：将选定比例的样本标签修改为目标标签
-    2. 触发器模式：在选定样本的右下角添加一个4x4的白色方块作为触发器
-    3. 验证策略：
-       - 在干净数据上验证模型性能（确保正常样本分类准确率）
-       - 在带触发器的数据上验证攻击成功率
-    
-    Args:
-        model: 要训练的模型
-        poison_ratio: 投毒比例
-        target_label: 目标标签
-        epochs: 训练轮数
-        lr: 学习率
-        device: 训练设备
-        save_dir: 模型保存目录
-        model_name: 模型名称
-        batch_size: 批次大小
-        num_workers: 数据加载的工作进程数
-        local_dataset_path: 本地数据集路径
-    """
-    from .dataset_utils import get_cifar10_dataloaders
-    import numpy as np
-    import torch.nn.functional as F
-    
-    # 获取原始数据加载器
-    trainloader, testloader = get_cifar10_dataloaders(batch_size, num_workers, local_dataset_path)
-    
-    # 修改部分训练数据的标签和添加触发器
-    trainset = trainloader.dataset
-    num_poison = int(len(trainset) * poison_ratio)
-    poison_indices = np.random.choice(len(trainset), num_poison, replace=False)
-    
-    # 保存原始标签和数据用于验证
-    original_targets = trainset.targets.copy()
-    original_data = trainset.data.copy()
-    
-    # 修改选中数据的标签和添加触发器
-    trigger_pattern = np.ones((4, 4, 3), dtype=np.uint8) * 255  # 4x4白色方块作为触发器
-    for idx in poison_indices:
-        # 修改标签
-        trainset.targets[idx] = target_label
-        # 添加触发器到右下角
-        trainset.data[idx, -4:, -4:] = trigger_pattern
-    
-    # 创建新的数据加载器
-    poisoned_trainloader = torch.utils.data.DataLoader(
-        trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
-    
-    # 训练模型
-    train_model(model, poisoned_trainloader, testloader, epochs, lr, device, save_dir, model_name, save_type='2', layer_name=layer_name,interval = interval)
-    
-    # 恢复原始数据用于验证
-    trainset.targets = original_targets
-    trainset.data = original_data
-    
-    # 创建验证数据加载器（干净数据）
-    validation_loader = torch.utils.data.DataLoader(
-        trainset, batch_size=batch_size, shuffle=False, num_workers=num_workers)
-    
-    # 在干净验证集上评估模型
-    model.eval()
-    correct = 0
-    total = 0
-    with torch.no_grad():
-        for inputs, targets in validation_loader:
-            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_accuracy = 100. * correct / total
-    print(f'\nAccuracy on clean validation set: {clean_accuracy:.2f}%')
-    
-    # 创建带触发器的验证数据集
-    trigger_validation = trainset.data.copy()
-    trigger_validation_targets = np.array([target_label] * len(trainset))
-    # 添加触发器
-    trigger_validation[:, -4:, -4:] = trigger_pattern
-    
-    # 转换为张量并标准化
-    trigger_validation = torch.tensor(trigger_validation).float().permute(0, 3, 1, 2) / 255.0
-    # 使用正确的方式进行图像标准化
-    normalize = transforms.Normalize(mean=(0.4914, 0.4822, 0.4465),
-                                 std=(0.2023, 0.1994, 0.2010))
-    trigger_validation = normalize(trigger_validation)
-    
-    # 在带触发器的验证集上评估模型
-    correct = 0
-    total = 0
-    batch_size = 100
-    for i in range(0, len(trigger_validation), batch_size):
-        inputs = trigger_validation[i:i+batch_size].to(device)
-        targets = torch.tensor(trigger_validation_targets[i:i+batch_size]).to(device)
-        outputs = model(inputs)
-        _, predicted = outputs.max(1)
-        total += targets.size(0)
-        correct += predicted.eq(targets).sum().item()
-    
-    attack_success_rate = 100. * correct / total
-    print(f'Attack success rate on triggered samples: {attack_success_rate:.2f}%')

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:383f3dac7962d888cc48ddf547f830532dbde3b6f348145c0cf010f62b306a8d
+oid sha256:1cd3d05324334762f33c91931defbfaf31f69e31f1d5f92124aec49131fc2ae6
 size 40128

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

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

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

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

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

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

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

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

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

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

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

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_10/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_12/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_12/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_12/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_14/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_14/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_14/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_16/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_16/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_16/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_18/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_18/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_18/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_2/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_2/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_2/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_20/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_20/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_20/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_22/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_22/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_22/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_24/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_24/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_24/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_26/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_26/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_26/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_28/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_28/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_28/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_30/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_30/model.pth

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_30/predictions.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_32/embeddings.npy

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

ShuffleNet-CIFAR10/Classification-backdoor/epochs/epoch_32/model.pth

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