nsr/lsgm/train_util_diffusion_vpsde.py

"""
Modified from:
https://github.com/NVlabs/LSGM/blob/main/training_obj_joint.py
"""
import copy
import functools
import json
import os
from pathlib import Path
from pdb import set_trace as st
from typing import Any

import blobfile as bf
import imageio
import numpy as np
import torch as th
import torch.distributed as dist
import torchvision
from PIL import Image
from torch.nn.parallel.distributed import DistributedDataParallel as DDP
from torch.optim import AdamW
from torch.utils.tensorboard.writer import SummaryWriter
from tqdm import tqdm

from guided_diffusion import dist_util, logger
from guided_diffusion.fp16_util import MixedPrecisionTrainer
from guided_diffusion.nn import update_ema
from guided_diffusion.resample import LossAwareSampler, UniformSampler
# from .train_util import TrainLoop3DRec
from guided_diffusion.train_util import (TrainLoop, calc_average_loss,
                                         find_ema_checkpoint,
                                         find_resume_checkpoint,
                                         get_blob_logdir, log_loss_dict,
                                         log_rec3d_loss_dict,
                                         parse_resume_step_from_filename)
from guided_diffusion.gaussian_diffusion import ModelMeanType

import dnnlib
from dnnlib.util import calculate_adaptive_weight

from ..train_util_diffusion import TrainLoop3DDiffusion
from ..cvD.nvsD_canoD import TrainLoop3DcvD_nvsD_canoD


class TrainLoop3DDiffusion_vpsde(TrainLoop3DDiffusion,TrainLoop3DcvD_nvsD_canoD):
    def __init__(self, *, rec_model, denoise_model, diffusion, loss_class, data, eval_data, batch_size, microbatch, lr, ema_rate, log_interval, eval_interval, save_interval, resume_checkpoint, use_fp16=False, fp16_scale_growth=0.001, schedule_sampler=None, weight_decay=0, lr_anneal_steps=0, iterations=10001, ignore_resume_opt=False, freeze_ae=False, denoised_ae=True, triplane_scaling_divider=10, use_amp=False, diffusion_input_size=224, **kwargs):
        super().__init__(rec_model=rec_model, denoise_model=denoise_model, diffusion=diffusion, loss_class=loss_class, data=data, eval_data=eval_data, batch_size=batch_size, microbatch=microbatch, lr=lr, ema_rate=ema_rate, log_interval=log_interval, eval_interval=eval_interval, save_interval=save_interval, resume_checkpoint=resume_checkpoint, use_fp16=use_fp16, fp16_scale_growth=fp16_scale_growth, schedule_sampler=schedule_sampler, weight_decay=weight_decay, lr_anneal_steps=lr_anneal_steps, iterations=iterations, ignore_resume_opt=ignore_resume_opt, freeze_ae=freeze_ae, denoised_ae=denoised_ae, triplane_scaling_divider=triplane_scaling_divider, use_amp=use_amp, diffusion_input_size=diffusion_input_size, **kwargs)

    def run_step(self, batch, step='g_step'):

        if step == 'diffusion_step_rec':
            self.forward_diffusion(batch, behaviour='diffusion_step_rec')
            _ = self.mp_trainer_rec.optimize(self.opt_rec) # TODO, update two groups of parameters
            took_step_ddpm = self.mp_trainer.optimize(self.opt) # TODO, update two groups of parameters

            if took_step_ddpm:
                self._update_ema()  # g_ema # TODO, ema only needs to track ddpm, remove ema tracking in rec

        elif step == 'd_step_rec':
            self.forward_D(batch, behaviour='rec')
            # _ = self.mp_trainer_cvD.optimize(self.opt_cvD)
            _ = self.mp_trainer_canonical_cvD.optimize(self.opt_cano_cvD)

        elif step == 'diffusion_step_nvs':
            self.forward_diffusion(batch, behaviour='diffusion_step_nvs')
            _ = self.mp_trainer_rec.optimize(self.opt_rec) # TODO, update two groups of parameters
            took_step_ddpm = self.mp_trainer.optimize(self.opt) # TODO, update two groups of parameters

            if took_step_ddpm:
                self._update_ema()  # g_ema

        elif step == 'd_step_nvs':
            self.forward_D(batch, behaviour='nvs')
            _ = self.mp_trainer_cvD.optimize(self.opt_cvD)

        self._anneal_lr()
        self.log_step()

    def run_loop(self):
        while (not self.lr_anneal_steps
               or self.step + self.resume_step < self.lr_anneal_steps):

            # let all processes sync up before starting with a new epoch of training
            dist_util.synchronize()

            # batch, cond = next(self.data)
            # if batch is None:
            # batch = next(self.data)
            # self.run_step(batch, 'g_step_rec')

            batch = next(self.data)
            self.run_step(batch, step='diffusion_step_rec')

            batch = next(self.data)
            self.run_step(batch, 'd_step_rec')

            # batch = next(self.data)
            # self.run_step(batch, 'g_step_nvs')

            batch = next(self.data)
            self.run_step(batch, step='diffusion_step_nvs')

            batch = next(self.data)
            self.run_step(batch, 'd_step_nvs')

            if self.step % self.log_interval == 0 and dist_util.get_rank(
            ) == 0:
                out = logger.dumpkvs()
                # * log to tensorboard
                for k, v in out.items():
                    self.writer.add_scalar(f'Loss/{k}', v,
                                           self.step + self.resume_step)

            # if self.step % self.eval_interval == 0 and self.step != 0:
            if self.step % self.eval_interval == 0:
                if dist_util.get_rank() == 0:
                    self.eval_loop()
                    # self.eval_novelview_loop()
                    # let all processes sync up before starting with a new epoch of training
                th.cuda.empty_cache()
                dist_util.synchronize()

            if self.step % self.save_interval == 0:
                self.save(self.mp_trainer, self.mp_trainer.model_name)
                self.save(self.mp_trainer_rec, self.mp_trainer_rec.model_name)
                self.save(self.mp_trainer_cvD, 'cvD')
                self.save(self.mp_trainer_canonical_cvD, 'cano_cvD')

                dist_util.synchronize()
                # Run for a finite amount of time in integration tests.
                if os.environ.get("DIFFUSION_TRAINING_TEST",
                                  "") and self.step > 0:
                    return

            self.step += 1

            if self.step > self.iterations:
                print('reached maximum iterations, exiting')

                # Save the last checkpoint if it wasn't already saved.
                if (self.step - 1) % self.save_interval != 0:

                    self.save(self.mp_trainer, self.mp_trainer.model_name)
                    self.save(self.mp_trainer_rec, self.mp_trainer_rec.model_name)
                    self.save(self.mp_trainer_cvD, 'cvD')
                    self.save(self.mp_trainer_canonical_cvD, 'cano_cvD')

                exit()

        # Save the last checkpoint if it wasn't already saved.
        if (self.step - 1) % self.save_interval != 0:
            self.save()
            self.save(self.mp_trainer_canonical_cvD, 'cvD')

    def forward_diffusion(self, batch, behaviour='rec', *args, **kwargs):
        """
        add sds grad to all ae predicted x_0 
        """

        self.ddp_cano_cvD.requires_grad_(False)
        self.ddp_nvs_cvD.requires_grad_(False)

        self.ddp_model.requires_grad_(True)
        self.ddp_rec_model.requires_grad_(True)

        # if behaviour != 'diff' and 'rec' in behaviour:
        # if behaviour != 'diff' and 'rec' in behaviour: # pure diffusion step
        #     self.ddp_rec_model.requires_grad_(True)
        for param in self.ddp_rec_model.module.decoder.triplane_decoder.parameters( # type: ignore
        ):  # type: ignore
            param.requires_grad_(False) # ! disable triplane_decoder grad in each iteration indepenently; 
        # else:

        self.mp_trainer_rec.zero_grad()
        self.mp_trainer.zero_grad()

        # ! no 'sds' step now, both add sds grad back to ViT

        # assert behaviour != 'sds'
        # if behaviour == 'sds':
        # else:
        #     self.ddp_ddpm_model.requires_grad_(True)

        batch_size = batch['img'].shape[0]

        for i in range(0, batch_size, self.microbatch):

            micro = {
                k: v[i:i + self.microbatch].to(dist_util.dev())
                for k, v in batch.items()
            }

            last_batch = (i + self.microbatch) >= batch_size

            vae_nelbo_loss = th.tensor(0.0).to(dist_util.dev())
            vision_aided_loss = th.tensor(0.0).to(dist_util.dev())
            denoise_loss = th.tensor(0.0).to(dist_util.dev())
            d_weight = th.tensor(0.0).to(dist_util.dev())

            # =================================== ae part ===================================
            with th.cuda.amp.autocast(dtype=th.float16,
                                      enabled=self.mp_trainer.use_amp
                                      and not self.freeze_ae):

                # apply vae
                vae_out = self.ddp_rec_model(
                    img=micro['img_to_encoder'],
                    c=micro['c'],
                    behaviour='enc_dec_wo_triplane')  # pred: (B, 3, 64, 64)
                

                if behaviour == 'diffusion_step_rec':
                    target = micro
                    pred = self.ddp_rec_model(latent=vae_out,
                                              c=micro['c'],
                                              behaviour='triplane_dec')

                    # vae reconstruction loss
                    if last_batch or not self.use_ddp:
                        vae_nelbo_loss, loss_dict = self.loss_class(pred,
                                                             target,
                                                             test_mode=False)
                    else:
                        with self.ddp_model.no_sync():  # type: ignore
                            vae_nelbo_loss, loss_dict = self.loss_class(
                                pred, target, test_mode=False)

                    last_layer = self.ddp_rec_model.module.decoder.triplane_decoder.decoder.net[  # type: ignore
                        -1].weight  # type: ignore

                    if 'image_sr' in pred:
                        vision_aided_loss = self.ddp_cano_cvD(
                            0.5 * pred['image_sr'] +
                            0.5 * th.nn.functional.interpolate(
                                pred['image_raw'],
                                size=pred['image_sr'].shape[2:],
                                mode='bilinear'),
                            for_G=True).mean()  # [B, 1] shape
                    else:
                        vision_aided_loss = self.ddp_cano_cvD(
                            pred['image_raw'], for_G=True
                        ).mean(
                        )   # [B, 1] shape

                    d_weight = calculate_adaptive_weight(
                        vae_nelbo_loss,
                        vision_aided_loss,
                        last_layer,
                        # disc_weight_max=1) * 1
                        disc_weight_max=1) * self.loss_class.opt.rec_cvD_lambda
                    # d_weight = self.loss_class.opt.rec_cvD_lambda # since decoder is fixed here. set to 0.001
                    
                    vision_aided_loss *= d_weight

                    # d_weight = self.loss_class.opt.rec_cvD_lambda
                    loss_dict.update({
                        'vision_aided_loss/G_rec':
                        vision_aided_loss,
                        'd_weight_G_rec':
                        d_weight,
                    })

                    log_rec3d_loss_dict(loss_dict)

                elif behaviour == 'diffusion_step_nvs':

                    novel_view_c = th.cat([micro['c'][1:], micro['c'][:1]])

                    pred = self.ddp_rec_model(latent=vae_out,
                                              c=novel_view_c,
                                              behaviour='triplane_dec')

                    if 'image_sr' in pred:
                        vision_aided_loss = self.ddp_nvs_cvD(
                            # pred_for_rec['image_sr'],
                            0.5 * pred['image_sr'] +
                            0.5 * th.nn.functional.interpolate(
                                pred['image_raw'],
                                size=pred['image_sr'].shape[2:],
                                mode='bilinear'),
                            for_G=True).mean()  # [B, 1] shape
                    else:
                        vision_aided_loss = self.ddp_nvs_cvD(
                            pred['image_raw'], for_G=True
                        ).mean(
                        )  # [B, 1] shape

                    d_weight = self.loss_class.opt.nvs_cvD_lambda
                    vision_aided_loss *= d_weight

                    log_rec3d_loss_dict({
                        'vision_aided_loss/G_nvs':
                        vision_aided_loss,
                    })

                    # ae_loss = th.tensor(0.0).to(dist_util.dev())

                # elif behaviour == 'diff':
                #     self.ddp_rec_model.requires_grad_(False)
                #     # assert self.ddp_rec_model.module.requires_grad == False, 'freeze ddpm_rec for pure diff step'
                else:
                    raise NotImplementedError(behaviour)
                #     assert behaviour == 'sds'

                # pred = None

                # if behaviour != 'sds': # also train diffusion
                # assert pred is not None

                # TODO, train diff and sds together, available?
                eps = vae_out[self.latent_name] 

                # if behaviour != 'sds':
                # micro_to_denoise.detach_()
                eps.requires_grad_(True) # single stage diffusion

                t, weights = self.schedule_sampler.sample(
                    eps.shape[0], dist_util.dev())
                noise = th.randn(size=vae_out.size(), device='cuda')  # note that this noise value is currently shared!

                model_kwargs = {}

                # ? 
                # or directly use SSD NeRF version?
                # get diffusion quantities for p (sgm prior) sampling scheme and reweighting for q (vae)

                # ! handle the sampling 

                # get diffusion quantities for p (sgm prior) sampling scheme and reweighting for q (vae)
                t_p, var_t_p, m_t_p, obj_weight_t_p, obj_weight_t_q, g2_t_p = \
                    diffusion.iw_quantities(args.batch_size, args.time_eps, args.iw_sample_p, args.iw_subvp_like_vp_sde)
                eps_t_p = diffusion.sample_q(vae_out, noise, var_t_p, m_t_p)

                # in case we want to train q (vae) with another batch using a different sampling scheme for times t
                if args.iw_sample_q in ['ll_uniform', 'll_iw']:
                    t_q, var_t_q, m_t_q, obj_weight_t_q, _, g2_t_q = \
                        diffusion.iw_quantities(args.batch_size, args.time_eps, args.iw_sample_q, args.iw_subvp_like_vp_sde)
                    eps_t_q = diffusion.sample_q(vae_out, noise, var_t_q, m_t_q)

                    eps_t_p = eps_t_p.detach().requires_grad_(True)
                    eps_t = th.cat([eps_t_p, eps_t_q], dim=0)
                    var_t = th.cat([var_t_p, var_t_q], dim=0)
                    t = th.cat([t_p, t_q], dim=0)
                    noise = th.cat([noise, noise], dim=0)
                else:
                    eps_t, m_t, var_t, t, g2_t = eps_t_p, m_t_p, var_t_p, t_p, g2_t_p
                
                # run the diffusion

                # mixing normal trick
                # TODO, create a new partial training_losses function 
                mixing_component = diffusion.mixing_component(eps_t, var_t, t, enabled=dae.mixed_prediction) # TODO, which should I use?
                params = utils.get_mixed_prediction(dae.mixed_prediction, pred_params, dae.mixing_logit, mixing_component)

                # nelbo loss with kl balancing




                # ! remainign parts of cross entropy in likelihook training

                cross_entropy_per_var += diffusion.cross_entropy_const(args.time_eps)
                cross_entropy = th.sum(cross_entropy_per_var, dim=[1, 2, 3])
                cross_entropy += remaining_neg_log_p_total  # for remaining scales if there is any
                all_neg_log_p = vae.decompose_eps(cross_entropy_per_var)
                all_neg_log_p.extend(remaining_neg_log_p_per_ver)  # add the remaining neg_log_p
                kl_all_list, kl_vals_per_group, kl_diag_list = utils.kl_per_group_vada(all_log_q, all_neg_log_p)


                kl_coeff = 1.0

                # ! calculate p/q loss; 
                # ? no spectral regularizer here
                # ? try adding grid_clip and sn later on.
                q_loss = th.mean(nelbo_loss) 
                p_loss = th.mean(p_objective) 

                # backpropagate q_loss for vae and update vae params, if trained
                if args.train_vae:
                    grad_scalar.scale(q_loss).backward(retain_graph=utils.different_p_q_objectives(args.iw_sample_p, args.iw_sample_q))
                    utils.average_gradients(vae.parameters(), args.distributed)
                    if args.grad_clip_max_norm > 0.:  # apply gradient clipping
                        grad_scalar.unscale_(vae_optimizer)
                        th.nn.utils.clip_grad_norm_(vae.parameters(), max_norm=args.grad_clip_max_norm)
                    grad_scalar.step(vae_optimizer)

                # if we use different p and q objectives or are not training the vae, discard gradients and backpropagate p_loss
                if utils.different_p_q_objectives(args.iw_sample_p, args.iw_sample_q) or not args.train_vae:
                    if args.train_vae:
                        # discard current gradients computed by weighted loss for VAE
                        dae_optimizer.zero_grad()

                    # compute gradients with unweighted loss
                    grad_scalar.scale(p_loss).backward()

                # update dae parameters
                utils.average_gradients(dae.parameters(), args.distributed)
                if args.grad_clip_max_norm > 0.:         # apply gradient clipping
                    grad_scalar.unscale_(dae_optimizer)
                    th.nn.utils.clip_grad_norm_(dae.parameters(), max_norm=args.grad_clip_max_norm)
                grad_scalar.step(dae_optimizer)


                # unpack separate objectives, in case we want to train q (vae) using a different sampling scheme for times t
                if args.iw_sample_q in ['ll_uniform', 'll_iw']:
                    l2_term_p, l2_term_q = th.chunk(l2_term, chunks=2, dim=0)
                    p_objective = th.sum(obj_weight_t_p * l2_term_p, dim=[1, 2, 3])
                    # cross_entropy_per_var = obj_weight_t_q * l2_term_q
                else:
                    p_objective = th.sum(obj_weight_t_p * l2_term, dim=[1, 2, 3])
                    # cross_entropy_per_var = obj_weight_t_q * l2_term

                # print(micro_to_denoise.min(), micro_to_denoise.max())
                compute_losses = functools.partial(
                    self.diffusion.training_losses,
                    self.ddp_model,
                    eps,  # x_start
                    t,
                    model_kwargs=model_kwargs,
                    return_detail=True)

                # ! DDPM step
                if last_batch or not self.use_ddp:
                    losses = compute_losses()
                    # denoised_out = denoised_fn()
                else:
                    with self.ddp_model.no_sync():  # type: ignore
                        losses = compute_losses()

                if isinstance(self.schedule_sampler, LossAwareSampler):
                    self.schedule_sampler.update_with_local_losses(
                        t, losses["loss"].detach())

                denoise_loss = (losses["loss"] * weights).mean()

                x_t = losses.pop('x_t')
                model_output = losses.pop('model_output')
                diffusion_target = losses.pop('diffusion_target')
                alpha_bar = losses.pop('alpha_bar')

                log_loss_dict(self.diffusion, t,
                              {k: v * weights
                               for k, v in losses.items()})

                # if behaviour == 'sds':
                # ! calculate sds grad, and add to the grad of

                # if 'rec' in behaviour and self.loss_class.opt.sds_lamdba > 0:  # only enable sds along with rec step
                #     w = (
                #         1 - alpha_bar**2
                #     ) / self.triplane_scaling_divider * self.loss_class.opt.sds_lamdba  # https://github.com/ashawkey/stable-dreamfusion/issues/106
                #     sds_grad = denoise_loss.clone().detach(
                #     ) * w  # * https://pytorch.org/docs/stable/generated/th.Tensor.detach.html. detach() returned Tensor share the same storage with previous one. add clone() here.

                #     # ae_loss = AddGradient.apply(latent[self.latent_name], sds_grad) # add sds_grad during backward

                #     def sds_hook(grad_to_add):

                #         def modify_grad(grad):
                #             return grad + grad_to_add  # add the sds grad to the original grad for BP

                #         return modify_grad

                #     eps[self.latent_name].register_hook(
                #         sds_hook(sds_grad))  # merge sds grad with rec/nvs ae step

                loss = vae_nelbo_loss + denoise_loss + vision_aided_loss  # caluclate loss within AMP

            # ! cvD loss

            # exit AMP before backward
            self.mp_trainer_rec.backward(loss)
            self.mp_trainer.backward(loss)

            # TODO, merge visualization with original AE
            # =================================== denoised AE log part ===================================

            if dist_util.get_rank() == 0 and self.step % 500 == 0 and behaviour != 'diff':
                with th.no_grad():
                    # gt_vis = th.cat([batch['img'], batch['depth']], dim=-1)

                    # st()

                    gt_depth = micro['depth']
                    if gt_depth.ndim == 3:
                        gt_depth = gt_depth.unsqueeze(1)
                    gt_depth = (gt_depth - gt_depth.min()) / (gt_depth.max() -
                                                              gt_depth.min())
                    # if True:
                    pred_depth = pred['image_depth']
                    pred_depth = (pred_depth - pred_depth.min()) / (
                        pred_depth.max() - pred_depth.min())
                    pred_img = pred['image_raw']
                    gt_img = micro['img']

                    # if 'image_sr' in pred:  # TODO
                    #     pred_img = th.cat(
                    #         [self.pool_512(pred_img), pred['image_sr']],
                    #         dim=-1)
                    #     gt_img = th.cat(
                    #         [self.pool_512(micro['img']), micro['img_sr']],
                    #         dim=-1)
                    #     pred_depth = self.pool_512(pred_depth)
                    #     gt_depth = self.pool_512(gt_depth)

                    gt_vis = th.cat(
                        [
                            gt_img, micro['img'], micro['img'],
                            gt_depth.repeat_interleave(3, dim=1)
                        ],
                        dim=-1)[0:1]  # TODO, fail to load depth. range [0, 1]

                    noised_ae_pred = self.ddp_rec_model(
                        img=None,
                        c=micro['c'][0:1],
                        latent=x_t[0:1] * self.
                        triplane_scaling_divider,  # TODO, how to define the scale automatically
                        behaviour=self.render_latent_behaviour)

                    # if denoised_out is None:
                    # if not self.denoised_ae:
                    # denoised_out = denoised_fn()

                    if self.diffusion.model_mean_type == ModelMeanType.START_X:
                        pred_xstart = model_output
                    else:  # * used here
                        pred_xstart = self.diffusion._predict_xstart_from_eps(
                            x_t=x_t, t=t, eps=model_output)

                    denoised_ae_pred = self.ddp_rec_model(
                        img=None,
                        c=micro['c'][0:1],
                        latent=pred_xstart[0:1] * self.
                        triplane_scaling_divider,  # TODO, how to define the scale automatically?
                        behaviour=self.render_latent_behaviour)

                    # denoised_out = denoised_ae_pred

                    # if not self.denoised_ae:
                    #     denoised_ae_pred = self.ddp_rec_model(
                    #         img=None,
                    #         c=micro['c'][0:1],
                    #         latent=denoised_out['pred_xstart'][0:1] * self.
                    #         triplane_scaling_divider,  # TODO, how to define the scale automatically
                    #         behaviour=self.render_latent_behaviour)
                    # else:
                    #     assert denoised_ae_pred is not None
                    #     denoised_ae_pred['image_raw'] = denoised_ae_pred[
                    #         'image_raw'][0:1]

                    # print(pred_img.shape)
                    # print('denoised_ae:', self.denoised_ae)

                    pred_vis = th.cat([
                        pred_img[0:1], noised_ae_pred['image_raw'][0:1],
                        denoised_ae_pred['image_raw'][0:1],
                        pred_depth[0:1].repeat_interleave(3, dim=1)
                    ],
                                      dim=-1)  # B, 3, H, W
                    # s

                    vis = th.cat([gt_vis, pred_vis], dim=-2)[0].permute(
                        1, 2, 0).cpu()  # ! pred in range[-1, 1]

                    # vis = th.cat([
                    #     self.pool_128(micro['img']), x_t[:, :3, ...],
                    #     denoised_out['pred_xstart'][:, :3, ...]
                    # ],
                    #              dim=-1)[0].permute(
                    #                  1, 2, 0).cpu()  # ! pred in range[-1, 1]

                    # vis_grid = torchvision.utils.make_grid(vis) # HWC
                    vis = vis.numpy() * 127.5 + 127.5
                    vis = vis.clip(0, 255).astype(np.uint8)
                    Image.fromarray(vis).save(
                        f'{logger.get_dir()}/{self.step+self.resume_step}denoised_{t[0].item()}_{behaviour}.jpg'
                    )
                    print(
                        'log denoised vis to: ',
                        f'{logger.get_dir()}/{self.step+self.resume_step}denoised_{t[0].item()}_{behaviour}.jpg'
                    )

                    th.cuda.empty_cache()