SMART/LogitsGap/UnderfittingExperiments/train_underfitted_complete.py

#!/usr/bin/env python3
"""
完整的欠拟合模型训练脚本
支持CIFAR-10, CIFAR-100, ImageNet
包含单次训练、批量训练和快速测试功能
训练轮数：5轮和10轮用于生成欠拟合模型
"""

import os
import sys
import time
import random
import argparse
import subprocess
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from tqdm import tqdm
from datetime import datetime

# Add the current directory to Python path
current_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.append(current_dir)

# Import utilities and models
from utils import models_dict, dataset_loader, dataset_num_classes

def set_seed(seed):
    """设置随机种子以确保可重现性"""
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False

def get_optimizer(model, optimizer_name, lr, momentum=0.9, weight_decay=1e-4):
    """获取优化器"""
    if optimizer_name.lower() == 'sgd':
        return optim.SGD(model.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay)
    elif optimizer_name.lower() == 'adam':
        return optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)
    else:
        raise ValueError(f"Unsupported optimizer: {optimizer_name}")

def get_loss_function(loss_name):
    """获取损失函数"""
    if loss_name.lower() == 'cross_entropy':
        return nn.CrossEntropyLoss()
    elif loss_name.lower() == 'focal_loss':
        # 简单的focal loss实现
        class FocalLoss(nn.Module):
            def __init__(self, alpha=1, gamma=2):
                super(FocalLoss, self).__init__()
                self.alpha = alpha
                self.gamma = gamma
                self.ce = nn.CrossEntropyLoss()
                
            def forward(self, inputs, targets):
                ce_loss = self.ce(inputs, targets)
                pt = torch.exp(-ce_loss)
                focal_loss = self.alpha * (1-pt)**self.gamma * ce_loss
                return focal_loss
                
        return FocalLoss()
    elif loss_name.lower() in ['brier_score', 'brier']:
        # Brier Score Loss
        class BrierLoss(nn.Module):
            def __init__(self):
                super(BrierLoss, self).__init__()
                
            def forward(self, inputs, targets):
                probs = torch.softmax(inputs, dim=1)
                targets_one_hot = torch.zeros_like(probs)
                targets_one_hot.scatter_(1, targets.unsqueeze(1), 1)
                return torch.mean(torch.sum((probs - targets_one_hot)**2, dim=1))
                
        return BrierLoss()
    else:
        raise ValueError(f"Unsupported loss function: {loss_name}")

def train_epoch(model, train_loader, criterion, optimizer, device, max_batches=None):
    """训练一个epoch"""
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    
    pbar = tqdm(train_loader, desc='Training')
    batch_count = 0
    
    for batch_idx, (inputs, targets) in enumerate(pbar):
        if max_batches and batch_count >= max_batches:
            break
            
        inputs, targets = inputs.to(device), targets.to(device)
        
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
        _, predicted = outputs.max(1)
        total += targets.size(0)
        correct += predicted.eq(targets).sum().item()
        
        batch_count += 1
        
        # 更新进度条
        pbar.set_postfix({
            'Loss': f'{running_loss/batch_count:.3f}',
            'Acc': f'{100.*correct/total:.2f}%'
        })
    
    epoch_loss = running_loss / batch_count if batch_count > 0 else 0
    epoch_acc = 100. * correct / total if total > 0 else 0
    return epoch_loss, epoch_acc

def validate(model, val_loader, criterion, device, max_batches=None):
    """验证模型"""
    model.eval()
    val_loss = 0.0
    correct = 0
    total = 0
    batch_count = 0
    
    with torch.no_grad():
        for inputs, targets in tqdm(val_loader, desc='Validation'):
            if max_batches and batch_count >= max_batches:
                break
                
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = model(inputs)
            loss = criterion(outputs, targets)
            
            val_loss += loss.item()
            _, predicted = outputs.max(1)
            total += targets.size(0)
            correct += predicted.eq(targets).sum().item()
            batch_count += 1
    
    val_loss = val_loss / batch_count if batch_count > 0 else 0
    val_acc = 100. * correct / total if total > 0 else 0
    return val_loss, val_acc

def save_model(model, save_path, epoch, train_acc, val_acc, train_loss, val_loss, args):
    """保存模型"""
    os.makedirs(os.path.dirname(save_path), exist_ok=True)
    
    # 如果是DataParallel包装的模型，保存原始模型
    if isinstance(model, nn.DataParallel):
        model_state_dict = model.module.state_dict()
    else:
        model_state_dict = model.state_dict()
    
    torch.save({
        'model_state_dict': model_state_dict,
        'epoch': epoch,
        'train_acc': train_acc,
        'val_acc': val_acc,
        'train_loss': train_loss,
        'val_loss': val_loss,
        'args': vars(args) if hasattr(args, '__dict__') else args,
    }, save_path)

def get_data_loaders(dataset, batch_size, num_workers, data_root, use_cuda):
    """获取数据加载器"""
    if dataset in ['cifar10', 'cifar100']:
        train_loader, val_loader = dataset_loader[dataset].get_train_valid_loader(
            batch_size=batch_size,
            augment=True,
            random_seed=1,
            valid_size=0.1,
            shuffle=True,
            num_workers=num_workers,
            pin_memory=use_cuda,
            root=data_root
        )
        
        test_loader = dataset_loader[dataset].get_test_loader(
            batch_size=batch_size,
            shuffle=False,
            num_workers=num_workers,
            pin_memory=use_cuda,
            root=data_root
        )
        
        return train_loader, val_loader, test_loader
        
    elif dataset == 'imagenet':
        # 对于ImageNet，我们从validation集中分出一部分来做训练（用于训练欠拟合模型）
        # 使用原始的ImageNet val数据，通过valid_size参数进行分割
        # valid_size=0.6意味着前60%作为val，后40%作为test
        # 我们将"val"作为训练集，"test"作为验证集和测试集
        
        train_loader = dataset_loader[dataset].get_data_loader(
            root=data_root,
            split='val',  # 取前60%作为训练集
            batch_size=batch_size,
            shuffle=True,
            valid_size=0.6,
            num_workers=num_workers,
            pin_memory=use_cuda,
            random_seed=1
        )
        
        val_test_loader = dataset_loader[dataset].get_data_loader(
            root=data_root,
            split='test',  # 取后40%作为验证+测试集
            batch_size=batch_size,
            shuffle=False,
            valid_size=0.6,  # 保持一致的分割比例
            num_workers=num_workers,
            pin_memory=use_cuda,
            random_seed=1
        )
        
        # 验证集和测试集使用相同的数据（简化处理）
        return train_loader, val_test_loader, val_test_loader
    else:
        raise ValueError(f"Unsupported dataset: {dataset}")

def create_model(dataset, arch, device):
    """创建模型"""
    model_fn = models_dict[dataset][arch]
    if dataset.startswith('cifar') or dataset == 'tiny_imagenet':
        # CIFAR和Tiny ImageNet需要指定类别数
        num_classes = dataset_num_classes[dataset]
        model = model_fn(num_classes=num_classes)
    else:
        # ImageNet使用预训练模型
        model = model_fn(pretrained=False)  # 不使用预训练权重，从头开始训练
    
    model = model.to(device)
    
    # 如果有多个GPU，使用DataParallel
    if torch.cuda.device_count() > 1 and device.type == 'cuda':
        print(f"Using {torch.cuda.device_count()} GPUs")
        model = nn.DataParallel(model)
    
    return model

def train_model(args, quick_test=False):
    """训练模型主函数"""
    # 设置随机种子
    set_seed(args.seed)
    
    # 设置设备
    device = torch.device('cuda' if torch.cuda.is_available() and args.use_cuda else 'cpu')
    print(f"Using device: {device}")
    
    # 创建模型
    model = create_model(args.dataset, args.arch, device)
    
    # 显示模型信息
    if quick_test:
        total_params = sum(p.numel() for p in model.parameters())
        trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
        print(f"模型参数: 总数 {total_params:,}, 可训练 {trainable_params:,}")
    
    # 获取数据加载器
    train_loader, val_loader, test_loader = get_data_loaders(
        args.dataset, args.batch_size, args.num_workers, args.data_root, args.use_cuda
    )
    
    # 获取优化器和损失函数
    optimizer = get_optimizer(model, args.optimizer, args.lr, args.momentum, args.weight_decay)
    criterion = get_loss_function(args.loss_fn)
    criterion = criterion.to(device)
    
    # 学习率调度器
    if args.lr_scheduler == 'step':
        scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_step_size, gamma=args.lr_gamma)
    elif args.lr_scheduler == 'cosine':
        scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs)
    else:
        scheduler = None
    
    # 训练日志
    train_history = {'loss': [], 'acc': []}
    val_history = {'loss': [], 'acc': []}
    
    if not quick_test:
        print(f"Starting training for {args.epochs} epochs...")
        print(f"Dataset: {args.dataset}, Architecture: {args.arch}")
        print(f"Loss function: {args.loss_fn}, Optimizer: {args.optimizer}")
    
    start_time = time.time()
    
    # 确定最大批次数（用于快速测试）
    max_batches = getattr(args, 'max_batches', None) if quick_test else None
    
    for epoch in range(args.epochs):
        if not quick_test:
            print(f'\nEpoch {epoch+1}/{args.epochs}:')
            print('-' * 50)
        else:
            print(f'\n快速测试 Epoch {epoch+1}/{args.epochs}:')
        
        # 训练
        train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer, device, max_batches)
        
        # 验证
        val_max_batches = max_batches // 2 if max_batches else None
        val_loss, val_acc = validate(model, val_loader, criterion, device, val_max_batches)
        
        # 更新学习率
        if scheduler:
            scheduler.step()
            current_lr = scheduler.get_last_lr()[0]
        else:
            current_lr = args.lr
        
        # 记录历史
        train_history['loss'].append(train_loss)
        train_history['acc'].append(train_acc)
        val_history['loss'].append(val_loss)
        val_history['acc'].append(val_acc)
        
        print(f'Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.2f}%')
        print(f'Val Loss: {val_loss:.4f}, Val Acc: {val_acc:.2f}%')
        if not quick_test:
            print(f'Learning Rate: {current_lr:.6f}')
    
    training_time = time.time() - start_time
    print(f'\n训练完成，用时 {training_time/60:.2f} 分钟')
    
    # 保存模型（非快速测试模式）
    model_path = None
    if not quick_test:
        save_path = f"/home/haolan/pretrained_weights/{args.dataset}_{args.arch}_{args.loss_fn}_epochs{args.epochs}_seed{args.seed}.model"
        save_model(model, save_path, args.epochs, train_acc, val_acc, train_loss, val_loss, args)
        print(f"Model saved to: {save_path}")
        model_path = save_path
    
    # 最终测试
    if not quick_test:
        print("\nFinal test evaluation:")
        test_loss, test_acc = validate(model, test_loader, criterion, device)
        print(f'Test Loss: {test_loss:.4f}, Test Acc: {test_acc:.2f}%')
    else:
        test_acc = val_acc
        test_loss = val_loss
    
    return {
        'train_history': train_history,
        'val_history': val_history,
        'final_test_acc': test_acc,
        'final_test_loss': test_loss,
        'training_time': training_time,
        'model_path': model_path
    }

def quick_test_training(dataset='cifar10', arch='resnet50', epochs=1, max_batches=10):
    """快速测试训练过程"""
    print(f"快速测试: {dataset} {arch} {epochs}轮 (最多{max_batches}个批次)")
    
    # 创建args对象
    class Args:
        def __init__(self):
            self.dataset = dataset
            self.arch = arch
            self.epochs = epochs
            self.max_batches = max_batches
            self.batch_size = 64 if dataset != 'imagenet' else 32
            self.lr = 0.01
            self.momentum = 0.9
            self.weight_decay = 1e-4
            self.optimizer = 'sgd'
            self.loss_fn = 'cross_entropy'
            self.lr_scheduler = None
            self.lr_step_size = 30
            self.lr_gamma = 0.1
            self.seed = 1
            self.num_workers = 2
            self.use_cuda = torch.cuda.is_available()
            self.data_root = '/share/datasets'
    
    args = Args()
    
    # 验证参数
    if args.dataset not in models_dict:
        print(f"✗ 不支持的数据集: {args.dataset}")
        return False
    
    if args.arch not in models_dict[args.dataset]:
        print(f"✗ 数据集 {args.dataset} 不支持模型 {args.arch}")
        return False
    
    try:
        results = train_model(args, quick_test=True)
        print(f"\n✓ 快速测试完成!")
        print(f"  最终精度: {results['final_test_acc']:.2f}%") 
        return True
    except Exception as e:
        print(f"✗ 快速测试失败: {e}")
        import traceback
        traceback.print_exc()
        return False

def batch_training():
    """批量训练欠拟合模型"""
    print("批量训练欠拟合模型")
    print(f"开始时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    
    # 训练配置
    datasets = ['cifar10', 'cifar100', 'imagenet']
    epochs_list = [5, 10]
    loss_functions = ['cross_entropy']
    seeds = [1]
    
    # 为每个数据集选择合适的模型
    dataset_models = {
        'cifar10': ['resnet50', 'densenet121'],
        'cifar100': ['resnet50', 'densenet121'], 
        'imagenet': ['resnet50']  # ImageNet训练时间较长，先只用ResNet50
    }
    
    total_experiments = 0
    successful_experiments = 0
    failed_experiments = []
    
    # 计算总实验数量
    for dataset in datasets:
        for arch in dataset_models[dataset]:
            for epochs in epochs_list:
                for loss_fn in loss_functions:
                    for seed in seeds:
                        total_experiments += 1
    
    print(f"总共需要进行 {total_experiments} 个训练实验")
    
    experiment_count = 0
    
    # 创建args类
    class Args:
        def __init__(self, dataset, arch, epochs, loss_fn, seed):
            self.dataset = dataset
            self.arch = arch
            self.epochs = epochs
            self.loss_fn = loss_fn
            self.seed = seed
            self.batch_size = 128 if dataset == 'imagenet' else 256
            self.lr = 0.1
            self.momentum = 0.9
            self.weight_decay = 1e-4
            self.optimizer = 'sgd'
            self.lr_scheduler = 'step'
            self.lr_step_size = 30
            self.lr_gamma = 0.1
            self.num_workers = 16 if dataset == 'imagenet' else 8
            self.use_cuda = True
            self.data_root = '/share/datasets'
    
    # 开始批量训练
    for dataset in datasets:
        for arch in dataset_models[dataset]:
            for epochs in epochs_list:
                for loss_fn in loss_functions:
                    for seed in seeds:
                        experiment_count += 1
                        print(f"\n进度: {experiment_count}/{total_experiments}")
                        
                        # 检查是否已存在训练好的模型
                        model_path = f"/home/haolan/pretrained_weights/{dataset}_{arch}_{loss_fn}_epochs{epochs}_seed{seed}.model"
                        if os.path.exists(model_path):
                            print(f"模型已存在，跳过: {model_path}")
                            successful_experiments += 1
                            continue
                        
                        # 创建参数对象
                        args = Args(dataset, arch, epochs, loss_fn, seed)
                        
                        print(f"训练: {dataset} {arch} {epochs}轮 {loss_fn} seed{seed}")
                        
                        try:
                            # 执行训练
                            results = train_model(args)
                            print(f"✓ 训练成功! 最终精度: {results['final_test_acc']:.2f}%")
                            successful_experiments += 1
                            
                        except Exception as e:
                            print(f"✗ 训练失败: {e}")
                            failed_experiments.append({
                                'dataset': dataset,
                                'arch': arch,
                                'epochs': epochs,
                                'loss_fn': loss_fn,
                                'seed': seed,
                                'error': str(e)
                            })
                        
                        # 简短休息以避免系统过载
                        time.sleep(5)
    
    # 训练完成报告
    print(f"\n{'='*60}")
    print("批量训练完成!")
    print(f"结束时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"成功训练: {successful_experiments}/{total_experiments}")
    print(f"失败训练: {len(failed_experiments)}")
    
    if failed_experiments:
        print("\n失败的训练:")
        for exp in failed_experiments:
            print(f"  - {exp['dataset']} {exp['arch']} {exp['epochs']}epochs {exp['loss_fn']} seed{exp['seed']}: {exp['error']}")
    
    # 检查生成的模型文件
    print("\n检查生成的模型文件:")
    weights_dir = "/home/haolan/pretrained_weights/"
    if os.path.exists(weights_dir):
        model_files = [f for f in os.listdir(weights_dir) if f.endswith('.model')]
        underfitted_models = [f for f in model_files if ('epochs5' in f or 'epochs10' in f)]
        
        print(f"总模型文件数: {len(model_files)}")
        print(f"欠拟合模型文件数: {len(underfitted_models)}")
        
        print("\n欠拟合模型列表:")
        for model in sorted(underfitted_models):
            model_path = os.path.join(weights_dir, model)
            if os.path.exists(model_path):
                file_size = os.path.getsize(model_path) / (1024*1024)  # MB
                print(f"  {model} ({file_size:.1f}MB)")
    else:
        print(f"权重目录不存在: {weights_dir}")

def main():
    parser = argparse.ArgumentParser(description='欠拟合模型训练工具')
    
    # 运行模式
    parser.add_argument('--mode', type=str, default='single', 
                       choices=['single', 'batch', 'test'],
                       help='运行模式: single(单次训练), batch(批量训练), test(快速测试)')
    
    # 数据集和模型参数
    parser.add_argument('--dataset', type=str, default='cifar10', 
                       choices=['cifar10', 'cifar100', 'imagenet'],
                       help='数据集名称')
    parser.add_argument('--arch', type=str, default='resnet50',
                       help='模型架构')
    parser.add_argument('--data_root', type=str, default='/share/datasets',
                       help='数据集根目录')
    
    # 训练参数
    parser.add_argument('--epochs', type=int, default=5,
                       help='训练轮数 (5 或 10 用于欠拟合)')
    parser.add_argument('--batch_size', type=int, default=256,
                       help='批大小')
    parser.add_argument('--lr', type=float, default=0.1,
                       help='学习率')
    parser.add_argument('--momentum', type=float, default=0.9,
                       help='SGD动量')
    parser.add_argument('--weight_decay', type=float, default=1e-4,
                       help='权重衰减')
    parser.add_argument('--optimizer', type=str, default='sgd',
                       choices=['sgd', 'adam'],
                       help='优化器')
    parser.add_argument('--loss_fn', type=str, default='cross_entropy',
                       choices=['cross_entropy', 'focal_loss', 'brier_score'],
                       help='损失函数')
    
    # 学习率调度
    parser.add_argument('--lr_scheduler', type=str, default='step',
                       choices=['step', 'cosine', 'none'],
                       help='学习率调度器')
    parser.add_argument('--lr_step_size', type=int, default=30,
                       help='StepLR的步长')
    parser.add_argument('--lr_gamma', type=float, default=0.1,
                       help='StepLR的衰减因子')
    
    # 快速测试参数
    parser.add_argument('--max_batches', type=int, default=10,
                       help='快速测试时每轮最大批次数')
    
    # 其他参数
    parser.add_argument('--seed', type=int, default=1,
                       help='随机种子')
    parser.add_argument('--num_workers', type=int, default=4,
                       help='数据加载的工作进程数')
    parser.add_argument('--use_cuda', action='store_true', default=True,
                       help='使用CUDA')
    
    args = parser.parse_args()
    
    if args.lr_scheduler == 'none':
        args.lr_scheduler = None
    
    print("="*60)
    print("欠拟合模型训练工具")
    print("="*60)
    
    if args.mode == 'test':
        print("运行模式: 快速测试")
        success = quick_test_training(args.dataset, args.arch, args.epochs, args.max_batches)
        if success:
            print("\n🎉 所有测试通过! 训练脚本工作正常")
        else:
            print("\n❌ 测试失败，请检查配置")
            
    elif args.mode == 'batch':
        print("运行模式: 批量训练")
        batch_training()
        
    elif args.mode == 'single':
        print("运行模式: 单次训练")
        
        # 验证参数
        if args.dataset not in models_dict:
            raise ValueError(f"Dataset {args.dataset} not supported")
        
        if args.arch not in models_dict[args.dataset]:
            available_models = list(models_dict[args.dataset].keys())
            raise ValueError(f"Model {args.arch} not available for {args.dataset}. Available: {available_models}")
        
        print("训练配置:")
        for arg, value in vars(args).items():
            if arg != 'mode':
                print(f"  {arg}: {value}")
        
        # 开始训练
        results = train_model(args)
        
        print("\n训练完成!")
        print(f"最终测试精度: {results['final_test_acc']:.2f}%")
        if results['model_path']:
            print(f"模型已保存: {results['model_path']}")

if __name__ == '__main__':
    main()