Upload train_3dsr.py

train_3dsr.py

@@ -0,0 +1,1178 @@
+#
+# 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=30000, 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("--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.")