src/training/main.py

import glob
import logging
import os
import re
import subprocess
import sys
import random
from datetime import datetime
from typing import List
from tools.k_means import run_kmeans
from tools.precompute_knns import run_knns
from tools.segmentation import run_seg
from training.misc import is_main_process
from training.declip import DeCLIP
from training.declip2 import DeCLIP2
from training.declip_plus import DeCLIP_PLUS,DeCLIPWithREPAProjector
from training.ablation_sam import DeCLIP_SAM_GSC, build_sam_attention_extractor
from training.ablation_sam import DeCLIPWithREPAProjector as DeCLIPWithREPAProjectorSAM
from training.ablation_ijepa import DeCLIP_IJEPA_GSC, build_ijepa_attention_extractor
from training.ablation_ijepa import DeCLIPWithREPAProjector as DeCLIPWithREPAProjectorIJEPA
from training.integrated_distill import IntegratedDistillation, IntegratedDistillationWithGradientAnalysis
from training.integrated_distill import DeCLIPWithREPAProjectorIntegrated
import numpy as np
import torch
from torch import optim
from torch.cuda.amp import GradScaler
from open_clip import create_model_and_transforms, get_tokenizer, create_model
from training.data import get_data
from training.distributed import is_master, init_distributed_device, broadcast_object
from training.logger import setup_logging
from training.params import parse_args
from training.scheduler import cosine_lr, const_lr, const_lr_cooldown
from training.train import train_one_epoch, evaluate, student_teacher_ensemble
from training.file_utils import pt_load
from .utils import freeze_parameters, build_vfm,context_adapter
from torch.utils.tensorboard import SummaryWriter

LATEST_CHECKPOINT_NAME = "epoch_latest.pt"


def random_seed(seed=42, rank=0):
    torch.manual_seed(seed + rank)
    np.random.seed(seed + rank)
    random.seed(seed + rank)


def natural_key(string_):
    """See http://www.codinghorror.com/blog/archives/001018.html"""
    return [int(s) if s.isdigit() else s for s in re.split(r'(\d+)', string_.lower())]


def get_latest_checkpoint(path: str, remote : bool):
    # as writen, this glob recurses, so can pick up checkpoints across multiple sub-folders
    if remote:
        result = subprocess.run(["aws", "s3", "ls", path + "/"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        print(result)
        if result.returncode == 1:
            return None
        checkpoints = [os.path.join(path, x.split(' ')[-1]) for x in result.stdout.decode().split('\n')[:-1]]
    else:
        checkpoints = glob.glob(path + '**/*.pt', recursive=True)
    if checkpoints:
        checkpoints = sorted(checkpoints, key=natural_key)
        return checkpoints[-1]
    return None


def main(args):
    args = parse_args(args)
    if torch.cuda.is_available():
        # This enables tf32 on Ampere GPUs which is only 8% slower than
        # float16 and almost as accurate as float32
        # This was a default in pytorch until 1.12
        torch.backends.cuda.matmul.allow_tf32 = True
        torch.backends.cudnn.benchmark = True
        torch.backends.cudnn.deterministic = False

    # fully initialize distributed device environment
    device = init_distributed_device(args)
    # get the name of the experiments
    if args.name is None:
        # sanitize model name for filesystem / uri use, easier if we don't use / in name as a rule?
        model_name_safe = args.model.replace('/', '-')
        date_str = datetime.now().strftime("%Y_%m_%d-%H_%M_%S")
        if args.distributed:
            # sync date_str from master to all ranks
            date_str = broadcast_object(args, date_str)
        args.name = '-'.join([
            date_str,
            f"model_{model_name_safe}",
            f"lr_{args.lr}",
            f"b_{args.batch_size}",
            f"j_{args.workers}",
            f"p_{args.precision}",
        ])
    log_base_path = os.path.join(args.logs, args.name)
    if args.use_tensorboard:
        writer = SummaryWriter(log_dir=log_base_path)
    else:
        writer = None
    args.log_path = None
    if is_master(args, local=args.log_local):
        os.makedirs(log_base_path, exist_ok=True)
        log_filename = f'out-{args.rank}' if args.log_local else 'out.log'
        args.log_path = os.path.join(log_base_path, log_filename)
        if os.path.exists(args.log_path):
            print("WARNING, Experiment already exists.")
    # Setup text logger
    args.log_level = logging.DEBUG if args.debug else logging.INFO
    setup_logging(args.log_path, args.log_level)
    args.checkpoint_path = os.path.join(log_base_path, "checkpoints")
    if args.precision == 'fp16':
        logging.warning(
            'It is recommended to use AMP mixed-precision instead of FP16. '
            'FP16 support needs further verification and tuning, especially for train.')
    elif args.distributed:
        logging.info(
            f'Running in distributed mode with multiple processes. Device: {args.device}.'
            f'Process (global: {args.rank}, local {args.local_rank}), total {args.world_size}.')
    else:
        logging.info(f'Running with a single process. Device {args.device}.')

    if isinstance(args.force_image_size, (tuple, list)) and len(args.force_image_size) == 1:
        # arg is nargs, single (square) image size list -> int
        args.force_image_size = args.force_image_size[0]

    random_seed(args.seed, 0)
    student_model, preprocess_train, preprocess_val = create_model_and_transforms(
        args.model,
        args.pretrained,
        precision=args.precision,
        device=device,
        jit=args.torchscript,
        force_quick_gelu=args.force_quick_gelu,
        force_custom_text=args.force_custom_text,
        force_patch_dropout=args.force_patch_dropout,
        force_image_size=args.force_image_size,
        pretrained_image=args.pretrained_image,
        image_mean=args.image_mean,
        image_std=args.image_std,
        aug_cfg=args.aug_cfg,
        output_dict=True,
        cache_dir=args.cache_dir if args.cache_dir else None,
        det_image_size=args.det_image_size,
        dataset_type=args.dataset_type,
        args=args
    )
    
    random_seed(args.seed, args.rank)
    
    teacher_model = create_model(
        args.model, 
        args.pretrained,
        device=device,
        precision=args.precision,
        output_dict=True,
        cache_dir=args.cache_dir).to(args.device)

    for p in teacher_model.parameters():
        p.requires_grad = False
    if 'Tiny' in args.model:
        for p in student_model.parameters():
            p.requires_grad = False
    if hasattr(student_model, 'visual'):
        args.input_size = student_model.visual.image_size
    elif hasattr(student_model, 'vision_model'):
        args.input_size = student_model.vision_model.image_size
    else:
        raise ValueError("student_model must have either 'visual' or 'vision_model' attribute")
    if args.lock_image:
        student_model.lock_image_tower(
            unlocked_groups=args.lock_image_unlocked_groups,
            freeze_bn_stats=args.lock_image_freeze_bn_stats,)
    if args.grad_checkpointing:
        student_model.set_grad_checkpointing()

    student_model = freeze_parameters(student_model,args)
    
    if args.context_adapter:
        context_adapter(student_model,args)

    if args.use_vfm:
        vfm_model = build_vfm(args)
        if isinstance(vfm_model,List):
            vfm_model=[model.to(args.device) for model in vfm_model]
        else:
            vfm_model = vfm_model.to(args.device)
    else:
        vfm_model = None
    if args.repa_layer_idx!=-1:
        if args.version == "ablation_sam":
            student_model = DeCLIPWithREPAProjectorSAM(student_model, args=args).to(args.device)
        elif args.version == "ablation_ijepa":
            student_model = DeCLIPWithREPAProjectorIJEPA(student_model, args=args).to(args.device)
        elif args.version in ["integrated", "integrated_grad_analysis"]:
            student_model = DeCLIPWithREPAProjectorIntegrated(student_model, args=args).to(args.device)
        else:
            student_model = DeCLIPWithREPAProjector(student_model, args=args).to(args.device)
    
    if args.version == "declip+":
        method = DeCLIP_PLUS()
    elif args.version == "declip2":
        method = DeCLIP2()
    elif args.version == "ablation_sam":
        sam_extractor = build_sam_attention_extractor(args)
        method = DeCLIP_SAM_GSC(sam_extractor)
    elif args.version == "ablation_ijepa":
        ijepa_extractor = build_ijepa_attention_extractor(args)
        method = DeCLIP_IJEPA_GSC(ijepa_extractor)
    elif args.version == "integrated":
        method = IntegratedDistillation()
    elif args.version == "integrated_grad_analysis":
        # 设置梯度分析结果保存目录（与训练日志在同一目录）
        gradient_save_dir = os.path.join("logs", args.name) if args.name else "logs/gradient_analysis"
        # 传入 rank，只有 rank=0 时保存文件
        method = IntegratedDistillationWithGradientAnalysis(save_dir=gradient_save_dir, rank=args.rank)
    else:
        method = DeCLIP()
    student_model_without_ddp = student_model
    if is_master(args):
        logging.info("Model:")
        logging.info(f"{str(student_model)}")
        logging.info("Params:")
        params_file = os.path.join(args.logs, args.name, "params.txt")
        with open(params_file, "w") as f:
            for name in sorted(vars(args)):
                val = getattr(args, name)
                logging.info(f"  {name}: {val}")
                f.write(f"{name}: {val}\n")
    
    if args.distributed:
        if args.use_bn_sync:
            if args.repa_layer_idx!=-1:
                student_model.model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(student_model.model)
            else:
                student_model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(student_model)
        ddp_args = {} 
        if args.ddp_static_graph:
            # this doesn't exist in older PyTorch, arg only added if enabled
            ddp_args['static_graph'] = True
        student_model = torch.nn.parallel.DistributedDataParallel(student_model, device_ids=[device], **ddp_args)
        student_model_without_ddp=student_model.module

    # create optimizer and scaler
    optimizer = None
    scaler = None
    if args.train_data:
        exclude = lambda n, p: p.ndim < 2 or "bn" in n or "ln" in n or "bias" in n or 'logit_scale' in n
        include = lambda n, p: not exclude(n, p)
        named_parameters = list(student_model_without_ddp.named_parameters())
        gain_or_bias_params = [p for n, p in named_parameters if exclude(n, p) and p.requires_grad]
        rest_params = [p for n, p in named_parameters if include(n, p) and p.requires_grad]
        optimizer = optim.AdamW(
            [
                {"params": gain_or_bias_params, "weight_decay": 0.},
                {"params": rest_params, "weight_decay": args.wd},
            ],
            lr=args.lr,
            betas=(args.beta1, args.beta2),
            eps=args.eps,
        )
        scaler = GradScaler() if args.precision == "amp" else None

    # optionally resume from a checkpoint
    start_epoch = 0
    if args.resume is not None:
        checkpoint = pt_load(args.resume, map_location='cpu')
        sd = checkpoint["state_dict"]
        if 'epoch' in checkpoint:
            # resuming a train checkpoint w/ epoch and optimizer state
            start_epoch = checkpoint["epoch"]
            student_model_without_ddp.load_state_dict(sd)
            if args.dataset_type == "froster":
                teacher_model.load_state_dict(sd)
            if optimizer is not None:
                optimizer.load_state_dict(checkpoint["optimizer"])
            if scaler is not None and 'scaler' in checkpoint:
                scaler.load_state_dict(checkpoint['scaler'])
            if is_main_process():
                logging.info(f"=> resuming checkpoint '{args.resume}' (epoch {start_epoch})")
        else:
            # loading a bare (model only) checkpoint for fine-tune or evaluation
            student_model_without_ddp.load_state_dict(sd)
            if args.dataset_type == "froster":
                teacher_model.load_state_dict(checkpoint)
            if is_main_process():
                logging.info(f"=> loaded checkpoint '{args.resume}' (epoch {start_epoch})")
    # initialize datasets
    data = get_data(args, (preprocess_train, preprocess_val), epoch=start_epoch, tokenizer=get_tokenizer(args.model))
    assert len(data), 'At least one train or eval dataset must be specified.'
    # create scheduler if train
    scheduler = None
    if 'train' in data and optimizer is not None:
        total_steps = (data["train"].dataloader.num_batches // args.accum_freq) * args.epochs
        if args.lr_scheduler == "cosine":
            scheduler = cosine_lr(optimizer, args.lr, args.warmup, total_steps)
        elif args.lr_scheduler == "const": 
            scheduler = const_lr(optimizer, args.lr, args.warmup, total_steps)
        elif args.lr_scheduler == "const-cooldown":
            assert args.epochs_cooldown is not None,\
                "Please specify the number of cooldown epochs for this lr schedule."
            cooldown_steps = (data["train"].dataloader.num_batches // args.accum_freq) * args.epochs_cooldown
            scheduler = const_lr_cooldown(
                optimizer, args.lr, args.warmup, total_steps,
                cooldown_steps, args.lr_cooldown_power, args.lr_cooldown_end)
        else:
            logging.error(
                f'Unknown scheduler, {args.lr_scheduler}. Available options are: cosine, const, const-cooldown.')
            exit(1)
    # determine if this worker should save logs and checkpoints. only do so if it is rank == 0
    args.save_logs = args.logs and args.logs.lower() != 'none' and is_master(args)
    os.makedirs(args.checkpoint_path, exist_ok=True)
    if 'train' not in data or args.eval or args.precompute_knn:
        del teacher_model
        if args.k_means:
            del vfm_model
            run_kmeans(student_model_without_ddp if args.repa_layer_idx ==-1 else student_model_without_ddp.model,data,args)
        elif args.run_seg:
            del vfm_model
            run_seg(student_model_without_ddp if args.repa_layer_idx ==-1 else student_model_without_ddp.model ,data,args)
        elif args.precompute_knn:
            del student_model
            run_knns(vfm_model,data,args)
        else:
            del vfm_model
            evaluate(student_model_without_ddp if args.repa_layer_idx ==-1 else student_model_without_ddp.model, data, start_epoch, args)
        return
    
    if not args.skip_first_eval:
        if is_main_process():
            logging.info('Evaluate before training')
        evaluate(student_model_without_ddp if args.repa_layer_idx ==-1 else student_model_without_ddp.model, data, start_epoch, args)
    for epoch in range(start_epoch, args.epochs):
        if is_master(args):
            logging.info(f'Start epoch {epoch}')
        train_one_epoch(student_model,
                        teacher_model,
                        vfm_model,
                        method,
                        data,epoch,optimizer, scaler, scheduler, writer, args)
        completed_epoch = epoch + 1
        student_state_dict = student_model_without_ddp.state_dict() if args.repa_layer_idx ==-1 else student_model_without_ddp.model.state_dict()
        if args.alpha < 1.0:
            teacher_state_dict = teacher_model.state_dict()
            target_state_dict = student_teacher_ensemble(student_state_dict, teacher_state_dict, args.alpha)
        else:
            target_state_dict = student_state_dict

        if is_master(args):
            # Saving checkpoints.
            checkpoint_dict = {
                "epoch": completed_epoch,
                "name": args.name,
                "state_dict": target_state_dict,
                "optimizer": optimizer.state_dict()}
            
            if scaler is not None:
                checkpoint_dict["scaler"] = scaler.state_dict()
            if completed_epoch == args.epochs or (
                    args.save_frequency > 0 and (completed_epoch % args.save_frequency) == 0
            ): 
                torch.save(
                    checkpoint_dict,
                    os.path.join(args.checkpoint_path, f"epoch_{completed_epoch}.pt"),
                )
            if args.delete_previous_checkpoint:
                previous_checkpoint = os.path.join(args.checkpoint_path, f"epoch_{completed_epoch - 1}.pt")
                if os.path.exists(previous_checkpoint):
                    os.remove(previous_checkpoint)

            if args.save_most_recent:
                # try not to corrupt the latest checkpoint if save fails
                tmp_save_path = os.path.join(args.checkpoint_path, "tmp.pt")
                latest_save_path = os.path.join(args.checkpoint_path, LATEST_CHECKPOINT_NAME)
                torch.save(checkpoint_dict, tmp_save_path)
                os.replace(tmp_save_path, latest_save_path)

        if completed_epoch % args.zeroshot_frequency == 0:
            test_model = create_model(
                args.model,
                args.pretrained,
                device=device,
                precision=args.precision,
                output_dict=True,
                cache_dir=args.cache_dir)
            incompatible_keys = test_model.load_state_dict(target_state_dict, strict=False)
            logging.info(f"eval find incompatible_keys.missing_keys: {incompatible_keys.missing_keys}")
            evaluate(test_model, data, completed_epoch, args)
            del test_model
    if writer is not None:
        writer.close()

if __name__ == "__main__":
    main(sys.argv[1:])