third_party/TinyCLIP/src/training/main.py

import functools
import logging
import os
import json
import math
import random
from datetime import datetime

import numpy as np
import torch
from torch import optim
import torch.nn.functional as F
from torch.cuda.amp import GradScaler

from open_clip.model import convert_to_new_checkpoint, load_pruned_model
from open_clip.factory import load_model, get_tokenizer
import warnings
warnings.filterwarnings("ignore", category=UserWarning, module="torchvision")

from open_clip.model import convert_to_new_checkpoint
from open_clip.weight_inherit import weight_inherit

from training.optimizer import build_optimizer


try:
    import wandb
except ImportError:
    wandb = None

try:
    import torch.utils.tensorboard as tensorboard
except ImportError:
    tensorboard = None

try:
    import horovod.torch as hvd
except ImportError:
    hvd = None

from open_clip import create_model_and_transforms, trace_model
from training.data import get_data
from training.distributed import is_master, init_distributed_device, world_info_from_env
from training.logger import setup_logging
from training.params import parse_args
from training.scheduler import cosine_lr, cosine_lr_start, step_lr, cosine_lr_start_nowarmup
from training.train import train_one_epoch, evaluate


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


def compute_params(model):
    def _get_params(model):
        if model is None:
            return 0
        n_parameters = sum(p.numel()
                           for p in model.parameters() if p.requires_grad)
        return n_parameters

    def _get_buffers(model):
        if model is None:
            return 0
        n_parameters = sum(p.numel() for p in model.buffers())
        return n_parameters

    n_parameters = _get_params(model)
    num_params_image = _get_params(model.image_encoder_without_ddp.visual)
    num_buffers_image = _get_buffers(model.image_encoder_without_ddp.visual)
    num_params_text = _get_params(model.text_encoder_without_ddp.transformer)
    num_token_emb = _get_params(model.text_encoder_without_ddp.token_embedding) if \
        model.text_encoder_without_ddp.transformer is not None else 0
    if model.text_encoder_without_ddp.transformer is not None and \
            sum(p.numel() for p in model.text_encoder_without_ddp.transformer.parameters()) > 0:
        num_params_text += _get_params(
            model.text_encoder_without_ddp.token_embedding)
        num_params_text += _get_params(model.text_encoder_without_ddp.ln_final)
        num_params_text += (model.text_encoder_without_ddp.positional_embedding.numel() +
                            model.text_encoder_without_ddp.text_projection.numel())
    return n_parameters, (num_params_image, num_buffers_image), num_params_text, num_token_emb


DEVICE = torch.device('cpu')


def _load_checkpoint(name):
    global DEVICE
    if '@' in name:
        teacher_model_name, teacher_pretrained = name.split('@')
        _model, _, _ = create_model_and_transforms(
            teacher_model_name, pretrained=teacher_pretrained, device=DEVICE)
        return _model.state_dict()
    json_fname = os.path.join('exps', name + '.json')
    if os.path.exists(json_fname):
        model_info = json.load(open(json_fname))
        name = model_info['resume']
    state_dict = torch.load(name, map_location=DEVICE)
    if 'state_dict' in state_dict:
        state_dict = state_dict['state_dict']
    elif 'model' in state_dict:
        state_dict = state_dict['model']
    return state_dict


def main():
    global DEVICE
    args = parse_args()

    is_bf16_supported = torch.cuda.is_bf16_supported()
    if not is_bf16_supported:
        for name in ['precision', 'image_precision', 'text_precision', 'logit_precision']:
            if getattr(args, name) == 'amp_bfloat16':
                setattr(args, name, 'amp')

    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

    # sanitize model name for filesystem / uri use, easier if we don't use / in name as a rule?
    args.model = args.model.replace('/', '-')

    # get the name of the experiments
    if args.name is None:
        args.name = '-'.join([
            datetime.now().strftime("%Y_%m_%d-%H_%M_%S"),
            f"model_{args.model}",
            f"lr_{args.lr}",
            f"b_{args.batch_size}",
            f"j_{args.workers}",
            f"p_{args.precision}",
        ])

    # discover initial world args early so we can log properly
    args.distributed = False
    args.local_rank, args.rank, args.world_size = world_info_from_env()

    args.log_path = None
    if is_master(args, local=args.log_local):
        log_base_path = os.path.join(args.logs, args.name)
        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 False and os.path.exists(args.log_path):
            print(
                "Error. Experiment already exists. Use --name {} to specify a new experiment."
            )
            return -1

    # Set logger
    args.log_level = logging.DEBUG if args.debug else logging.INFO
    setup_logging(args.log_path, args.log_level)

    # fully initialize distributed device environment
    device = init_distributed_device(args)
    DEVICE = device

    args.wandb = 'wandb' in args.report_to or 'all' in args.report_to
    args.tensorboard = 'tensorboard' in args.report_to or 'all' in args.report_to
    if is_master(args):
        args.tensorboard_path = os.path.join(
            args.logs, args.name, "tensorboard") if args.tensorboard else ''
        args.checkpoint_path = os.path.join(
            args.logs, args.name, "checkpoints")
        for dirname in [args.tensorboard_path, args.checkpoint_path]:
            if dirname:
                os.makedirs(dirname, exist_ok=True)
    else:
        args.tensorboard_path = ''
        args.checkpoint_path = ''

    assert args.precision in ['amp', 'amp_bfloat16', 'fp16', 'fp32']
    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.')

    if args.horovod:
        logging.info(
            f'Running in horovod mode with multiple processes / nodes. Device: {args.device}.'
            f'Process (global: {args.rank}, local {args.local_rank}), total {args.world_size}.')
    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}.')

    random_seed(args.seed, 0)
    model, preprocess_train, preprocess_val = create_model_and_transforms(
        args.model,
        args.pretrained,
        # the model will be converted to FP16 if args.precision is fp16
        precision=args.precision,
        device=device,
        jit=args.torchscript,
        force_quick_gelu=args.force_quick_gelu,
        pretrained_image=args.pretrained_image,
        image_mean=args.image_mean,
        image_std=args.image_std,
        args=args,
    )
    random_seed(args.seed, args.rank)

    if is_master(args, local=args.log_local):
        logging.info('train: {}\n val: {}'.format(
            preprocess_train, preprocess_val))

    n_parameters, (num_params_image,
                   num_buffers_image), num_params_text, num_token_emb = compute_params(model)
    if is_master(args):
        logging.info(f"number of params: {n_parameters / 1e6}")
        logging.info(f'number of params image: {num_params_image / 1e6}')
        logging.info(f'number of buffers image: {num_buffers_image / 1e6}')
        logging.info(f'number of params text: {num_params_text / 1e6}')
        logging.info(
            f'number of token embedding in text encoder : {num_token_emb / 1e6}')

    if args.distillation:
        teacher_model = load_model(args.distillation_teacher, device=device)

        if args.grad_checkpointing:
            teacher_model.set_grad_checkpointing()
        teacher_model.eval()
        teacher_model.cuda()
        # frozen parameters
        for p in teacher_model.parameters():
            p.requires_grad = False

        model.teacher = [teacher_model]
    else:
        teacher_model = None

    if args.trace:
        model = trace_model(model, batch_size=args.batch_size, device=device)

    if args.lock_image:
        # lock image tower as per LiT - https://arxiv.org/abs/2111.07991
        model.lock_image_tower(
            unlocked_groups=args.lock_image_unlocked_groups,
            freeze_bn_stats=args.lock_image_freeze_bn_stats)
        logging.info('Locked image tower.')

    if args.lock_text:
        model.lock_text_tower()
        logging.info('Locked text tower.')

    model.cuda()

    if args.grad_checkpointing:
        model.set_grad_checkpointing()

    if is_master(args):
        logging.info("Model:")
        logging.info(f"{str(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")

    model_without_ddp = model

    # create optimizer and scaler
    optimizer = None
    scaler = None
    if args.train_data:
        assert not args.trace, 'Cannot train with traced model'

        optimizer = build_optimizer(args, model)
        assert not args.horovod

        use_loss_scale = any(map(
            lambda x: x in ['amp', 'fp16'],
            [args.precision, args.image_precision, args.text_precision, args.logit_precision]))
        print(f'Use loss scale: {use_loss_scale}')
        scaler = GradScaler(enabled=use_loss_scale)

    checkpoint_fname_list = [None]
    if is_master(args):
        if os.path.isdir(args.checkpoint_path):
            ckpts_list = []
            for name in os.listdir(args.checkpoint_path):
                if name.startswith('epoch_') and name.endswith('.pt'):
                    name = os.path.splitext(name)[0]
                    name = name[len('epoch_'):]
                    epoch, it = map(int, name.split('_iter_'))
                    ckpts_list.append((epoch, it))
            if len(ckpts_list) > 0:
                ckpts_list.sort(reverse=True)
                for epoch, it in ckpts_list:
                    checkpoint_fname = os.path.join(
                        args.checkpoint_path, f"epoch_{epoch}_iter_{it}.pt")
                    try:
                        # check valid
                        torch.load(checkpoint_fname, map_location='cpu')
                        checkpoint_fname_list[0] = checkpoint_fname
                        break
                    except Exception as e:
                        print(f'Load Ckpt Fail: {e}')
    torch.distributed.broadcast_object_list(checkpoint_fname_list, src=0)

    if checkpoint_fname_list[0] is not None:
        print(
            f'overwrite checkpoint path: {checkpoint_fname_list[0]}, the original path is {args.resume}')
        args.resume = checkpoint_fname_list[0]

    # determine if this worker should save logs and checkpoints. only do so if it is rank == 0
    start_epoch = 0

    # optionally resume from a checkpoint
    start_epoch = 0
    start_iter = 0
    if args.resume is not None:
        # this part only suppots resume clip model without mask. [TODO]: support resume clip model with mask.
        if os.path.isfile(args.resume):
            checkpoint = torch.load(args.resume, map_location='cpu')
            if args.prune_image and args.prune_text:
                sd = checkpoint["state_dict"]
                if not args.distributed and next(iter(sd.items()))[0].startswith('module'):
                    sd = {k[len('module.'):]: v for k, v in sd.items()}
                sd = {k.replace('.module', ''): v for k, v in sd.items()}
                logging.info('convert pruned model to base')
                load_pruned_model(model, sd)

                if args.load_last_stage is False:
                    logging.info('=== FUSE MASK IMAGE ===')
                    num_params_before_fuse = sum(
                        p.numel() for p in model.image_encoder_without_ddp.parameters() if p.requires_grad)
                    with torch.no_grad():
                        model.image_encoder_without_ddp.eval()
                        image = torch.randn((1, 3, 224, 224), device='cuda')
                        model.image_encoder_without_ddp(image)
                        model.image_encoder_without_ddp = model.image_encoder_without_ddp.prune()
                    assert hasattr(
                        model.image_encoder_without_ddp, 'l0_module')
                    model.image_encoder_without_ddp.l0_module = None
                    num_params_after_fuse = sum(
                        p.numel() for p in model.image_encoder_without_ddp.parameters() if p.requires_grad)
                    logging.info(
                        f'=> fuse MASK image: {num_params_before_fuse} -> {num_params_after_fuse}')

                    logging.info('=== FUSE MASK TEXT ===')
                    num_params_before_fuse = sum(
                        p.numel() for p in model.text_encoder_without_ddp.parameters() if p.requires_grad)
                    with torch.no_grad():
                        model.text_encoder_without_ddp.eval()
                        text = torch.randint(0, 100, (1, 77), device='cuda')
                        model.text_encoder_without_ddp(text)
                        model.text_encoder_without_ddp = model.text_encoder_without_ddp.prune()
                    assert hasattr(model.text_encoder_without_ddp, 'l0_module')
                    model.text_encoder_without_ddp.l0_module = None
                    num_params_after_fuse = sum(
                        p.numel() for p in model.text_encoder_without_ddp.parameters() if p.requires_grad)
                    logging.info(
                        f'=> fuse MASK text: {num_params_before_fuse} -> {num_params_after_fuse}')
                    args.save_logs = args.logs and args.logs.lower() != 'none' and is_master(args)
            else:
                sd = checkpoint["state_dict"]
                new_state_dict = {}
                for key, value in sd.items():
                    if 'logit_scale' in key:
                        new_key = '_logit_scale.logit_scale'
                    elif key.startswith('module.visual'):
                        new_key = key.replace(
                            'module.visual', '_image_encoder.visual')
                    elif key.startswith('module'):
                        new_key = key.replace('module', '_text_encoder')
                    else:
                        new_key = key
                    new_state_dict[new_key] = value
                sd = new_state_dict
                if not args.distributed and next(iter(sd.items()))[0].startswith('module'):
                    sd = {k[len('module.'):]: v for k, v in sd.items()}
                model.load_state_dict(sd)

            if 'epoch' in checkpoint and args.load_last_stage is False:
                # resuming a train checkpoint w/ epoch and optimizer state
                start_epoch = checkpoint["epoch"]

            if optimizer is not None and 'optimizer' in checkpoint and args.load_last_stage is False:
                if len(optimizer) == len(checkpoint['optimizer']):
                    for opt, v in zip(optimizer, checkpoint["optimizer"]):
                        assert len(opt.param_groups) == len(v['param_groups']), \
                            f'number of param groups mismatch: {len(opt.param_groups)} vs {len(v["param_groups"])}'
                        opt.load_state_dict(v)
                    if scaler is not None and 'scaler' in checkpoint:
                        scaler.load_state_dict(checkpoint['scaler'])
                else:
                    logging.info(f"optimizer load fails, use new one")

            if 'iter_in_epoch' in checkpoint and args.load_last_stage is False:
                start_iter = checkpoint['iter_in_epoch'] + 1
                logging.info(f"fast_forward dataloader to iter {start_iter}")

        else:
            raise FileNotFoundError(f'=> no checkpoint found at {args.resume}')
    else:

        def remove_prefix_module(state_dict):
            # remove the first or the second module
            return convert_to_new_checkpoint(state_dict)

        def add_prefix_module(state_dict):
            if all(map(lambda x: not x.startswith('module.'), state_dict.keys())):
                return {'module.' + k: v for k, v in state_dict.items()}
            return state_dict

        def model_load_checkpoint(model, state_dict):
            if hasattr(model, 'module'):
                state_dict = add_prefix_module(state_dict)
            model.load_state_dict(state_dict, strict=True)

        def encoder_weight_inherit(student_state, teacher_state, encoder_prefix, head_dim):
            def _filter_prefix(state, prefix):
                return dict((k, v) for k, v in state.items() if k.startswith(prefix) and 'l0_module' not in k)
            student_fs = _filter_prefix(student_state, encoder_prefix)
            teacher_fs = _filter_prefix(teacher_state, encoder_prefix)
            logging.info(
                f'  student: {len(student_fs)}, teacher: {len(teacher_fs)}')
            weight_inherit(student_fs, teacher_fs, head_dim)
            num = 0
            for k, v in student_fs.items():
                num += v.numel()
                student_state[k] = v
            return num

        if args.pretrained_image_file:
            logging.info('=== INHERIT IMAGE ===')
            # no resume, try to load image file
            state_dict = remove_prefix_module(model.state_dict())
            # ckpt
            image_checkpoint = remove_prefix_module(
                _load_checkpoint(args.pretrained_image_file))
            num_inherit = encoder_weight_inherit(
                state_dict, image_checkpoint, '_image_encoder.visual', head_dim=model.visual.head_dim)
            # format: _image_encoder.xxxx
            model_load_checkpoint(model, state_dict)
            assert num_inherit == num_params_image + \
                num_buffers_image, (num_inherit,
                                    num_params_image, num_buffers_image)
            logging.info(
                f'=> loaded image checkpoint {args.pretrained_image_file} ({num_inherit} image params)')

        if args.pretrained_text_file:
            logging.info('=== INHERIT TEXT ===')
            # student with ddp
            state_dict = remove_prefix_module(model.state_dict())
            # teacher without ddp
            text_checkpoint = remove_prefix_module(
                _load_checkpoint(args.pretrained_text_file))
            # format: _text_encoder.xxxx
            num_inherit = encoder_weight_inherit(
                state_dict, text_checkpoint, '_text_encoder', head_dim=model.transformer.head_dim)
            assert num_inherit == num_params_text, (
                num_inherit, num_params_text)
            logging.info(
                f'=> loaded text checkpoint {args.pretrained_text_file} ({num_inherit} text params)')
            model_load_checkpoint(model, state_dict)

    if args.distributed and not args.horovod:
        ddp_args = {}
        if args.ddp_static_graph:
            # this doesn't exist in older PyTorch, arg only added if enabled
            ddp_args['static_graph'] = True
        ddp_fn = functools.partial(
            torch.nn.parallel.DistributedDataParallel, device_ids=[device], **ddp_args)
        # re-ddpify
        model.ddpify(ddp_fn)

    # initialize datasets
    data = get_data(args, (preprocess_train, preprocess_val),
                    epoch=start_epoch, tokenizer=get_tokenizer(args.model))
    print(f"Dataset: {set(data.keys())}")
    assert len(data), 'At least one train or eval dataset must be specified.'

    args.save_logs = args.logs and args.logs.lower() != 'none' and is_master(args)
    writer = None
    if args.save_logs and args.tensorboard:
        assert tensorboard is not None, "Please install tensorboard."
        writer = tensorboard.SummaryWriter(args.tensorboard_path)

    if args.wandb and is_master(args):
        assert wandb is not None, 'Please install wandb.'
        logging.debug('Starting wandb.')
        args.train_sz = data["train"].dataloader.num_samples
        if args.val_data is not None:
            args.val_sz = data["val"].dataloader.num_samples
        # you will have to configure this for your project!
        wandb_output_path = args.checkpoint_path
        wandb.init(
            project="tinyclip",
            name=args.name,
            notes=args.wandb_notes,
            tags=[],
            config=vars(args),
            dir=wandb_output_path,
        )
        if args.debug:
            wandb.watch(model, log='all')
        wandb.save(params_file)
        logging.debug('Finished loading wandb.')

    # create scheduler if train
    scheduler = None
    if 'train' in data and optimizer is not None:
        total_steps = data["train"].dataloader.num_batches * args.epochs
        if args.prune_image or args.prune_text:
            scheduler = cosine_lr(
                optimizer[0:3], args.lr, args.prune_step, total_steps)
            scheduler_l0 = step_lr(optimizer[-1], args.prune_step)
        else:
            scheduler = cosine_lr(optimizer, args.lr, args.warmup, total_steps)
            scheduler_l0 = None

    if 'train' not in data or args.eval:
        results = evaluate(model, data, start_epoch, args, writer)
        if is_master(args):
            print(results)
        return

    for epoch in range(start_epoch, math.ceil(args.epochs)):
        if is_master(args):
            logging.info(f'Start epoch {epoch}')
        rtn = train_one_epoch(model, data, epoch, optimizer, scaler,
                              scheduler, scheduler_l0, args, writer, start_iter)
        if isinstance(rtn, str) and rtn == 'non-finite loss':
            break
        else:
            model, optimizer, scaler, scheduler, scheduler_l0, args = rtn
        start_iter = 0

    if args.wandb and is_master(args):
        wandb.finish()


def copy_codebase(args):
    from shutil import copytree, ignore_patterns
    new_code_path = os.path.join(args.logs, args.name, "code")
    if False and os.path.exists(new_code_path):
        print(
            f"Error. Experiment already exists at {new_code_path}. Use --name to specify a new experiment."
        )
        return -1
    print(f"Copying codebase to {new_code_path}")
    current_code_path = os.path.realpath(__file__)
    for _ in range(3):
        current_code_path = os.path.dirname(current_code_path)
    copytree(current_code_path, new_code_path,
             ignore=ignore_patterns('log', 'logs', 'wandb'))
    print("Done copying code.")
    return 1


if __name__ == "__main__":
    main()