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

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 LeNet5
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='conv2', 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 = LeNet5(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='LeNet5_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()