Upload Models/RAR_infer.py with huggingface_hub

Models/RAR_infer.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """
-CUDA_VISIBLE_DEVICES=0 streamlit run RAR_infer.py
+CUDA_VISIBLE_DEVICES=0 streamlit run run.py
 
 CUDA_VISIBLE_DEVICES=0 streamlit run RAR_infer.py \
       --config=./configs/infer_cfg.yaml \
@@ -81,6 +81,8 @@ from diffusion.model.sd35 import load_scheduler, load_vae, load_mmdit, load_text
 import torchvision.transforms.functional as F 
 from torchvision.transforms import InterpolationMode
 from diffusion.model.utils import set_fp32_attention, set_grad_checkpoint
+# Interface
+import streamlit as st
 
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
@@ -278,242 +280,256 @@ def get_args():
     parser.add_argument("--config", type=str, help="config")
     return parser.parse_known_args()[0]
 
-#### Main
-# [0]: Config
-## ======================================================================
-# args = get_args()
-config = args = pyrallis.parse(config_class=SanaInference, config_path="./configs/infer_cfg.yaml")
-args.image_size = config.model.image_size
-if args.resolution:
-    args.image_size = args.resolution
-set_env(args.seed)
-
-if args.weight_type == "bf16":
-    weight_type = torch.bfloat16
-elif args.weight_type == "fp16":
-    weight_type = torch.float16
-elif args.weight_type == "fp32":
-    weight_type = torch.float32
-else:
-    raise KeyError(f"Unsupported Weight Type: {args.weight_type}")
-
-# only support fixed latent size currently
-latent_size = args.image_size // config.vae.vae_downsample_rate
-max_sequence_length = config.text_encoder.model_max_length
-flow_shift = config.scheduler.flow_shift
-pag_applied_layers = config.model.pag_applied_layers
-guidance_type = "classifier-free_PAG"
-assert (
-    isinstance(args.interval_guidance, list)
-    and len(args.interval_guidance) == 2
-    and args.interval_guidance[0] <= args.interval_guidance[1]
-)
-args.interval_guidance = [max(0, args.interval_guidance[0]), min(1, args.interval_guidance[1])]
-
-# tags
-match = re.search(r".*epoch_(\d+).*step_(\d+).*", args.model_path)
-epoch_name, step_name = match.groups() if match else ("unknown", "unknown")
-guidance_type = guidance_type_select(guidance_type, args.pag_scale, config.model.attn_type)
-
-# Sampler Config
-args.sampling_algo = (
-    args.sampling_algo
-    if ("flow" not in args.model_path or args.sampling_algo == "flow_dpm-solver")
-    else "flow_euler"
-)
-assert args.sampling_algo in ["flow_dpm-solver", "flow_euler"], f"Only support flow_dpm-solver and flow_euler now, but received {args.sampling_algo}."
-sample_steps_dict = {"flow_dpm-solver": 20, "flow_euler": 28} # {"dpm-solver": 20, "sa-solver": 25, "flow_dpm-solver": 20, "flow_euler": 28}
-sample_steps = args.step if args.step != -1 else sample_steps_dict[args.sampling_algo]
-
-# output setting
-work_dir = args.work_dir
-# work_dir = os.path.join(work_dir, f"ep{epoch_name}_it{step_name}_r{args.image_size}_s{args.step}_n{args.num_rounds}_{args.flow_type}") # ep100_r256_s4_n4_p2p
-config.work_dir = work_dir
-os.umask(0o000)
-save_root = work_dir # $work_dirs/online/ep100_it32500_s4_n4_p2p/SOTS
-os.makedirs(work_dir, exist_ok=True)
-save_detail = args.detail
-
-# logger
-num_gpus = torch.cuda.device_count()
-logger = setup_logger('SD35M', save_root, 0)
-logger.info("##############################################################")
-logger.info('Using {} GPUS'.format(num_gpus))
-logger.info('Running with config:\n{}'.format(config))
-logger.info('Running with args:\n{}'.format(args))
-logger.info(f"Sampler {args.sampling_algo}")
-logger.info(colored(f"Save Results: {save_root}", "blue"))
-logger.info("##############################################################")
-# [1]: model define
-## ======================================================================
-weight_dtype = weight_type # get_weight_dtype(config.model.mixed_precision)
-device = "cuda" if torch.cuda.is_available() else "cpu"
-## [1-1]: Loading VAE ...
-vae = None
-vae_dtype = get_weight_dtype(config.vae.weight_dtype)
-if not config.data.load_vae_feat:
-    if config.vae.vae_type == "SDVAE":
-        vae = load_vae(config.vae.vae_pretrained, device)
-        vae = vae.to(vae_dtype).eval()
+@st.cache_resource
+def load_rar_model():
+    # [0]: Config
+    ## ======================================================================
+    # args = get_args()
+    config = args = pyrallis.parse(config_class=SanaInference, config_path="./configs/infer_cfg.yaml")
+    args.image_size = config.model.image_size
+    if args.resolution:
+        args.image_size = args.resolution
+    set_env(args.seed)
+
+    if args.weight_type == "bf16":
+        weight_type = torch.bfloat16
+    elif args.weight_type == "fp16":
+        weight_type = torch.float16
+    elif args.weight_type == "fp32":
+        weight_type = torch.float32
     else:
-        raise KeyError(f"Only support VAE: 'SDVAE', but received {config.vae.vae_type}.")
-vae.to(vae_dtype)
-logger.info("##############################################################")
-logger.info(f"VAE type: {config.vae.vae_type}, path: {config.vae.vae_pretrained}, weight_dtype: {vae_dtype}")
-logger.info(f"VAE Params: {sum(p.numel() for p in vae.parameters())/1e6} M, dtype: {next(vae.parameters()).dtype}")
-logger.info("##############################################################")
-    
-# [1-2]: Loading Tokenizer ...
-text_encoder = None
-logger.info("##############################################################")
-logger.info(f"text_encoder type: {config.text_encoder.text_encoder_name}, path: {config.text_encoder.text_encoder_pretrained}")
-if config.text_encoder.text_encoder_name == "sd35-text":
-    text_encoder = load_text_encoder(config.text_encoder.text_encoder_pretrained, device)
-logger.info("##############################################################")
-os.environ["AUTOCAST_LINEAR_ATTN"] = "true" if config.model.autocast_linear_attn else "false"
-## [1-3]: Loading IQA model ...
-logger.info("##############################################################")
-if not args.assessment_model:
-    args.assessment_model = "SDQA"
-logger.info(f"IQA type: {args.assessment_model}, config: {args.assessment_config}")
-if args.assessment_model == "SDQA":
-    from iqa import DepictQA, load_pretrained_weights
-    assert os.path.isfile(args.assessment_config)
-    ## loading cfg
-    with open(args.assessment_config, "r") as f:
-        iqa_cfg = EasyDict(yaml.safe_load(f))
-    ## Model
-    assessment = DepictQA(iqa_cfg, training=False)
-    assessment = load_pretrained_weights(iqa_cfg, assessment, logger=None)
-assessment.eval().to(weight_dtype).to(device)
-logger.propagate = False
-logger.info(f"IQA Params: {sum(p.numel() for p in assessment.parameters())/1e6} M, dtype: {next(assessment.parameters()).dtype}")
-logger.info("##############################################################")
-## [1-4]: Loading Connector model ...
-connector_dtype = torch.float32
-logger.info("##############################################################")
-logger.info(f"Connector type: {config.connector.model}, path: {config.connector.model_pretrained}, weight_dtype: {connector_dtype}")
-if config.connector.model == "QFormer":
-    from diffusion.model.qa_connector import QFormer
-    connector = QFormer(
-        hidden_dim = config.connector.hidden_dim,
-        layers = config.connector.layers,
-        heads = config.connector.heads
+        raise KeyError(f"Unsupported Weight Type: {args.weight_type}")
+
+    # only support fixed latent size currently
+    flow_shift = config.scheduler.flow_shift
+    pag_applied_layers = config.model.pag_applied_layers
+    guidance_type = "classifier-free_PAG"
+    assert (
+        isinstance(args.interval_guidance, list)
+        and len(args.interval_guidance) == 2
+        and args.interval_guidance[0] <= args.interval_guidance[1]
     )
-else:
-    raise KeyError("Unknown Connector Type: only support [QFormer], but recieve {config.connector.model}.")
-# if config.connector.load_from:
-    # logger.info(f"Loading Pre-trained Weight for Connector: {config.connector.load_from}")
-    # state_dict = torch.load(config.connector.load_from, map_location='cpu')
-    # missing, unexpected = connector.load_state_dict(state_dict["state_dict"], strict=False)
-    # logger.warning(f"Missing keys: {missing}")
-    # logger.warning(f"Unexpected keys: {unexpected}")
-connector = connector.eval().to(weight_dtype).to(device)
-logger.info(f"Connector Params: {sum(p.numel() for p in connector.parameters())/1e6} M, dtype: {next(connector.parameters()).dtype}")
-logger.info("##############################################################")
-# [1-5]: Loading DiT model ...
-if config.model.model == "SD35M_P2P":
-    assert args.flow_type == "p2p", f"Error: Model {config.model.model} only support 'p2p' mode."
-    from diffusion.model.sd35 import load_mmdit_p2p
-    DiT = load_mmdit_p2p(
-                       config.model.model_pretrained, 
-                       config.model.shift, 
-                       False, 
-                       device, 
-                       config.model.image_size, 
-                       config.model.input_channel,
-                    ).eval().to(device)
-elif config.model.model == "SD35M_D2C":
-    assert args.flow_type == "d2c", f"Error: Model {config.model.model} only support 'd2c' mode."
-    from diffusion.model.sd35 import load_mmdit
-    DiT = load_mmdit(
-                       config.model.model_pretrained, 
-                       config.model.shift, 
-                       False, 
-                       device, 
-                       config.model.image_size, 
-                       config.model.input_channel,
-                    ).eval().to(device)
-else:
-    raise KeyError(f"Only support Model: 'SD35M_P2P' or 'SD35M_D2C', but received {config.model.model}.")
- ## Load model
-state_dict = torch.load(config.model.load_from)
-if config.model.load_from.endswith(".bin"):
-    logger.info("Loading fsdp bin checkpoint....")
-    old_state_dict = state_dict
-    state_dict = dict()
-    state_dict["state_dict"] = old_state_dict
-if "pos_embed" in state_dict["state_dict"]:
-    del state_dict["state_dict"]["pos_embed"]
-missing, unexpected = DiT.load_state_dict(state_dict["state_dict"], strict=False)
-DiT.eval().to(weight_dtype)
-dit_dtype = weight_dtype
-logger.info("##############################################################")
-logger.info("# % Model Define .....  ")
-logger.info(f"Inference with {weight_dtype}, default guidance_type: {guidance_type}, flow_shift: {flow_shift}")
-logger.info(f"{DiT.__class__.__name__}:{config.model.model}, Model Parameters: {sum(p.numel() for p in DiT.parameters()):,}")
-logger.info("Generating sample from ckpt: %s" % config.model.load_from)
-logger.warning(f"Missing keys: {missing}")
-logger.warning(f"Unexpected keys: {unexpected}")
-logger.info(f"Parameter of DiT: {sum(p.numel() for p in DiT.parameters()) / 1000000} M")
-logger.info("##############################################################")
-# [1-6]: Combination Model
-model = IQAIR(DiT, connector, assessment, device)
-logger.info("##############################################################")
-logger.info("Summary: IQAIR")
-for param in model.parameters():
-    param.requires_grad = False
-num_total_params = sum(p.numel() for p in model.parameters())
-logger.info(f"All params: {round(num_total_params/1e6, 3)}M")
-logger.info("##############################################################")
-## Load model
-if os.path.isfile(args.model_path):
-    state_dict = torch.load(args.model_path)
-    if args.model_path.endswith(".bin"):
+    args.interval_guidance = [max(0, args.interval_guidance[0]), min(1, args.interval_guidance[1])]
+
+    # tags
+    match = re.search(r".*epoch_(\d+).*step_(\d+).*", args.model_path)
+    epoch_name, step_name = match.groups() if match else ("unknown", "unknown")
+    guidance_type = guidance_type_select(guidance_type, args.pag_scale, config.model.attn_type)
+
+    # Sampler Config
+    args.sampling_algo = (
+        args.sampling_algo
+        if ("flow" not in args.model_path or args.sampling_algo == "flow_dpm-solver")
+        else "flow_euler"
+    )
+    assert args.sampling_algo in ["flow_dpm-solver", "flow_euler"], f"Only support flow_dpm-solver and flow_euler now, but received {args.sampling_algo}."
+    sample_steps_dict = {"flow_dpm-solver": 20, "flow_euler": 28} # {"dpm-solver": 20, "sa-solver": 25, "flow_dpm-solver": 20, "flow_euler": 28}
+    sample_steps = args.step if args.step != -1 else sample_steps_dict[args.sampling_algo]
+
+    # output setting
+    work_dir = args.work_dir
+    # work_dir = os.path.join(work_dir, f"ep{epoch_name}_it{step_name}_r{args.image_size}_s{args.step}_n{args.num_rounds}_{args.flow_type}") # ep100_r256_s4_n4_p2p
+    config.work_dir = work_dir
+    os.umask(0o000)
+    save_root = work_dir # $work_dirs/online/ep100_it32500_s4_n4_p2p/SOTS
+    os.makedirs(work_dir, exist_ok=True)
+    save_detail = args.detail
+
+    # logger
+    num_gpus = torch.cuda.device_count()
+    logger = setup_logger('SD35M', save_root, 0)
+    logger.info("##############################################################")
+    logger.info('Using {} GPUS'.format(num_gpus))
+    logger.info('Running with config:\n{}'.format(config))
+    logger.info('Running with args:\n{}'.format(args))
+    logger.info(f"Sampler {args.sampling_algo}")
+    logger.info(colored(f"Save Results: {save_root}", "blue"))
+    logger.info("##############################################################")
+    # [1]: model define
+    ## ======================================================================
+    weight_dtype = weight_type # get_weight_dtype(config.model.mixed_precision)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    ## [1-1]: Loading VAE ...
+    vae = None
+    vae_dtype = get_weight_dtype(config.vae.weight_dtype)
+    if not config.data.load_vae_feat:
+        if config.vae.vae_type == "SDVAE":
+            vae = load_vae(config.vae.vae_pretrained, device)
+            vae = vae.to(vae_dtype).eval()
+        else:
+            raise KeyError(f"Only support VAE: 'SDVAE', but received {config.vae.vae_type}.")
+    vae.to(vae_dtype)
+    logger.info("##############################################################")
+    logger.info(f"VAE type: {config.vae.vae_type}, path: {config.vae.vae_pretrained}, weight_dtype: {vae_dtype}")
+    logger.info(f"VAE Params: {sum(p.numel() for p in vae.parameters())/1e6} M, dtype: {next(vae.parameters()).dtype}")
+    logger.info("##############################################################")
+        
+    # [1-2]: Loading Tokenizer ...
+    text_encoder = None
+    logger.info("##############################################################")
+    logger.info(f"text_encoder type: {config.text_encoder.text_encoder_name}, path: {config.text_encoder.text_encoder_pretrained}")
+    if config.text_encoder.text_encoder_name == "sd35-text":
+        text_encoder = load_text_encoder(config.text_encoder.text_encoder_pretrained, device)
+    logger.info("##############################################################")
+    os.environ["AUTOCAST_LINEAR_ATTN"] = "true" if config.model.autocast_linear_attn else "false"
+    ## [1-3]: Loading IQA model ...
+    logger.info("##############################################################")
+    if not args.assessment_model:
+        args.assessment_model = "SDQA"
+    logger.info(f"IQA type: {args.assessment_model}, config: {args.assessment_config}")
+    if args.assessment_model == "SDQA":
+        from iqa import DepictQA, load_pretrained_weights
+        assert os.path.isfile(args.assessment_config)
+        ## loading cfg
+        with open(args.assessment_config, "r") as f:
+            iqa_cfg = EasyDict(yaml.safe_load(f))
+        ## Model
+        assessment = DepictQA(iqa_cfg, training=False)
+        assessment = load_pretrained_weights(iqa_cfg, assessment, logger=None)
+    assessment.eval().to(weight_dtype).to(device)
+    logger.propagate = False
+    logger.info(f"IQA Params: {sum(p.numel() for p in assessment.parameters())/1e6} M, dtype: {next(assessment.parameters()).dtype}")
+    logger.info("##############################################################")
+    ## [1-4]: Loading Connector model ...
+    connector_dtype = torch.float32
+    logger.info("##############################################################")
+    logger.info(f"Connector type: {config.connector.model}, path: {config.connector.model_pretrained}, weight_dtype: {connector_dtype}")
+    if config.connector.model == "QFormer":
+        from diffusion.model.qa_connector import QFormer
+        connector = QFormer(
+            hidden_dim = config.connector.hidden_dim,
+            layers = config.connector.layers,
+            heads = config.connector.heads
+        )
+    else:
+        raise KeyError("Unknown Connector Type: only support [QFormer], but recieve {config.connector.model}.")
+    # if config.connector.load_from:
+        # logger.info(f"Loading Pre-trained Weight for Connector: {config.connector.load_from}")
+        # state_dict = torch.load(config.connector.load_from, map_location='cpu')
+        # missing, unexpected = connector.load_state_dict(state_dict["state_dict"], strict=False)
+        # logger.warning(f"Missing keys: {missing}")
+        # logger.warning(f"Unexpected keys: {unexpected}")
+    connector = connector.eval().to(weight_dtype).to(device)
+    logger.info(f"Connector Params: {sum(p.numel() for p in connector.parameters())/1e6} M, dtype: {next(connector.parameters()).dtype}")
+    logger.info("##############################################################")
+    # [1-5]: Loading DiT model ...
+    if config.model.model == "SD35M_P2P":
+        assert args.flow_type == "p2p", f"Error: Model {config.model.model} only support 'p2p' mode."
+        from diffusion.model.sd35 import load_mmdit_p2p
+        DiT = load_mmdit_p2p(
+                        config.model.model_pretrained, 
+                        config.model.shift, 
+                        False, 
+                        device, 
+                        config.model.image_size, 
+                        config.model.input_channel,
+                        ).eval().to(device)
+    elif config.model.model == "SD35M_D2C":
+        assert args.flow_type == "d2c", f"Error: Model {config.model.model} only support 'd2c' mode."
+        from diffusion.model.sd35 import load_mmdit
+        DiT = load_mmdit(
+                        config.model.model_pretrained, 
+                        config.model.shift, 
+                        False, 
+                        device, 
+                        config.model.image_size, 
+                        config.model.input_channel,
+                        ).eval().to(device)
+    else:
+        raise KeyError(f"Only support Model: 'SD35M_P2P' or 'SD35M_D2C', but received {config.model.model}.")
+    ## Load model
+    state_dict = torch.load(config.model.load_from)
+    if config.model.load_from.endswith(".bin"):
         logger.info("Loading fsdp bin checkpoint....")
         old_state_dict = state_dict
         state_dict = dict()
         state_dict["state_dict"] = old_state_dict
     if "pos_embed" in state_dict["state_dict"]:
         del state_dict["state_dict"]["pos_embed"]
-    missing, unexpected = model.load_state_dict(state_dict["state_dict"], strict=False)
-    model.eval().to(weight_dtype)
+    missing, unexpected = DiT.load_state_dict(state_dict["state_dict"], strict=False)
+    DiT.eval().to(weight_dtype)
     dit_dtype = weight_dtype
     logger.info("##############################################################")
     logger.info("# % Model Define .....  ")
     logger.info(f"Inference with {weight_dtype}, default guidance_type: {guidance_type}, flow_shift: {flow_shift}")
-    logger.info(f"{model.__class__.__name__}:{config.model.model}, Model Parameters: {sum(p.numel() for p in model.parameters()):,}")
-    logger.info("Generating sample from ckpt: %s" % args.model_path)
-    missing_ckpt = []
-    for m in missing:
-        if "llm" in m and "lora" not in m:
-            continue
-        missing_ckpt.append(m)
-    logger.warning(f"Missing keys: {missing_ckpt}")
+    logger.info(f"{DiT.__class__.__name__}:{config.model.model}, Model Parameters: {sum(p.numel() for p in DiT.parameters()):,}")
+    logger.info("Generating sample from ckpt: %s" % config.model.load_from)
+    logger.warning(f"Missing keys: {missing}")
     logger.warning(f"Unexpected keys: {unexpected}")
-    logger.info(f"Parameter of Model: {sum(p.numel() for p in model.parameters()) / 1000000} M")
+    logger.info(f"Parameter of DiT: {sum(p.numel() for p in DiT.parameters()) / 1000000} M")
     logger.info("##############################################################")
-else:
+    # [1-6]: Combination Model
+    model = IQAIR(DiT, connector, assessment, device)
     logger.info("##############################################################")
-    logger.info("Combination Model is inference from pre-trained weight!")
+    logger.info("Summary: IQAIR")
+    for param in model.parameters():
+        param.requires_grad = False
+    num_total_params = sum(p.numel() for p in model.parameters())
+    logger.info(f"All params: {round(num_total_params/1e6, 3)}M")
     logger.info("##############################################################")
+    ## Load model
+    if os.path.isfile(args.model_path):
+        state_dict = torch.load(args.model_path)
+        if args.model_path.endswith(".bin"):
+            logger.info("Loading fsdp bin checkpoint....")
+            old_state_dict = state_dict
+            state_dict = dict()
+            state_dict["state_dict"] = old_state_dict
+        if "pos_embed" in state_dict["state_dict"]:
+            del state_dict["state_dict"]["pos_embed"]
+        missing, unexpected = model.load_state_dict(state_dict["state_dict"], strict=False)
+        model.eval().to(weight_dtype)
+        dit_dtype = weight_dtype
+        logger.info("##############################################################")
+        logger.info("# % Model Define .....  ")
+        logger.info(f"Inference with {weight_dtype}, default guidance_type: {guidance_type}, flow_shift: {flow_shift}")
+        logger.info(f"{model.__class__.__name__}:{config.model.model}, Model Parameters: {sum(p.numel() for p in model.parameters()):,}")
+        logger.info("Generating sample from ckpt: %s" % args.model_path)
+        missing_ckpt = []
+        for m in missing:
+            if "llm" in m and "lora" not in m:
+                continue
+            missing_ckpt.append(m)
+        logger.warning(f"Missing keys: {missing_ckpt}")
+        logger.warning(f"Unexpected keys: {unexpected}")
+        logger.info(f"Parameter of Model: {sum(p.numel() for p in model.parameters()) / 1000000} M")
+        logger.info("##############################################################")
+    else:
+        logger.info("##############################################################")
+        logger.info("Combination Model is inference from pre-trained weight!")
+        logger.info("##############################################################")
+    return model, vae, args, config, device
 
 # [2]: Inference
-def RAR_process(img, fname):
+def RAR_process(img, fname, model, vae, args, config, device):
     lq = image_process(img)
     lq = lq.to(device)
     bs = lq.shape[0]
+    latent_size = args.image_size // config.vae.vae_downsample_rate
     latent_size_h, latent_size_w = latent_size, latent_size
 
+    save_detail = args.detail
+    save_root = config.work_dir
     save_folder = os.path.join(save_root, fname)
     os.makedirs(save_folder, exist_ok=True)
     restore_results = [] 
     flag = 0
     # generator 
     generator = torch.Generator(device=device).manual_seed(args.seed)
-    dit_step = args.step
+    sample_steps = args.step
     num_rounds = args.num_rounds 
     print("="*20)
+
+    if args.weight_type == "bf16":
+        weight_dtype = torch.bfloat16
+    elif args.weight_type == "fp16":
+        weight_dtype = torch.float16
+    elif args.weight_type == "fp32":
+        weight_dtype = torch.float32
+    else:
+        raise KeyError(f"Unsupported Weight Type: {args.weight_type}")
+    dit_dtype = weight_dtype
+    vae_dtype = get_weight_dtype(config.vae.weight_dtype)
     # start sampling
     with torch.no_grad():
         ## [a1]: VAE
@@ -586,7 +602,7 @@ def RAR_process(img, fname):
                     guidance_type=guidance_type,
                     cfg_scale=args.cfg_scale,
                     pag_scale=args.pag_scale,
-                    pag_applied_layers=pag_applied_layers,
+                    pag_applied_layers=config.model.pag_applied_layers,
                     model_type="flow",
                     model_kwargs=model_kwargs,
                     schedule="FLOW",
@@ -598,7 +614,7 @@ def RAR_process(img, fname):
                     order=2,
                     skip_type="time_uniform_flow",
                     method="multistep",
-                    flow_shift=flow_shift,
+                    flow_shift=config.scheduler.flow_shift,
                 )
             elif args.sampling_algo == "flow_euler": 
                 flow_solver = FlowEuler(
@@ -643,12 +659,12 @@ def RAR_process(img, fname):
                 recon = vae.process_out(input_images.to(vae_dtype).to(device)).to(device)
                 recon = vae.decode(recon)
                 recon = torch.clamp((recon + 1.0) / 2.0, min=0.0, max=1.0)
-                restore_results.append(recon)
                 # save recon image
                 save_recon_path = os.path.join(save_folder, "%s_step%d_%s.png"%(fname.split(".")[0], n_round, prompts[0]))
                 save_recon = 255.0 * rearrange(recon[0], "c h w -> h w c")
                 save_recon = Image.fromarray(save_recon.type(torch.uint8).cpu().numpy())
                 save_recon.save(save_recon_path)
+                restore_results.append(save_recon)
                 return restore_results
             elif save_detail:
                 if flag == 1:
@@ -657,23 +673,17 @@ def RAR_process(img, fname):
                     recon = vae.process_out(samples.to(vae_dtype).to(device)).to(device)
                     recon = vae.decode(recon)
                     recon = torch.clamp((recon + 1.0) / 2.0, min=0.0, max=1.0)
-                    restore_results.append(recon)
                     # save recon image
                     save_recon_path = os.path.join(save_folder, "%s_step%d_%s.png"%(fname.split(".")[0], n_round, prompts[0]))
                     save_recon = 255.0 * rearrange(recon[0], "c h w -> h w c")
                     save_recon = Image.fromarray(save_recon.type(torch.uint8).cpu().numpy())
                     save_recon.save(save_recon_path)
-            
+                    restore_results.append(save_recon)
             # prepare for next round
             input_images = samples 
             torch.cuda.empty_cache()
 
 # ==========================================================================================================
-# Interface
-# sample_image = r"/home/CORP/hsiang.chen/Projects/Demo/sample_images/1/input.png"
-import streamlit as st
-import time 
-
 # root_dir = r"/home/CORP/hsiang.chen/Desktop/RAR_proj/Demo/"
 # -----------------------------
 # Predefined images – replace with your own paths
@@ -687,7 +697,10 @@ PREDEFINED_IMAGES = {
     "Sample 6": {"input":"sample_images/6/input.png", "output": ["sample_images/6/s1_noise.png", "sample_images/6/s2_LL.png"]},
     "Sample 7": {"input":"sample_images/7/input.png", "output": ["sample_images/7/s1_resolution.png", "sample_images/7/s2_LL.png", "sample_images/7/s3_haze.png"]},
     "Sample 8": {"input":"sample_images/8/input.png", "output": ["sample_images/8/s1_resolution.png", "sample_images/8/s2_none.png"]},
+    "Prague 1": {"input":"sample_images/realworld/IMG_9453.jpeg", "output": None},
+    "Prague 2": {"input":"sample_images/realworld/IMG_9525.jpeg", "output": None},
 }
+# sample_image = r"/home/CORP/hsiang.chen/Projects/Demo/sample_images/1/input.png"
 
 st.set_page_config(page_title="RAR Demo", layout="wide", initial_sidebar_state='expanded')
 st.title("AIC-C: RAR Demo")
@@ -709,13 +722,18 @@ selected_name = st.sidebar.selectbox(
 # Load image based on user choice
 input_image = None
 if upload_file is not None:
-    filename = os.path.basename(upload_file)
+    filename = upload_file.name
     input_image = Image.open(upload_file)
-elif selected_name != "None":
+    input_image = input_image.resize((256, 256))
+elif "Sample" in selected_name:
     # input_image = Image.open(os.path.join(root_dir, PREDEFINED_IMAGES[selected_name][0]))
     filename = os.path.basename(PREDEFINED_IMAGES[selected_name]["input"])
     input_image = Image.open(PREDEFINED_IMAGES[selected_name]["input"])
     input_image = input_image.resize((256, 256))
+elif "Prague" in selected_name:
+    filename = upload_file.name
+    input_image = Image.open(upload_file)
+    input_image = input_image.resize((256, 256))
 
 # =============================
 # Image Processing Section
@@ -730,11 +748,12 @@ def process_image(image: Image.Image, selected_name: str, filename: str):
     For now, we simply return the original image.
     """
     output_images = [image]
-    if selected_name != "None":
+    if "Sample" in selected_name:
         for image_path in PREDEFINED_IMAGES[selected_name]["output"]:
             output_images.append(Image.open(image_path))
     else:
-        restored_images = RAR_process(image, filename)
+        model, vae, args, config, device = load_rar_model()
+        restored_images = RAR_process(image, filename, model, vae, args, config, device)
         output_images += restored_images
     # Example placeholder: return the input image unchanged
     return output_images
@@ -761,7 +780,7 @@ with left_col:
 with right_col:
     st.subheader("Processed Output")
     if input_image:
-        results = process_image(input_image, selected_name, ) # <-------------------------------------- Modify process_image
+        results = process_image(input_image, selected_name, filename) # <-------------------------------------- Modify process_image
         stage_idx = st.session_state.get("stage_idx", len(results)-1) if st.session_state.get("stage_idx", len(results)-1) < len(results)  else len(results)-1
         st.image(results[stage_idx].resize((256,256)))