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

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