train_3dsr.py

#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use 
# under the terms of the LICENSE.md file.
#
# For inquiries contact  george.drettakis@inria.fr
#

import os, glob
import numpy as np
import open3d as o3d
import cv2
import json
import torch
import random
from random import randint
from utils.loss_utils import l1_loss, ssim
from gaussian_renderer import render, network_gui
from torch import autocast
import sys
import copy
from scene import Scene, GaussianModel
from utils.general_utils import safe_state
import uuid
import lpips
import pyiqa
import natsort
# from tqdm import tqdm
from utils.image_utils import psnr
from argparse import ArgumentParser, Namespace
from arguments import ModelParams, PipelineParams, OptimizationParams
# from scipy.spatial.transform import Rotation as R, Slerp
import torchvision
from scene.cameras import Camera
from PIL import Image
from utils.general_utils import PILtoTorch
try:
    # from torch.utils.tensorboard import SummaryWriter
    from tensorboardX import SummaryWriter
    TENSORBOARD_FOUND = True
except ImportError:
    TENSORBOARD_FOUND = False
    
##### Stable SR usage #####
from pytorch_lightning import seed_everything
from omegaconf import OmegaConf
from utils.stable_sr_utils import instantiate_from_config
from utils.wavelet_color_fix import wavelet_reconstruction, adaptive_instance_normalization
from contextlib import nullcontext
from tqdm import tqdm, trange
from einops import rearrange, repeat
from utils.util_image import ImageSpliterTh
import torch.nn.functional as F
from pathlib import Path
import time

@torch.no_grad()
def create_offset_gt(image, offset):
    height, width = image.shape[1:]
    meshgrid = np.meshgrid(range(width), range(height), indexing='xy')
    id_coords = np.stack(meshgrid, axis=0).astype(np.float32)
    id_coords = torch.from_numpy(id_coords).cuda()
    
    id_coords = id_coords.permute(1, 2, 0) + offset
    id_coords[..., 0] /= (width - 1)
    id_coords[..., 1] /= (height - 1)
    id_coords = id_coords * 2 - 1
    
    image = torch.nn.functional.grid_sample(image[None], id_coords[None], align_corners=True, padding_mode="border")[0]
    return image

def prepare_training(dataset, opt, pipe, testing_iterations, saving_iterations, checkpoint_iterations, checkpoint, debug_from, args, dataset2=None):
    first_iter = 0
    tb_writer = prepare_output_and_logger(dataset)
    gaussians = GaussianModel(dataset.sh_degree)
    
    if args.load_pretrain:
        scene = Scene(dataset, gaussians, load_iteration=args.pretrain_iteration, shuffle=False)
        scene.model_path = args.output_folder
        dataset_name = os.path.basename(dataset.source_path)
        dataset.model_path = os.path.join(args.output_folder, dataset_name)
        
        tb_writer = prepare_output_and_logger(dataset)
        scene.model_path = dataset.model_path
    else:
        scene = Scene(dataset, gaussians)
    
    if args.load_pretrain:
        gaussians.max_radii2D = torch.zeros((gaussians.get_xyz.shape[0]), dtype=torch.float32, device="cuda")
        gaussians.training_setup(opt)
        print("--- after loading pretrain points:", gaussians._xyz.shape[0])
    else:
        gaussians.training_setup(opt)
        
    if checkpoint:
        (model_params, first_iter) = torch.load(checkpoint)
        gaussians.restore(model_params, opt)    

    bg_color = [1, 1, 1] if dataset.white_background else [0, 0, 0]
    background = torch.tensor(bg_color, dtype=torch.float32, device="cuda")
    
    out_dict = {"scene": scene, "gaussians": gaussians, "tb_writer": tb_writer}
    return out_dict

def training_with_iters(in_dict, dataset, opt, pipe, testing_iterations, saving_iterations, checkpoint_iterations, checkpoint, debug_from, args, dataset2=None, SR_iter=0):
    scene = in_dict['scene']
    gaussians = in_dict['gaussians']
    tb_writer = in_dict['tb_writer']
    
    first_iter = 0    
    bg_color = [1, 1, 1] if dataset.white_background else [0, 0, 0]
    background = torch.tensor(bg_color, dtype=torch.float32, device="cuda")

    iter_start = torch.cuda.Event(enable_timing = True)
    iter_end = torch.cuda.Event(enable_timing = True)

    trainCameras = scene.getTrainCameras().copy()
    testCameras = scene.getTestCameras().copy()
    allCameras = trainCameras + testCameras
    
    # highresolution index
    highresolution_index = []
    for index, camera in enumerate(trainCameras):
        if camera.image_width >= 800:
            highresolution_index.append(index)

    gaussians.compute_3D_filter(cameras=trainCameras)

    viewpoint_stack = None
    ema_loss_for_log = 0.0
    progress_bar = tqdm(range(first_iter, opt.iterations), desc="Training progress")
    first_iter += 1
    
    for iteration in range(first_iter, opt.iterations + 1):
        if network_gui.conn == None:
            network_gui.try_connect()
        while network_gui.conn != None:
            try:
                net_image_bytes = None
                custom_cam, do_training, pipe.convert_SHs_python, pipe.compute_cov3D_python, keep_alive, scaling_modifer = network_gui.receive()
                if custom_cam != None:
                    net_image = render(custom_cam, gaussians, pipe, background, scaling_modifer)["render"]
                    net_image_bytes = memoryview((torch.clamp(net_image, min=0, max=1.0) * 255).byte().permute(1, 2, 0).contiguous().cpu().numpy())
                network_gui.send(net_image_bytes, dataset.source_path)
                if do_training and ((iteration < int(opt.iterations)) or not keep_alive):
                    break
            except Exception as e:
                network_gui.conn = None

        iter_start.record()

        gaussians.update_learning_rate(iteration)

        # Every 1000 its we increase the levels of SH up to a maximum degree
        if iteration % 1000 == 0:
            gaussians.oneupSHdegree()

        # Pick a random Camera
        if not viewpoint_stack:
            viewpoint_stack = scene.getTrainCameras().copy()
        viewpoint_cam = viewpoint_stack.pop(randint(0, len(viewpoint_stack)-1))
        
        # Pick a random high resolution camera
        if random.random() < 0.3 and dataset.sample_more_highres:
            viewpoint_cam = trainCameras[highresolution_index[randint(0, len(highresolution_index)-1)]]
            
        # Render
        if (iteration - 1) == debug_from:
            pipe.debug = True

        #TODO ignore border pixels
        if dataset.ray_jitter:
            subpixel_offset = torch.rand((int(viewpoint_cam.image_height), int(viewpoint_cam.image_width), 2), dtype=torch.float32, device="cuda") - 0.5
            # subpixel_offset *= 0.0
        else:
            subpixel_offset = None
            
        # Rendering
        render_pkg = render(viewpoint_cam, gaussians, pipe, background, kernel_size=dataset.kernel_size, subpixel_offset=subpixel_offset)
        image, viewspace_point_tensor, visibility_filter, radii = render_pkg["render"], render_pkg["viewspace_points"], render_pkg["visibility_filter"], render_pkg["radii"]

        # Loss
        gt_image = viewpoint_cam.original_image.cuda()
        
        # sample gt_image with subpixel offset
        if dataset.resample_gt_image:
            gt_image = create_offset_gt(gt_image, subpixel_offset)
        
        Ll1 = l1_loss(image, gt_image)
        loss_hr = (1.0 - opt.lambda_dssim) * Ll1 + opt.lambda_dssim * (1.0 - ssim(image, gt_image))
        loss = loss_hr
        
        if iteration > opt.iterations - len(trainCameras):
            training_folder = os.path.join(args.output_folder, 'training_views')
            if not os.path.exists(training_folder):
                os.makedirs(training_folder)
            file_name = os.path.join(training_folder, viewpoint_cam.image_name + ".png")
            torchvision.utils.save_image(image, os.path.join(file_name))
        
        if args.fidelity_train_en:
            lr_resolution = dataset.resolution * 4
            gt_path = os.path.join(dataset.source_path, f'images_{lr_resolution}', viewpoint_cam.image_name+'.png')
            image_gt_lr = Image.open(gt_path)
            w_lr, h_lr = image_gt_lr.size
            image_gt_lr = PILtoTorch(image_gt_lr, (w_lr, h_lr)).cuda()
            image_lr = torch.nn.functional.interpolate(image.unsqueeze(0), scale_factor=0.25, mode='bicubic', antialias=True).squeeze(0)
            loss_lr = (1.0 - opt.lambda_dssim) * l1_loss(image_lr, image_gt_lr) + opt.lambda_dssim * (1.0 - ssim(image_lr, image_gt_lr))
            loss += loss_lr * args.wt_lr
                    
        loss.backward()
        iter_end.record()
        
        if iteration == opt.iterations - 1 and not args.skip_train_results:
            training_folder = os.path.join(args.outdir, 'train_results')
            if not os.path.exists(training_folder):
                os.makedirs(training_folder)
                
            for i in range(len(trainCameras)):                
                cam = trainCameras[i]
                rendering = render(cam, gaussians, pipe, background, kernel_size=dataset.kernel_size, subpixel_offset=subpixel_offset)["render"]
                file_name = os.path.join(training_folder, cam.image_name + f"_step_{3-SR_iter}.png")
                print(file_name)
                torchvision.utils.save_image(rendering, os.path.join(file_name))
            
        with torch.no_grad():
            # Progress bar
            ema_loss_for_log = 0.4 * loss.item() + 0.6 * ema_loss_for_log
            if iteration % 10 == 0:
                progress_bar.set_postfix({"Loss": f"{ema_loss_for_log:.{7}f}"})
                progress_bar.update(10)
            if iteration == opt.iterations:
                progress_bar.close()

            # Log and save
            training_report(tb_writer, iteration, Ll1, loss, l1_loss, iter_start.elapsed_time(iter_end), testing_iterations, scene, render, (pipe, background, dataset.kernel_size))
            if (iteration in saving_iterations):
                final_iter = (3-SR_iter) * opt.iterations + iteration
                print("\n[ITER {}] Saving Gaussians".format(iteration))
                scene.save(final_iter)

            # Densification
            if iteration < opt.densify_until_iter:
                # Keep track of max radii in image-space for pruning
                gaussians.max_radii2D[visibility_filter] = torch.max(gaussians.max_radii2D[visibility_filter], radii[visibility_filter])
                gaussians.add_densification_stats(viewspace_point_tensor, visibility_filter)

                if iteration > opt.densify_from_iter and iteration % opt.densification_interval == 0:
                    size_threshold = 20 if iteration > opt.opacity_reset_interval else None
                    gaussians.densify_and_prune(opt.densify_grad_threshold, 0.005, scene.cameras_extent, size_threshold)
                    gaussians.compute_3D_filter(cameras=trainCameras)

                if iteration % opt.opacity_reset_interval == 0 or (dataset.white_background and iteration == opt.densify_from_iter):
                    gaussians.reset_opacity()

            if iteration % 100 == 0 and iteration > opt.densify_until_iter:
                if iteration < opt.iterations - 100:
                    # don't update in the end of training
                    gaussians.compute_3D_filter(cameras=trainCameras)
        
            # Optimizer step
            if iteration < opt.iterations:
                gaussians.optimizer.step()
                gaussians.optimizer.zero_grad(set_to_none = True)

            if (iteration in checkpoint_iterations):
                print("\n[ITER {}] Saving Checkpoint".format(iteration))
                torch.save((gaussians.capture(), iteration), scene.model_path + "/chkpnt" + str(iteration) + ".pth")
    
    out_dict = {"scene": scene, "gaussians": gaussians, "tb_writer": tb_writer, "highresolution_index": highresolution_index}
    
    return out_dict

def load_model_from_config(config, ckpt, verbose=False):
	print(f"Loading model from {ckpt}")
	pl_sd = torch.load(ckpt, map_location="cpu")
	if "global_step" in pl_sd:
		print(f"Global Step: {pl_sd['global_step']}")
	sd = pl_sd["state_dict"]
	model = instantiate_from_config(config.model)
	m, u = model.load_state_dict(sd, strict=False)
	if len(m) > 0 and verbose:
		print("missing keys:")
		print(m)
	if len(u) > 0 and verbose:
		print("unexpected keys:")
		print(u)

	model.cuda()
	model.eval()
	return model

def prepare_model(opt):
    config = OmegaConf.load(f"{opt.config}")
    model = load_model_from_config(config, f"{opt.ckpt}")
    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
    model = model.to(device)
    model.configs = config
    
    vqgan_config = OmegaConf.load("configs/autoencoder/autoencoder_kl_64x64x4_resi.yaml")
    vq_model = load_model_from_config(vqgan_config, opt.vqgan_ckpt)
    vq_model = vq_model.to(device)
    vq_model.decoder.fusion_w = opt.dec_w
    
    model.register_schedule(given_betas=None, beta_schedule="linear", timesteps=1000,
						  linear_start=0.00085, linear_end=0.0120, cosine_s=8e-3)
       
    out_dict = {'model': model, 'vq_model': vq_model}
    return out_dict

def space_timesteps(num_timesteps, section_counts):
	"""
	Create a list of timesteps to use from an original diffusion process,
	given the number of timesteps we want to take from equally-sized portions
	of the original process.
	For example, if there's 300 timesteps and the section counts are [10,15,20]
	then the first 100 timesteps are strided to be 10 timesteps, the second 100
	are strided to be 15 timesteps, and the final 100 are strided to be 20.
	If the stride is a string starting with "ddim", then the fixed striding
	from the DDIM paper is used, and only one section is allowed.
	:param num_timesteps: the number of diffusion steps in the original
						  process to divide up.
	:param section_counts: either a list of numbers, or a string containing
						   comma-separated numbers, indicating the step count
						   per section. As a special case, use "ddimN" where N
						   is a number of steps to use the striding from the
						   DDIM paper.
	:return: a set of diffusion steps from the original process to use.
	"""
	if isinstance(section_counts, str):
		if section_counts.startswith("ddim"):
			desired_count = int(section_counts[len("ddim"):])
			for i in range(1, num_timesteps):
				if len(range(0, num_timesteps, i)) == desired_count:
					return set(range(0, num_timesteps, i))
			raise ValueError(
				f"cannot create exactly {num_timesteps} steps with an integer stride"
			)
		section_counts = [int(x) for x in section_counts.split(",")]   #[250,]
	size_per = num_timesteps // len(section_counts)
	extra = num_timesteps % len(section_counts)
	start_idx = 0
	all_steps = []
	for i, section_count in enumerate(section_counts):
		size = size_per + (1 if i < extra else 0)
		if size < section_count:
			raise ValueError(
				f"cannot divide section of {size} steps into {section_count}"
			)
		if section_count <= 1:
			frac_stride = 1
		else:
			frac_stride = (size - 1) / (section_count - 1)
		cur_idx = 0.0
		taken_steps = []
		for _ in range(section_count):
			taken_steps.append(start_idx + round(cur_idx))
			cur_idx += frac_stride
		all_steps += taken_steps
		start_idx += size
	return set(all_steps)

def read_image(im_path):
	im = np.array(Image.open(im_path).convert("RGB"))
	im = im.astype(np.float32)/255.0
	im = im[None].transpose(0,3,1,2)
	im = (torch.from_numpy(im) - 0.5) / 0.5
	return im.cuda()

def visualize_image(latent, rgb_patch, model_dict, out_img_name=None):
    # latent: latent to be decoded
    # rgb_patch: input image rgb patch
    # model_dict: dictionary containing model and vq_model
    # out_img_name: output image name
    
    vq_model = model_dict['vq_model']
    model = model_dict['model']
    _, enc_fea_lq = vq_model.encode(rgb_patch)
    x_samples = vq_model.decode(latent * 1. / model.scale_factor, enc_fea_lq)
    x_samples = wavelet_reconstruction(x_samples, rgb_patch)
    im_sr = torch.clamp((x_samples+1.0)/2.0, min=0.0, max=1.0)
    out = Image.fromarray(np.uint8(im_sr[0, ].permute(1,2,0).cpu().numpy()*255))
    
    if out_img_name is not None:        
        out.save(out_img_name)
    return out
    
def train_proposed(dataset, op, pipe, testing_iterations, saving_iterations, checkpoint_iterations, checkpoint, debug_from, args, dataset2=None):    
    ####################################
    # Set up for Stable SR
    ####################################
    print('>>>>>>>>>>color correction>>>>>>>>>>>')
    if args.colorfix_type == 'adain':
        print('Use adain color correction')
    elif args.colorfix_type == 'wavelet':
        print('Use wavelet color correction')
    else:
        print('No color correction')
    print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
    
    #############################################
    # load StableSR model and scheduler
    #############################################
    # Check input images
    os.makedirs(args.outdir, exist_ok=True)
    outpath = args.outdir
    batch_size = args.n_samples
    images_path_ori = sorted(glob.glob(os.path.join(args.init_img, "*")))
    images_path = np.array(copy.deepcopy(images_path_ori))
    
    # Only taking training views for SR
    llffhold = 8
    all_indices = np.arange(len(images_path))
    train_indices = all_indices % llffhold != 0
    sr_indices = all_indices[train_indices]
    images_path = images_path[sr_indices[:]]
    print(f"Found {len(images_path)} inputs.")
    
    # Prepare model
    out_dict = prepare_model(args)
    model = out_dict['model']
    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
    sqrt_alphas_cumprod = copy.deepcopy(model.sqrt_alphas_cumprod)
    sqrt_one_minus_alphas_cumprod = copy.deepcopy(model.sqrt_one_minus_alphas_cumprod)
    
    # Modify scheduler for fewer steps
    use_timesteps = set(space_timesteps(1000, [args.ddpm_steps]))
    last_alpha_cumprod = 1.0
    new_betas = []
    timestep_map = []
    for i, alpha_cumprod in enumerate(model.alphas_cumprod):
        if i in use_timesteps:
            new_betas.append(1 - alpha_cumprod / last_alpha_cumprod)
            last_alpha_cumprod = alpha_cumprod
            timestep_map.append(i)
    new_betas = [beta.data.cpu().numpy() for beta in new_betas]
    model.register_schedule(given_betas=np.array(new_betas), timesteps=len(new_betas))
    model.num_timesteps = 1000
    model.ori_timesteps = list(use_timesteps)
    model.ori_timesteps.sort()
    model = model.to(device)
    
    # Add model and args to out_dict
    out_dict['model'] = model
    out_dict['args'] = args
    precision_scope = autocast if args.precision == "autocast" else nullcontext
    
    #############################################
    # Loading scene and Gaussians
    #############################################    
    op.densify_until_iter = args.densify_end
    input_dict = prepare_training(dataset, op, pipe, testing_iterations, saving_iterations, checkpoint_iterations, checkpoint, debug_from, args, dataset2)
    scene = input_dict["scene"]
    trainCameras = scene.getTrainCameras()
    
    if 'llff' in dataset.source_path:
        dir_name = dataset.source_path
        lr_resolution = dataset.resolution * 4
        
        orig_folder =  os.path.join(dir_name, 'images')
        orig_files = os.listdir(orig_folder)
        orig_files = natsort.natsorted(orig_files)
        
        cur_files = os.listdir( os.path.join(dir_name, f'images_{lr_resolution}'))
        cur_files = natsort.natsorted(cur_files)        
    #############################################
    # Prepare for SR method
    #############################################
    with model.ema_scope():
        tic = time.time()
        all_samples = list()        
        seed_everything(args.seed)
        
        imgs_per_batch = batch_size
        loop_img_time = len(images_path) // imgs_per_batch
        one_more_time = (len(images_path) % imgs_per_batch) > 0        
        loop_img_time += int(one_more_time)
      
        #############################################
        # Loop by denoising steps
        #############################################
        for iteration in range(args.ddpm_steps-1, -1, -1):
            for loop_id in range(loop_img_time):
                if loop_id == loop_img_time - 1:
                    images_path_small = images_path[loop_id*imgs_per_batch:]
                else:
                    images_path_small = images_path[loop_id*imgs_per_batch : (loop_id+1)*imgs_per_batch]
                
                im_lq_bs = []
                im_path_bs = []
                for img_id in range(len(images_path_small)):
                    cur_image = read_image(images_path_small[img_id])
                    size_min = min(cur_image.size(-1), cur_image.size(-2))
                    upsample_scale = max(args.input_size/size_min,
                                         args.upscale)
                    cur_image = F.interpolate(
                                cur_image,
                                size=(int(cur_image.size(-2)*upsample_scale),
                                        int(cur_image.size(-1)*upsample_scale)),
                                mode='bicubic',
                                )
                    cur_image = cur_image.clamp(-1, 1)                    
                    im_lq_bs.append(cur_image) # 1 x c x h x w, [-1, 1]
                    im_path_bs.append(images_path_small[img_id]) # 1 x c x h x w, [-1, 1]
                im_lq_bs = torch.cat(im_lq_bs, dim=0)                
                ori_h, ori_w = im_lq_bs.shape[2:]
                ref_patch=None
                if not (ori_h % 32 == 0 and ori_w % 32 == 0):
                    flag_pad = True
                    pad_h = ((ori_h // 32) + 1) * 32 - ori_h
                    pad_w = ((ori_w // 32) + 1) * 32 - ori_w
                    im_lq_bs = F.pad(im_lq_bs, pad=(0, pad_w, 0, pad_h), mode='reflect')
                else:
                    flag_pad = False
                    
                if iteration != args.ddpm_steps - 1:
                    #####################################################
                    # Load upsampled image, and encode to latent space
                    #####################################################
                    imgs = []
                    for img_id in range(len(im_path_bs)):
                        img_name = str(Path(im_path_bs[img_id]).name)
                        basename = os.path.splitext(os.path.basename(img_name))[0]
                        training_folder = os.path.join(args.outdir, 'train_results')
                        cur_id = loop_id * imgs_per_batch + img_id
                        imgpath = os.path.join(training_folder, trainCameras[cur_id].image_name + f"_step_{3-int(iteration)-1}.png")                        
                        cur_image = read_image(imgpath)
                        
                        # Add padding to loaded image
                        if not (ori_h % 32 == 0 and ori_w % 32 == 0):
                            pad_h = ((ori_h // 32) + 1) * 32 - ori_h
                            pad_w = ((ori_w // 32) + 1) * 32 - ori_w
                            cur_image = F.pad(cur_image, pad=(0, pad_w, 0, pad_h), mode='reflect')
                        imgs.append(cur_image)
                    imgs = torch.cat(imgs, dim=0)
                    
                print("************** Diffusion step ", 3-iteration, "**************")
                with torch.no_grad():
                    with precision_scope("cuda"):
                        #############################################
                        # Start of loop for denoised images
                        #############################################
                        for img_id in range(len(im_path_bs)):
                            #############################################
                            # Split image to patches
                            #############################################
                            if im_lq_bs.shape[2] > args.vqgantile_size or im_lq_bs.shape[3] > args.vqgantile_size:
                                im_spliter = ImageSpliterTh(im_lq_bs[img_id].unsqueeze(0), args.vqgantile_size, args.vqgantile_stride, sf=1)
                                if iteration != args.ddpm_steps-1:
                                    im_spliter_x_tilda = ImageSpliterTh(imgs[img_id].unsqueeze(0), args.vqgantile_size, args.vqgantile_stride, sf=1)
                                #############################################
                                # Loop to process each patch in an image   
                                #############################################                         
                                for im_lq_pch, index_infos in im_spliter:
                                    if iteration == args.ddpm_steps-1:
                                        init_latent = model.get_first_stage_encoding(model.encode_first_stage(im_lq_pch))  # move to latent space
                                        text_init = ['']*args.n_samples
                                        semantic_c = model.cond_stage_model(text_init)
                                        noise = torch.randn_like(init_latent)
                                        # If you would like to start from the intermediate steps, you can add noise to LR to the specific steps.
                                        t = repeat(torch.tensor([999]), '1 -> b', b=im_lq_pch.size(0))
                                        t = t.to(device).long()
                                        # Apply the noise to the latent space (sqrt(alpha) * z + sqrt(1-alpha) * x) to create x_T
                                        x_T = model.q_sample_respace(x_start=init_latent, t=t, sqrt_alphas_cumprod=sqrt_alphas_cumprod, 
                                                sqrt_one_minus_alphas_cumprod=sqrt_one_minus_alphas_cumprod, noise=noise)
                                        _, x0_head = model.sample_canvas_one_iter(iteration=iteration, cond=semantic_c, struct_cond=init_latent, 
                                                                                    batch_size=im_lq_pch.size(0), timesteps=args.ddpm_steps, time_replace=args.ddpm_steps, 
                                                                                    x_T=x_T, tile_size=int(args.input_size/8), tile_overlap=args.tile_overlap, 
                                                                                    batch_size_sample=args.n_samples, return_x0=True)
                                    else:
                                        #############################################
                                        # Encode image to latent space
                                        #############################################
                                        im_lq_pch_tilda, index_infos_tilda = next(im_spliter_x_tilda)
                                        x0_tilda_latent = model.get_first_stage_encoding(model.encode_first_stage(im_lq_pch_tilda))  # move to latent space
                                        text_init = ['']*args.n_samples
                                        semantic_c = model.cond_stage_model(text_init)
                                        init_latent = model.get_first_stage_encoding(model.encode_first_stage(im_lq_pch))  # move to latent space
                                        x_T_1 = model.sample_canvas_one_iter(iteration=iteration+1, cond=semantic_c, struct_cond=init_latent, 
                                                        batch_size=im_lq_pch.size(0), timesteps=args.ddpm_steps, time_replace=args.ddpm_steps, 
                                                        x_T=x_T, tile_size=int(args.input_size/8), tile_overlap=args.tile_overlap, 
                                                        batch_size_sample=args.n_samples, return_x0=False, x0_input=x0_tilda_latent)
                                        _, x0_head = model.sample_canvas_one_iter(iteration=iteration, cond=semantic_c, struct_cond=init_latent, 
                                                                                    batch_size=im_lq_pch.size(0), timesteps=args.ddpm_steps, time_replace=args.ddpm_steps, 
                                                                                    x_T=x_T_1, tile_size=int(args.input_size/8), tile_overlap=args.tile_overlap, 
                                                                                    batch_size_sample=args.n_samples, return_x0=True)
                                    # Decode the latent space to image space
                                    vq_model = out_dict['vq_model']
                                    _, enc_fea_lq = vq_model.encode(im_lq_pch)
                                    x_samples = vq_model.decode(x0_head * 1. / model.scale_factor, enc_fea_lq)
                                    
                                    if args.colorfix_type == 'adain':
                                        x_samples = adaptive_instance_normalization(x_samples, im_lq_pch)
                                    elif args.colorfix_type == 'wavelet':
                                        x_samples = wavelet_reconstruction(x_samples, im_lq_pch)
                                    im_spliter.update_gaussian(x_samples, index_infos)

                                im_sr = im_spliter.gather()
                                im_sr = torch.clamp((im_sr+1.0)/2.0, min=0.0, max=1.0)
                                
                                if upsample_scale > args.upscale:
                                    im_sr = F.interpolate(
                                                im_sr,
                                                size=(int(im_lq_bs.size(-2)*args.upscale/upsample_scale),
                                                    int(im_lq_bs.size(-1)*args.upscale/upsample_scale)),
                                                mode='bicubic',)
                                    im_sr = torch.clamp(im_sr, min=0.0, max=1.0)
                                
                                if flag_pad:
                                    im_sr = im_sr[:, :, :ori_h, :ori_w, ]

                                im_sr = im_sr.cpu().numpy().transpose(0,2,3,1)*255   # b x h x w x c                                
                                img_name = str(Path(im_path_bs[img_id]).name)
                                basename = os.path.splitext(os.path.basename(img_name))[0]
                                outpath = str(Path(args.outdir)) + '/' + basename + f'_step_{3-int(iteration)}.png'
                                print('Finished:', outpath)
                                Image.fromarray(im_sr[0, ].astype(np.uint8)).save(outpath)
                            
                            #######################################################################
                            # Take the entire image as SR input (when input image is small enough)
                            #######################################################################
                            else:
                                if iteration == args.ddpm_steps-1:
                                    init_latent = model.get_first_stage_encoding(model.encode_first_stage(im_lq_bs[img_id].unsqueeze(0)))  # move to latent space
                                    text_init = ['']*args.n_samples
                                    semantic_c = model.cond_stage_model(text_init)
                                    noise = torch.randn_like(init_latent)
                                    # If you would like to start from the intermediate steps, you can add noise to LR to the specific steps.
                                    t = repeat(torch.tensor([999]), '1 -> b', b=1)
                                    t = t.to(device).long()
                                    x_T = model.q_sample_respace(x_start=init_latent, t=t, sqrt_alphas_cumprod=sqrt_alphas_cumprod, sqrt_one_minus_alphas_cumprod=sqrt_one_minus_alphas_cumprod, noise=noise)
                                    _, x0_head = model.sample_canvas_one_iter(iteration=iteration, cond=semantic_c, struct_cond=init_latent, 
                                                                            batch_size=1, timesteps=args.ddpm_steps, time_replace=args.ddpm_steps, 
                                                                            x_T=x_T, tile_size=int(args.input_size/8), tile_overlap=args.tile_overlap, 
                                                                            batch_size_sample=args.n_samples, return_x0=True)
                                else:
                                    #############################################
                                    # Encode image to latent space
                                    #############################################
                                    x0_tilda_latent = model.get_first_stage_encoding(model.encode_first_stage(imgs[img_id].unsqueeze(0)))  # move to latent space
                                    text_init = ['']*args.n_samples
                                    semantic_c = model.cond_stage_model(text_init)
                                    init_latent = model.get_first_stage_encoding(model.encode_first_stage(im_lq_bs[img_id].unsqueeze(0)))  # move to latent space
                                    # Get x_{t-1}
                                    x_T_1 = model.sample_canvas_one_iter(iteration=iteration+1, cond=semantic_c, struct_cond=init_latent, 
                                                    batch_size=1, timesteps=args.ddpm_steps, time_replace=args.ddpm_steps, 
                                                    x_T=x_T, tile_size=int(args.input_size/8), tile_overlap=args.tile_overlap, 
                                                    batch_size_sample=args.n_samples, return_x0=False, x0_input=x0_tilda_latent)
                                    # Predict x0_head
                                    _, x0_head = model.sample_canvas_one_iter(iteration=iteration, cond=semantic_c, struct_cond=init_latent, 
                                                                                batch_size=1, timesteps=args.ddpm_steps, time_replace=args.ddpm_steps, 
                                                                                x_T=x_T_1, tile_size=int(args.input_size/8), tile_overlap=args.tile_overlap, 
                                                                                batch_size_sample=args.n_samples, return_x0=True)
                                    
                                vq_model = out_dict['vq_model']
                                _, enc_fea_lq = vq_model.encode(im_lq_bs[img_id].unsqueeze(0))
                                x_samples = vq_model.decode(x0_head * 1. / model.scale_factor, enc_fea_lq)
                                if args.colorfix_type == 'adain':
                                    x_samples = adaptive_instance_normalization(x_samples, im_lq_bs[img_id].unsqueeze(0))
                                elif args.colorfix_type == 'wavelet':
                                    x_samples = wavelet_reconstruction(x_samples, im_lq_bs[img_id].unsqueeze(0))
                                im_sr = torch.clamp((x_samples+1.0)/2.0, min=0.0, max=1.0)
                                if flag_pad:
                                    im_sr = im_sr[:, :, :ori_h, :ori_w, ]

                                im_sr = im_sr.cpu().numpy().transpose(0,2,3,1)*255   # b x h x w x c                                
                                img_name = str(Path(im_path_bs[img_id]).name)
                                basename = os.path.splitext(os.path.basename(img_name))[0]
                                outpath = str(Path(args.outdir)) + '/' + basename + f'_step_{3-int(iteration)}.png'
                                Image.fromarray(im_sr[0, ].astype(np.uint8)).save(outpath)
                                print('Finished:', outpath)
                                
                                if iteration == 0:
                                    final_sr_path = os.path.join(args.outdir, 'final_sr_results')
                                    os.makedirs(final_sr_path, exist_ok=True)
                                    outpath = final_sr_path + '/' + basename + f'.png'
                                    Image.fromarray(im_sr[0, ].astype(np.uint8)).save(outpath)                        
                    #############################################
                    # End of loop for denoised images
                    #############################################                
            
            #############################################
            # Update ground truth image in trainCameras  
            #############################################
            for img_id in range(len(trainCameras)):
                img_name = trainCameras[img_id].image_name
                img_path = str(Path(args.outdir)) + '/' + img_name + f'_step_{3-int(iteration)}.png'
                img_transfer = Image.open(img_path).convert("RGB")
                width, height = img_transfer.size
                loaded_image = PILtoTorch(img_transfer, (width, height)).cuda()
                trainCameras[img_id].original_image = loaded_image.clone()
                
            # #############################################
            # # Train GS
            # #############################################
            input_dict = training_with_iters(input_dict, dataset, op, pipe, testing_iterations, saving_iterations,
                                            checkpoint_iterations, checkpoint, debug_from, args, dataset2, SR_iter=iteration,) 

def find_offline_sr_image(offline_sr_dir, image_name):
    candidates = [
        os.path.join(offline_sr_dir, image_name + ext)
        for ext in [".png", ".jpg", ".jpeg", ".JPG", ".JPEG"]
    ]
    for candidate in candidates:
        if os.path.exists(candidate):
            return candidate
    matches = glob.glob(os.path.join(offline_sr_dir, "**", image_name + ".*"), recursive=True)
    image_matches = [
        match for match in matches
        if os.path.splitext(match)[1].lower() in [".png", ".jpg", ".jpeg"]
    ]
    if image_matches:
        return sorted(image_matches)[0]
    raise FileNotFoundError(
        f"Cannot find offline SR image for '{image_name}' in {offline_sr_dir}. "
        "Expected the same basename as the training view, e.g. image_name.png."
    )

def load_offline_sr_targets(trainCameras, args):
    if args.offline_sr_dir is None:
        raise ValueError("--offline_sr_dir is required when --sr_backend offline")
    if not os.path.isdir(args.offline_sr_dir):
        raise FileNotFoundError(f"--offline_sr_dir does not exist: {args.offline_sr_dir}")

    print(f">>>>>>>>>> loading offline SR targets from {args.offline_sr_dir}")
    loaded_paths = []
    for cam in trainCameras:
        sr_path = find_offline_sr_image(args.offline_sr_dir, cam.image_name)
        sr_image = Image.open(sr_path).convert("RGB")
        expected_size = (cam.image_width, cam.image_height)

        if sr_image.size != expected_size:
            message = (
                f"Offline SR size mismatch for {cam.image_name}: "
                f"got {sr_image.size}, expected {expected_size}. "
                "The offline SR outputs must match the refinement camera resolution."
            )
            if args.offline_sr_resize:
                print("[Warning] " + message + " Resizing because --offline_sr_resize is enabled.")
                sr_image = sr_image.resize(expected_size, Image.BICUBIC)
            else:
                raise ValueError(message + " Pass --offline_sr_resize only for debugging.")

        loaded_image = PILtoTorch(sr_image, expected_size).cuda()
        cam.original_image = loaded_image.clone()
        loaded_paths.append(sr_path)

    print(f">>>>>>>>>> loaded {len(loaded_paths)} offline SR target images")
    return loaded_paths

def train_offline_sr(dataset, op, pipe, testing_iterations, saving_iterations, checkpoint_iterations, checkpoint, debug_from, args, dataset2=None):
    if not args.load_pretrain:
        raise ValueError("--load_pretrain is required for offline SR refinement")

    op.densify_until_iter = args.densify_end
    input_dict = prepare_training(
        dataset, op, pipe, testing_iterations, saving_iterations,
        checkpoint_iterations, checkpoint, debug_from, args, dataset2
    )
    scene = input_dict["scene"]
    trainCameras = scene.getTrainCameras()
    load_offline_sr_targets(trainCameras, args)

    input_dict = training_with_iters(
        input_dict, dataset, op, pipe, testing_iterations, saving_iterations,
        checkpoint_iterations, checkpoint, debug_from, args, dataset2, SR_iter=3
    )
    return input_dict

def training(dataset, opt, pipe, testing_iterations, saving_iterations, checkpoint_iterations, checkpoint, debug_from, args, dataset2=None):
    first_iter = 0
    tb_writer = prepare_output_and_logger(dataset)
    gaussians = GaussianModel(dataset.sh_degree)
    scene = Scene(dataset, gaussians)
    gaussians.training_setup(opt)
    if checkpoint:
        (model_params, first_iter) = torch.load(checkpoint)
        gaussians.restore(model_params, opt)
        print(" ----- checkpoint loaded from", checkpoint)

    bg_color = [1, 1, 1] if dataset.white_background else [0, 0, 0]
    background = torch.tensor(bg_color, dtype=torch.float32, device="cuda")
    iter_start = torch.cuda.Event(enable_timing = True)
    iter_end = torch.cuda.Event(enable_timing = True)

    trainCameras = scene.getTrainCameras().copy()
    testCameras = scene.getTestCameras().copy()
    allCameras = trainCameras + testCameras
    
    # highresolution index
    highresolution_index = []
    for index, camera in enumerate(trainCameras):
        if camera.image_width >= 800:
            highresolution_index.append(index)

    gaussians.compute_3D_filter(cameras=trainCameras)

    viewpoint_stack = None
    ema_loss_for_log = 0.0
    progress_bar = tqdm(range(first_iter, opt.iterations), desc="Training progress")
    
    first_iter += 1

    num_points = {}
    
    for iteration in range(first_iter, opt.iterations + 1):        
        if network_gui.conn == None:
            network_gui.try_connect()
        while network_gui.conn != None:
            try:
                net_image_bytes = None
                custom_cam, do_training, pipe.convert_SHs_python, pipe.compute_cov3D_python, keep_alive, scaling_modifer = network_gui.receive()
                if custom_cam != None:
                    net_image = render(custom_cam, gaussians, pipe, background, scaling_modifer)["render"]
                    net_image_bytes = memoryview((torch.clamp(net_image, min=0, max=1.0) * 255).byte().permute(1, 2, 0).contiguous().cpu().numpy())
                network_gui.send(net_image_bytes, dataset.source_path)
                if do_training and ((iteration < int(opt.iterations)) or not keep_alive):
                    break
            except Exception as e:
                network_gui.conn = None

        iter_start.record()

        gaussians.update_learning_rate(iteration)

        # Every 1000 its we increase the levels of SH up to a maximum degree
        if iteration % 1000 == 0:
            gaussians.oneupSHdegree()

        # Pick a random Camera
        if not viewpoint_stack:
            viewpoint_stack = scene.getTrainCameras().copy()
        pop_id = randint(0, len(viewpoint_stack)-1)
        viewpoint_cam = viewpoint_stack.pop(pop_id)
        
        if random.random() < 0.3 and dataset.sample_more_highres:
            viewpoint_cam = trainCameras[highresolution_index[randint(0, len(highresolution_index)-1)]]
            
        # Render
        if (iteration - 1) == debug_from:
            pipe.debug = True

        #TODO ignore border pixels
        if dataset.ray_jitter:
            subpixel_offset = torch.rand((int(viewpoint_cam.image_height), int(viewpoint_cam.image_width), 2), dtype=torch.float32, device="cuda") - 0.5
            # subpixel_offset *= 0.0
        else:
            subpixel_offset = None
        render_pkg = render(viewpoint_cam, gaussians, pipe, background, kernel_size=dataset.kernel_size, subpixel_offset=subpixel_offset)
        image, viewspace_point_tensor, visibility_filter, radii = render_pkg["render"], render_pkg["viewspace_points"], render_pkg["visibility_filter"], render_pkg["radii"]

        # Loss
        gt_image = viewpoint_cam.original_image.cuda()
        # sample gt_image with subpixel offset
        if dataset.resample_gt_image:
            gt_image = create_offset_gt(gt_image, subpixel_offset)
        Ll1 = l1_loss(image, gt_image)
        loss = (1.0 - opt.lambda_dssim) * Ll1 + opt.lambda_dssim * (1.0 - ssim(image, gt_image))        
        loss.backward()
        iter_end.record()

        with torch.no_grad():
            # Progress bar
            ema_loss_for_log = 0.4 * loss.item() + 0.6 * ema_loss_for_log
            if iteration % 10 == 0:
                progress_bar.set_postfix({"Loss": f"{ema_loss_for_log:.{7}f}"})
                progress_bar.update(10)
            if iteration == opt.iterations:
                progress_bar.close()

            # Log and save
            training_report(tb_writer, iteration, Ll1, loss, l1_loss, iter_start.elapsed_time(iter_end), testing_iterations, scene, render, (pipe, background, dataset.kernel_size))
            if (iteration in saving_iterations):
                print("\n[ITER {}] Saving Gaussians".format(iteration))
                scene.save(iteration)
            if (iteration == opt.iterations):
                print("\n[ITER {}] Saving Gaussians".format(iteration))
                scene.save(iteration)
            if iteration % 1000 == 0:
                print("\n[ITER {}] Saving Gaussians".format(iteration))
                scene.save(iteration, output_folder="iteration_29000")

            if not args.freeze_point:
                # Densification
                if iteration < opt.densify_until_iter:
                    # Keep track of max radii in image-space for pruning
                    gaussians.max_radii2D[visibility_filter] = torch.max(gaussians.max_radii2D[visibility_filter], radii[visibility_filter])
                    gaussians.add_densification_stats(viewspace_point_tensor, visibility_filter)

                    if iteration > opt.densify_from_iter and iteration % opt.densification_interval == 0:
                        size_threshold = 20 if iteration > opt.opacity_reset_interval else None
                        gaussians.densify_and_prune(opt.densify_grad_threshold, 0.005, scene.cameras_extent, size_threshold)
                        gaussians.compute_3D_filter(cameras=trainCameras)

                    if iteration % opt.opacity_reset_interval == 0 or (dataset.white_background and iteration == opt.densify_from_iter):
                        gaussians.reset_opacity()

            if iteration % 100 == 0 and iteration > opt.densify_until_iter:
                if iteration < opt.iterations - 100:
                    gaussians.compute_3D_filter(cameras=trainCameras)
            
            if iteration % 500 == 0:
                num_points[iteration] = gaussians.get_xyz.shape[0]
                print("number of points:", gaussians._xyz.shape[0])
            
            if iteration == opt.iterations:
                with open(os.path.join(args.output_folder, "num_points.json"), "w") as f:
                    json.dump(num_points, f)
        
            # Optimizer step
            if iteration < opt.iterations:
                gaussians.optimizer.step()
                gaussians.optimizer.zero_grad(set_to_none = True)

            if (iteration in checkpoint_iterations):
                print("\n[ITER {}] Saving Checkpoint".format(iteration))
                torch.save((gaussians.capture(), iteration), scene.model_path + "/chkpnt" + str(iteration) + ".pth")

def prepare_output_and_logger(args):
    if not args.model_path:
        if os.getenv('OAR_JOB_ID'):
            unique_str=os.getenv('OAR_JOB_ID')
        else:
            unique_str = str(uuid.uuid4())
        args.model_path = os.path.join("./output/", unique_str[0:10])
        
    # Set up output folder
    print("Output folder: {}".format(args.model_path))
    os.makedirs(args.model_path, exist_ok = True)
    with open(os.path.join(args.model_path, "cfg_args"), 'w') as cfg_log_f:
        cfg_log_f.write(str(Namespace(**vars(args))))

    # Create Tensorboard writer
    tb_writer = None
    if TENSORBOARD_FOUND:
        tb_writer = SummaryWriter(args.model_path)
    else:
        print("Tensorboard not available: not logging progress")
    return tb_writer

def training_report(tb_writer, iteration, Ll1, loss, l1_loss, elapsed, testing_iterations, scene : Scene, renderFunc, renderArgs):
    if tb_writer:
        tb_writer.add_scalar('train_loss_patches/l1_loss', Ll1.item(), iteration)
        tb_writer.add_scalar('train_loss_patches/total_loss', loss.item(), iteration)
        tb_writer.add_scalar('iter_time', elapsed, iteration)

    # Report test and samples of training set
    if iteration in testing_iterations:
        torch.cuda.empty_cache()
        validation_configs = ({'name': 'test', 'cameras' : scene.getTestCameras()}, 
                              {'name': 'train', 'cameras' : [scene.getTrainCameras()[idx % len(scene.getTrainCameras())] for idx in range(5, 30, 5)]})

        for config in validation_configs:
            if config['cameras'] and len(config['cameras']) > 0:
                l1_test = 0.0
                psnr_test = 0.0
                for idx, viewpoint in enumerate(config['cameras']):
                    image = torch.clamp(renderFunc(viewpoint, scene.gaussians, *renderArgs)["render"], 0.0, 1.0)
                    gt_image = torch.clamp(viewpoint.original_image.to("cuda"), 0.0, 1.0)
                    if tb_writer and (idx < 5):
                        tb_writer.add_images(config['name'] + "_view_{}/render".format(viewpoint.image_name), image[None], global_step=iteration)
                        if iteration == testing_iterations[0]:
                            tb_writer.add_images(config['name'] + "_view_{}/ground_truth".format(viewpoint.image_name), gt_image[None], global_step=iteration)
                    l1_test += l1_loss(image, gt_image).mean().double()
                    psnr_test += psnr(image, gt_image).mean().double()
                psnr_test /= len(config['cameras'])
                l1_test /= len(config['cameras'])          
                print("\n[ITER {}] Evaluating {}: L1 {} PSNR {}".format(iteration, config['name'], l1_test, psnr_test))
                if tb_writer:
                    tb_writer.add_scalar(config['name'] + '/loss_viewpoint - l1_loss', l1_test, iteration)
                    tb_writer.add_scalar(config['name'] + '/loss_viewpoint - psnr', psnr_test, iteration)

        if tb_writer:
            try:
                tb_writer.add_histogram("scene/opacity_histogram", scene.gaussians.get_opacity, iteration)
            except:
                pass
            tb_writer.add_scalar('total_points', scene.gaussians.get_xyz.shape[0], iteration)
        torch.cuda.empty_cache()

def parse_args():
    parser = ArgumentParser(description="Training script parameters")
    lp = ModelParams(parser)
    op = OptimizationParams(parser)
    pp = PipelineParams(parser)
    parser.add_argument('--ip', type=str, default="127.0.0.1")
    parser.add_argument('--port', type=int, default=6009)
    parser.add_argument('--debug_from', type=int, default=-1)
    parser.add_argument('--detect_anomaly', action='store_true', default=False)
    parser.add_argument("--test_iterations", nargs="+", type=int, default=[7_000, 30_000])
    parser.add_argument("--save_iterations", nargs="+", type=int, default=[7_000, 30_000])
    parser.add_argument("--quiet", action="store_true")
    parser.add_argument("--checkpoint_iterations", nargs="+", type=int, default=[])
    parser.add_argument("--start_checkpoint", type=str, default = None)
    parser.add_argument("--output_folder", type=str)
    parser.add_argument("--load_pretrain", action="store_true")
    parser.add_argument(
        "--pretrain_iteration",
        type=int,
        default=30000,
        help="Iteration to load from -m when --load_pretrain is enabled.",
    )
    parser.add_argument("--freeze_point", action="store_true")
    parser.add_argument("--SR_GS", action="store_true")
    parser.add_argument("--fidelity_train_en", action="store_true")
    parser.add_argument("--prune_init_en", action="store_true")
    parser.add_argument("--seed", type=int, default=999)
    parser.add_argument("--edge_aware_loss_en", action="store_true")
    parser.add_argument("--lpips_wt", type=float, default=0.2)
    parser.add_argument("--wt_lr", type=float, default=0.4)
    parser.add_argument("--densify_end", type=int, default=15000)
    parser.add_argument("--original", action="store_true")
    parser.add_argument(
        "--sr_backend",
        type=str,
        default="stablesr",
        choices=["stablesr", "offline"],
        help="Use the original StableSR loop or load precomputed pseudo-HR images.",
    )
    parser.add_argument(
        "--offline_sr_dir",
        type=str,
        default=None,
        help="Directory of precomputed pseudo-HR images for --sr_backend offline.",
    )
    parser.add_argument(
        "--offline_sr_resize",
        action="store_true",
        help="Resize offline SR targets to the refinement camera size. Debug only; prefer exact-size images.",
    )
    parser.add_argument(
        "--skip_train_results",
        action="store_true",
        help="Skip saving full train-view renders at the end of a refinement stage.",
    )
    #############################################
    #### From Stable SR code ####
    #############################################
    parser.add_argument(
		"--init-img",
		type=str,
		nargs="?",
		help="path to the input image",
		default="inputs/user_upload"
	)
    parser.add_argument(
		"--outdir",
		type=str,
		nargs="?",
		help="dir to write results to",
		default="outputs/user_upload"
	)
    parser.add_argument(
		"--ddpm_steps",
		type=int,
		default=1000,
		help="number of ddpm sampling steps",
	)
    parser.add_argument(
		"--n_iter",
		type=int,
		default=1,
		help="sample this often",
	)
    parser.add_argument(
		"--C",
		type=int,
		default=4,
		help="latent channels",
	)
    parser.add_argument(
		"--f",
		type=int,
		default=8,
		help="downsampling factor, most often 8 or 16",
	)
    parser.add_argument(
		"--n_samples",
		type=int,
		default=1,
		help="how many samples to produce for each given prompt. A.k.a batch size",
	)
    parser.add_argument(
		"--config",
		type=str,
		default="configs/stable-diffusion/v1-inference.yaml",
		help="path to config which constructs model",
	)
    parser.add_argument(
		"--ckpt",
		type=str,
		default="./stablesr_000117.ckpt",
		help="path to checkpoint of model",
	)
    parser.add_argument(
		"--vqgan_ckpt",
		type=str,
		default="./vqgan_cfw_00011.ckpt",
		help="path to checkpoint of VQGAN model",
	)  
    parser.add_argument(
		"--precision",
		type=str,
		help="evaluate at this precision",
		choices=["full", "autocast"],
		default="autocast"
	)
    parser.add_argument(
		"--dec_w",
		type=float,
		default=0.5,
		help="weight for combining VQGAN and Diffusion",
	)
    parser.add_argument(
		"--tile_overlap",
		type=int,
		default=32,
		help="tile overlap size (in latent)",
	)
    parser.add_argument(
		"--upscale",
		type=float,
		default=4.0,
		help="upsample scale",
	)
    parser.add_argument(
		"--colorfix_type",
		type=str,
		default="nofix",
		help="Color fix type to adjust the color of HR result according to LR input: adain (used in paper); wavelet; nofix",
	)
    parser.add_argument(
		"--vqgantile_stride",
		type=int,
		default=1000,
		help="the stride for tile operation before VQGAN decoder (in pixel)",
	)
    parser.add_argument(
		"--vqgantile_size",
		type=int,
		default=1280,
		help="the size for tile operation before VQGAN decoder (in pixel)",
	)
    parser.add_argument(
        "--input_size",
        type=int,
        default=512,
        help="input size",
    )
    
    args = parser.parse_args(sys.argv[1:])
    args.save_iterations.append(args.iterations)
    
    return lp, op, pp, args

if __name__ == "__main__":
    lp, op, pp, args = parse_args()
    print("Optimizing " + args.model_path)    
    # Set up random seed
    torch.manual_seed(args.seed)
    random.seed(args.seed)
    np.random.seed(args.seed)
    torch.backends.cudnn.benchmark = False
    torch.backends.cudnn.deterministic = True
    random.seed(args.seed)
    seed_everything(args.seed)
    
    # Initialize system state (RNG)
    safe_state(args.quiet)

    # Start GUI server, configure and run training
    network_gui.init(args.ip, args.port)
    torch.autograd.set_detect_anomaly(args.detect_anomaly)    
        
    if args.original:
        training(lp.extract(args), op.extract(args), pp.extract(args), args.test_iterations, args.save_iterations, args.checkpoint_iterations, args.start_checkpoint, args.debug_from, args)
    elif args.sr_backend == "offline":
        train_offline_sr(lp.extract(args), op.extract(args), pp.extract(args), args.test_iterations, args.save_iterations, args.checkpoint_iterations, args.start_checkpoint, args.debug_from, args)
    else:
        train_proposed(lp.extract(args), op.extract(args), pp.extract(args), args.test_iterations, args.save_iterations, args.checkpoint_iterations, args.start_checkpoint, args.debug_from, args)    
    # All done
    print("\nTraining complete.")