Upload 84 files

.gitattributes

@@ -33,3 +33,24 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/default_image.png filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/1/result.png filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/2/result.png filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/3/result.png filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/4/result.png filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/1/result.png filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/2/result.png filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/3/result.png filter=lfs diff=lfs merge=lfs -text
+apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/4/result.png filter=lfs diff=lfs merge=lfs -text
+assets/demo_image.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/default_image.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/1/result.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/2/result.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/3/result.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/4/result.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/1/result.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/2/result.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/3/result.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/4/result.png filter=lfs diff=lfs merge=lfs -text
+tests/test_data/ghibli_style_output_full_finetuning.png filter=lfs diff=lfs merge=lfs -text
+tests/test_data/ghibli_style_output_lora.png filter=lfs diff=lfs merge=lfs -text

.python-version

@@ -0,0 +1 @@
+3.10.12

CODE_OF_CONDUCT.md

@@ -0,0 +1 @@
+

CONTRIBUTING.md

@@ -0,0 +1 @@
+

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Danh Tran
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

SECURITY.md

@@ -0,0 +1 @@
+

SUPPORT.md

@@ -0,0 +1 @@
+

apps/gradio_app.py

@@ -0,0 +1,33 @@
+import argparse
+import subprocess
+import os
+import torch
+from gradio_app.gui_components import create_gui
+from gradio_app.config_loader import load_model_configs
+
+def run_setup_script():
+    setup_script = os.path.join(os.path.dirname(__file__),
+                                "gradio_app", "setup_scripts.py")
+    try:
+        result = subprocess.run(["python", setup_script], capture_output=True, text=True, check=True)
+        return result.stdout
+    except subprocess.CalledProcessError as e:
+        print(f"Setup script failed with error: {e.stderr}")
+        return f"Setup script failed: {e.stderr}"
+
+def main():
+    parser = argparse.ArgumentParser(description="Ghibli Stable Diffusion Synthesisr")
+    parser.add_argument("--config_path", type=str, default="configs/model_ckpts.yaml")
+    parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu")
+    parser.add_argument("--port", type=int, default=7860)
+    parser.add_argument("--share", action="store_true")
+    args = parser.parse_args()
+    print("Running setup script...")
+    run_setup_script()
+    print("Starting Gradio app...")
+    model_configs = load_model_configs(args.config_path)
+    demo = create_gui(model_configs, args.device)
+    demo.launch(server_port=args.port, share=args.share)
+
+if __name__ == "__main__":
+    main()

apps/gradio_app/aa.py

@@ -0,0 +1,603 @@
+import argparse
+import json
+from typing import Union, List
+from pathlib import Path
+import os
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from transformers import CLIPTextModel, CLIPTokenizer
+from diffusers import AutoencoderKL, UNet2DConditionModel, PNDMScheduler, StableDiffusionPipeline
+from tqdm import tqdm
+import yaml
+
+def load_model_configs(config_path: str = "configs/model_ckpts.yaml") -> dict:
+    """
+    Load model configurations from a YAML file.
+    Returns a dictionary with model IDs and their details.
+    """
+    try:
+        with open(config_path, 'r') as f:
+            configs = yaml.safe_load(f)
+        return {cfg['model_id']: cfg for cfg in configs}
+    except (IOError, yaml.YAMLError) as e:
+        raise ValueError(f"Error loading {config_path}: {e}")
+
+def get_examples(examples_dir: Union[str, List[str]] = None,
+                 use_lora: Union[bool, None] = None) -> List:
+    # Convert single string to list
+    directories = [examples_dir] if isinstance(examples_dir, str) else examples_dir or []
+
+    # Validate directories
+    valid_dirs = [d for d in directories if os.path.isdir(d)]
+    if not valid_dirs:
+        print("Error: No valid directories found, using provided examples")
+        return get_provided_examples(use_lora)
+
+    examples = []
+    for dir_path in valid_dirs:
+        # Get sorted subdirectories
+        subdirs = sorted(
+            os.path.join(dir_path, d) for d in os.listdir(dir_path) if os.path.isdir(os.path.join(dir_path, d))
+        )
+
+        for subdir in subdirs:
+            config_path = os.path.join(subdir, "config.json")
+            image_path = os.path.join(subdir, "result.png")
+
+            if not (os.path.isfile(config_path) and os.path.isfile(image_path)):
+                print(f"Error: Missing config.json or result.png in {subdir}")
+                continue
+
+            try:
+                with open(config_path, 'r') as f:
+                    config = json.load(f)
+            except (json.JSONDecodeError, IOError) as e:
+                print(f"Error reading {config_path}: {e}")
+                continue
+
+            required_keys = ["prompt", "height", "width", "num_inference_steps", "guidance_scale", "seed", "image"]
+            if config.get("use_lora", False):
+                required_keys.extend(["lora_model_id", "base_model_id", "lora_rank", "lora_scale"])
+            else:
+                required_keys.append("finetune_model_id")
+
+            if missing_keys := set(required_keys) - set(config.keys()):
+                print(f"Error: Missing keys in {config_path}: {', '.join(missing_keys)}")
+                continue
+
+            if config["image"] != "result.png":
+                print(f"Error: Image key in {config_path} does not match 'result.png'")
+                continue
+
+            try:
+                Image.open(image_path).verify()
+                image = Image.open(image_path)  # Re-open after verify
+            except Exception as e:
+                print(f"Error: Invalid image {image_path}: {e}")
+                continue
+
+            if use_lora is not None and config.get("use_lora", False) != use_lora:
+                print(f"DEBUG: Skipping {config_path} due to use_lora mismatch (expected {use_lora}, got {config.get('use_lora', False)})")
+                continue
+
+            # Build example list based on use_lora
+            example = [
+                config["prompt"],
+                config["height"],
+                config["width"],
+                config["num_inference_steps"],
+                config["guidance_scale"],
+                config["seed"],
+                image,
+                # config.get("use_lora", False)
+            ]
+            if config.get("use_lora", False):
+                example.extend([
+                    config["lora_model_id"],
+                    config["base_model_id"],
+                    config["lora_rank"],
+                    config["lora_scale"]
+                ])
+            else:
+                example.append(config["finetune_model_id"])
+
+            examples.append(example)
+            print(f"DEBUG: Loaded example from {config_path}: {example[:6]}")
+
+    return examples or get_provided_examples(use_lora)
+
+def get_provided_examples(use_lora: bool = False) -> list:
+    example1_image = None
+    example2_image = None
+    # Attempt to load example images
+    if use_lora:
+        try:
+            example2_path = "apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/1/result.png"
+            if os.path.exists(example2_path):
+                example2_image = Image.open(example2_path)
+        except Exception as e:
+            print(f"Failed to load example2 image: {e}")
+        output = [list({
+            "prompt": "a cat is laying on a sofa in Ghibli style",
+            "width": 512,
+            "height": 768,
+            "steps": 100,
+            "cfg_scale": 10.0,
+            "seed": 789,
+            "image": example2_path, # example2_image,
+            # "use_lora": True,
+            "model": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA",
+            "base_model": "stabilityai/stable-diffusion-2-1",
+            "lora_rank": 64,
+            "lora_alpha": 0.9
+        }.values())]
+
+    else:
+        try:
+            example1_path = "apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/1/result.png"
+            if os.path.exists(example1_path):
+                example1_image = Image.open(example1_path)
+        except Exception as e:
+            print(f"Failed to load example1 image: {e}")
+        output = [list({
+            "prompt": "a serene landscape in Ghibli style",
+            "width": 256,
+            "height": 512,
+            "steps": 50,
+            "cfg_scale": 3.5,
+            "seed": 42,
+            "image": example1_path, # example1_image,
+            # "use_lora": False,
+            "model": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+        }.values())]
+    
+    return output
+
+def create_demo(
+    config_path: str = "configs/model_ckpts.yaml",
+    device: str = "cuda" if torch.cuda.is_available() else "cpu",
+):
+    model_configs = load_model_configs(config_path)
+
+    finetune_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning'), None)
+    lora_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora'), None)
+
+    if not finetune_model_id or not lora_model_id:
+        raise ValueError("Could not find full_finetuning or lora model IDs in the configuration file.")
+
+    finetune_config = model_configs.get(finetune_model_id, {})
+    finetune_local_dir = finetune_config.get('local_dir')
+    if finetune_local_dir and os.path.exists(finetune_local_dir) and any(os.path.isfile(os.path.join(finetune_local_dir, f)) for f in os.listdir(finetune_local_dir)):
+        finetune_model_path = finetune_local_dir
+    else:
+        finetune_model_path = finetune_model_id
+
+    lora_config = model_configs.get(lora_model_id, {})
+    lora_local_dir = lora_config.get('local_dir')
+    if lora_local_dir and os.path.exists(lora_local_dir) and any(os.path.isfile(os.path.join(lora_local_dir, f)) for f in os.listdir(lora_local_dir)):
+        lora_model_path = lora_local_dir
+    else:
+        lora_model_path = lora_model_id
+
+    base_model_id = lora_config.get('base_model_id', 'stabilityai/stable-diffusion-2-1')
+    base_model_config = model_configs.get(base_model_id, {})
+    base_local_dir = base_model_config.get('local_dir')
+    if base_local_dir and os.path.exists(base_local_dir) and any(os.path.isfile(os.path.join(base_local_dir, f)) for f in os.listdir(base_local_dir)):
+        base_model_path = base_local_dir
+    else:
+        base_model_path = base_model_id
+
+    device = torch.device(device)
+    dtype = torch.float16 if device.type == "cuda" else torch.float32
+
+    finetune_model_ids = [mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning']
+    lora_model_ids = [mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora']
+    base_model_ids = [model_configs[mid].get('base_model_id') for mid in model_configs if model_configs[mid].get('base_model_id')]
+
+    def generate_image(prompt, height, width, num_inference_steps, guidance_scale, seed, random_seed, use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale):
+        try:
+            model_configs = load_model_configs(config_path)
+            finetune_config = model_configs.get(finetune_model_id, {})
+            finetune_local_dir = finetune_config.get('local_dir')
+            finetune_model_path = finetune_local_dir if finetune_local_dir and os.path.exists(finetune_local_dir) and any(os.path.isfile(os.path.join(finetune_local_dir, f)) for f in os.listdir(finetune_local_dir)) else finetune_model_id
+
+            lora_config = model_configs.get(lora_model_id, {})
+            lora_local_dir = lora_config.get('local_dir')
+            lora_model_path = lora_local_dir if lora_local_dir and os.path.exists(lora_local_dir) and any(os.path.isfile(os.path.join(lora_local_dir, f)) for f in os.listdir(lora_local_dir)) else lora_model_id
+
+            base_model_config = model_configs.get(base_model_id, {})
+            base_local_dir = base_model_config.get('local_dir')
+            base_model_path = base_local_dir if base_local_dir and os.path.exists(base_local_dir) and any(os.path.isfile(os.path.join(base_local_dir, f)) for f in os.listdir(base_local_dir)) else base_model_id
+
+            if not prompt:
+                return None, "Prompt cannot be empty."
+            if height % 8 != 0 or width % 8 != 0:
+                return None, "Height and width must be divisible by 8."
+            if num_inference_steps < 1 or num_inference_steps > 100:
+                return None, "Number of inference steps must be between 1 and 100."
+            if guidance_scale < 1.0 or guidance_scale > 20.0:
+                return None, "Guidance scale must be between 1.0 and 20.0."
+            if seed < 0 or seed > 4294967295:
+                return None, "Seed must be between 0 and 4294967295."
+            if use_lora and (not lora_model_path or not os.path.exists(lora_model_path) and not lora_model_path.startswith("danhtran2mind/")):
+                return None, f"LoRA model path {lora_model_path} does not exist or is invalid."
+            if use_lora and (not base_model_path or not os.path.exists(base_model_path) and not base_model_path.startswith("stabilityai/")):
+                return None, f"Base model path {base_model_path} does not exist or is invalid."
+            if not use_lora and (not finetune_model_path or not os.path.exists(finetune_model_path) and not finetune_model_path.startswith("danhtran2mind/")):
+                return None, f"Fine-tuned model path {finetune_model_path} does not exist or is invalid."
+            if use_lora and (lora_rank < 1 or lora_rank > 128):
+                return None, "LoRA rank must be between 1 and 128."
+            if use_lora and (lora_scale < 0.0 or lora_scale > 2.0):
+                return None, "LoRA scale must be between 0.0 and 2.0."
+
+            batch_size = 1
+            if random_seed:
+                seed = torch.randint(0, 4294967295, (1,)).item()
+            generator = torch.Generator(device=device).manual_seed(int(seed))
+
+            if use_lora:
+                try:
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        base_model_path, torch_dtype=dtype, use_safetensors=True
+                    )
+                    pipe.load_lora_weights(lora_model_path, adapter_name="ghibli-lora", lora_scale=lora_scale)
+                    pipe = pipe.to(device)
+                    vae = pipe.vae
+                    tokenizer = pipe.tokenizer
+                    text_encoder = pipe.text_encoder
+                    unet = pipe.unet
+                    scheduler = PNDMScheduler.from_config(pipe.scheduler.config)
+                except Exception as e:
+                    return None, f"Error loading LoRA model: {e}"
+            else:
+                try:
+                    vae = AutoencoderKL.from_pretrained(finetune_model_path, subfolder="vae", torch_dtype=dtype).to(device)
+                    tokenizer = CLIPTokenizer.from_pretrained(finetune_model_path, subfolder="tokenizer")
+                    text_encoder = CLIPTextModel.from_pretrained(finetune_model_path, subfolder="text_encoder", torch_dtype=dtype).to(device)
+                    unet = UNet2DConditionModel.from_pretrained(finetune_model_path, subfolder="unet", torch_dtype=dtype).to(device)
+                    scheduler = PNDMScheduler.from_pretrained(finetune_model_path, subfolder="scheduler")
+                except Exception as e:
+                    return None, f"Error loading fine-tuned model: {e}"
+
+            text_input = tokenizer(
+                [prompt], padding="max_length", max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt"
+            )
+            with torch.no_grad():
+                text_embeddings = text_encoder(text_input.input_ids.to(device))[0].to(dtype=dtype)
+
+            max_length = text_input.input_ids.shape[-1]
+            uncond_input = tokenizer(
+                [""] * batch_size, padding="max_length", max_length=max_length, return_tensors="pt"
+            )
+            with torch.no_grad():
+                uncond_embeddings = text_encoder(uncond_input.input_ids.to(device))[0].to(dtype=dtype)
+
+            text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
+
+            latents = torch.randn(
+                (batch_size, unet.config.in_channels, height // 8, width // 8),
+                generator=generator, dtype=dtype, device=device
+            )
+
+            scheduler.set_timesteps(num_inference_steps)
+            latents = latents * scheduler.init_noise_sigma
+
+            for t in tqdm(scheduler.timesteps, desc="Generating image"):
+                latent_model_input = torch.cat([latents] * 2)
+                latent_model_input = scheduler.scale_model_input(latent_model_input, t)
+
+                with torch.no_grad():
+                    if device.type == "cuda":
+                        with torch.autocast(device_type="cuda", dtype=torch.float16):
+                            noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+                    else:
+                        noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+
+                noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+                noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+                latents = scheduler.step(noise_pred, t, latents).prev_sample
+
+            with torch.no_grad():
+                latents = latents / vae.config.scaling_factor
+                image = vae.decode(latents).sample
+
+            image = (image / 2 + 0.5).clamp(0, 1)
+            image = image.detach().cpu().permute(0, 2, 3, 1).numpy()
+            image = (image * 255).round().astype("uint8")
+            pil_image = Image.fromarray(image[0])
+
+            if use_lora:
+                del pipe
+            else:
+                del vae, tokenizer, text_encoder, unet, scheduler
+            torch.cuda.empty_cache()
+
+            return pil_image, f"Generated image successfully! Seed used: {seed}"
+        except Exception as e:
+            return None, f"Failed to generate image: {e}"
+
+    def load_example_image_full_finetuning(prompt, height, width, num_inference_steps, guidance_scale,
+                                          seed, image, finetune_model_id):
+        try:
+            status = "Loaded example successfully"
+            return (
+                prompt, height, width, num_inference_steps, guidance_scale, seed,
+                image, finetune_model_id, status
+            )
+        except Exception as e:
+            print(f"DEBUG: Exception in load_example_image: {e}")
+            return (
+                prompt, height, width, num_inference_steps, guidance_scale, seed,
+                None, finetune_model_id,
+                f"Error loading example: {e}"
+            )
+
+    def load_example_image_lora(prompt, height, width, num_inference_steps, guidance_scale,
+                               seed, image, lora_model_id,
+                               base_model_id, lora_rank, lora_scale):
+        try:
+            status = "Loaded example successfully"
+            # Ensure base_model_id, lora_rank, and lora_scale have valid values
+            base_model_id = base_model_id or "stabilityai/stable-diffusion-2-1"
+            lora_rank = lora_rank if lora_rank is not None else 64
+            lora_scale = lora_scale if lora_scale is not None else 1.2
+
+            return (
+                prompt, height, width, num_inference_steps, guidance_scale, seed,
+                image, lora_model_id, base_model_id,
+                lora_rank, lora_scale, status
+            )
+        except Exception as e:
+            print(f"DEBUG: Exception in load_example_image_lora: {e}")
+            return (
+                prompt, height, width, num_inference_steps, guidance_scale, seed,
+                None, lora_model_id, base_model_id or "stabilityai/stable-diffusion-2-1",
+                lora_rank or 64, lora_scale or 1.2, f"Error loading example: {e}"
+            )
+
+    badges_text = r"""
+    <div style="text-align: left; font-size: 14px; display: flex; flex-direction: column; gap: 10px;">
+        <div style="display: flex; align-items: center; justify-content: left; gap: 8px;">
+            You can explore GitHub repository:
+            <a href="https://github.com/danhtran2mind/Ghibli-Stable-Diffusion-Synthesis">
+                <img src="https://img.shields.io/badge/GitHub-danhtran2mind%2FGhibli--Stable--Diffusion--Synthesis-blue?style=flat&logo=github" alt="GitHub Repo">
+            </a>. And you can explore HuggingFace Model Hub:
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--Base--finetuning-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+            and
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--LoRA-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+        </div>
+    </div>
+    """.strip()
+
+    try:
+        custom_css = open("apps/gradio_app/static/styles.css", "r").read()
+    except FileNotFoundError:
+        print("Error: styles.css not found, using default styling")
+        custom_css = ""
+
+    examples_full_finetuning = get_examples("apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning",
+                                             use_lora=False)
+    examples_lora = get_examples("apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA", 
+                                 use_lora=True)
+    
+    with gr.Blocks(css=custom_css, theme="ocean") as demo:
+        gr.Markdown("## Ghibli-Style Image Generator")
+        with gr.Tabs():
+            with gr.Tab(label="Full Finetuning"):
+                with gr.Row():
+                    with gr.Column(scale.=1):
+                        gr.Markdown("### Image Generation Settings")
+                        prompt_ft = gr.Textbox(
+                            label="Prompt",
+                            placeholder="e.g., 'a serene landscape in Ghibli style'",
+                            lines=2
+                        )
+                        with gr.Group():
+                            gr.Markdown("#### Image Dimensions")
+                            with gr.Row():
+                                width_ft = gr.Slider(
+                                    minimum=32, maximum=4096, value=512, step=8, label="Width"
+                                )
+                                height_ft = gr.Slider(
+                                    minimum=32, maximum=4096, value=512, step=8, label="Height"
+                                )
+                        with gr.Accordion("Advanced Settings", open=False):
+                            num_inference_steps_ft = gr.Slider(
+                                minimum=1, maximum=100, value=50, step=1, label="Inference Steps",
+                                info="More steps, better quality, longer wait."
+                            )
+                            guidance_scale_ft = gr.Slider(
+                                minimum=1.0, maximum=20.0, value=3.5, step=0.5, label="Guidance Scale",
+                                info="Controls how closely the image follows the prompt."
+                            )
+                            random_seed_ft = gr.Checkbox(label="Use Random Seed", value=False)
+                            seed_ft = gr.Slider(
+                                minimum=0, maximum=4294967295, value=42, step=1,
+                                label="Seed", info="Use a seed (0-4294967295) for consistent results."
+                            )
+                        with gr.Group():
+                            gr.Markdown("#### Model Configuration")
+                            finetune_model_path_ft = gr.Dropdown(
+                                label="Fine-tuned Model", choices=finetune_model_ids,
+                                value=finetune_model_id
+                            )
+                        # image_path_ft = gr.Textbox(visible=False)
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Generated Result")
+                        output_image_ft = gr.Image(label="Generated Image", interactive=False, height=512)
+                        output_text_ft = gr.Textbox(label="Status", interactive=False, lines=3)
+
+                        generate_btn_ft = gr.Button("Generate Image", variant="primary")
+                        stop_btn_ft = gr.Button("Stop Generation")
+
+                gr.Markdown("### Examples for Full Finetuning")
+                gr.Examples(
+                    examples=examples_full_finetuning,
+                    inputs=[
+                        prompt_ft, height_ft, width_ft, num_inference_steps_ft, 
+                        guidance_scale_ft, seed_ft, output_image_ft, finetune_model_path_ft
+                    ],
+                    outputs=[prompt_ft, height_ft, width_ft, num_inference_steps_ft,
+                             guidance_scale_ft, seed_ft, output_image_ft, finetune_model_path_ft,
+                             output_text_ft],
+                    fn=load_example_image_full_finetuning,
+                    # fn=lambda *args: load_example_image_full_finetuning(*args),
+                    cache_examples=False,
+                    label="Examples for Full Fine-tuning",
+                    examples_per_page=4
+                )
+
+            with gr.Tab(label="LoRA"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Image Generation Settings")
+                        prompt_lora = gr.Textbox(
+                            label="Prompt",
+                            placeholder="e.g., 'a serene landscape in Ghibli style'",
+                            lines=2
+                        )
+                        with gr.Group():
+                            gr.Markdown("#### Image Dimensions")
+                            with gr.Row():
+                                width_lora = gr.Slider(
+                                    minimum=32, maximum=4096, value=512, step=8, label="Width"
+                                )
+                                height_lora = gr.Slider(
+                                    minimum=32, maximum=4096, value=512, step=8, label="Height"
+                                )
+                        with gr.Accordion("Advanced Settings", open=False):
+                            num_inference_steps_lora = gr.Slider(
+                                minimum=1, maximum=100, value=50, step=1, label="Inference Steps",
+                                info="More steps, better quality, longer wait."
+                            )
+                            guidance_scale_lora = gr.Slider(
+                                minimum=1.0, maximum=20.0, value=3.5, step=0.5, label="Guidance Scale",
+                                info="Controls how closely the image follows the prompt."
+                            )
+                            lora_rank_lora = gr.Slider(
+                                minimum=1, maximum=128, value=64, step=1, label="LoRA Rank",
+                                info="Controls model complexity and memory usage."
+                            )
+                            lora_scale_lora = gr.Slider(
+                                minimum=0.0, maximum=2.0, value=1.2, step=0.1, label="LoRA Scale",
+                                info="Adjusts the influence of LoRA weights."
+                            )
+                            random_seed_lora = gr.Checkbox(label="Use Random Seed", value=False)
+                            seed_lora = gr.Slider(
+                                minimum=0, maximum=4294967295, value=42, step=1,
+                                label="Seed", info="Use a seed (0-4294967295) for consistent results."
+                            )
+                        with gr.Group():
+                            gr.Markdown("#### Model Configuration")
+                            lora_model_path_lora = gr.Dropdown(
+                                label="LoRA Model", choices=lora_model_ids,
+                                value=lora_model_id
+                            )
+                            base_model_path_lora = gr.Dropdown(
+                                label="Base Model", choices=base_model_ids,
+                                value=base_model_id
+                            )
+                        # image_path_lora = gr.Textbox(visible=False)
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Generated Result")
+                        output_image_lora = gr.Image(label="Generated Image", interactive=False, height=512)
+                        output_text_lora = gr.Textbox(label="Status", interactive=False, lines=3)
+
+                        generate_btn_lora = gr.Button("Generate Image", variant="primary")
+                        stop_btn_lora = gr.Button("Stop Generation")
+
+                gr.Markdown("### Examples for LoRA")
+                gr.Examples(
+                    examples=examples_lora,
+                    inputs=[
+                        prompt_lora, height_lora, width_lora, num_inference_steps_lora, 
+                        guidance_scale_lora, seed_lora, output_image_lora,      
+                        lora_model_path_lora, base_model_path_lora,
+                        lora_rank_lora, lora_scale_lora
+                    ],
+                    outputs=[
+                        prompt_lora, height_lora, width_lora, num_inference_steps_lora,
+                        guidance_scale_lora, seed_lora, output_image_lora,
+                        lora_model_path_lora, base_model_path_lora,
+                        lora_rank_lora, lora_scale_lora,
+                        output_text_lora
+                    ],
+                    fn=load_example_image_lora,
+                    # fn=lambda *args: load_example_image_lora(*args),
+                    cache_examples=False,
+                    label="Examples for LoRA",
+                    examples_per_page=4
+                )
+
+        gr.Markdown(badges_text)
+
+        generate_event_ft = generate_btn_ft.click(
+            fn=generate_image,
+            inputs=[
+                prompt_ft, height_ft, width_ft, num_inference_steps_ft, guidance_scale_ft, seed_ft,
+                random_seed_ft, gr.State(value=False), finetune_model_path_ft, gr.State(value=None),
+                gr.State(value=None), gr.State(value=None), gr.State(value=None)
+            ],
+            outputs=[output_image_ft, output_text_ft]
+        )
+
+        generate_event_lora = generate_btn_lora.click(
+            fn=generate_image,
+            inputs=[
+                prompt_lora, height_lora, width_lora, num_inference_steps_lora, guidance_scale_lora, seed_lora,
+                random_seed_lora, gr.State(value=True), gr.State(value=None), lora_model_path_lora,
+                base_model_path_lora, lora_rank_lora, lora_scale_lora
+            ],
+            outputs=[output_image_lora, output_text_lora]
+        )
+
+        stop_btn_ft.click(fn=None, inputs=None, outputs=None, cancels=[generate_event_ft])
+        stop_btn_lora.click(fn=None, inputs=None, outputs=None, cancels=[generate_event_lora])
+
+        def cleanup():
+            print("DEBUG: Cleaning up resources...")
+            torch.cuda.empty_cache()
+
+        demo.unload(cleanup)
+
+    return demo
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Ghibli-Style Image Generator using a fine-tuned Stable Diffusion model or Stable Diffusion 2.1 with LoRA weights.")
+    parser.add_argument(
+        "--config_path",
+        type=str,
+        default="configs/model_ckpts.yaml",
+        help="Path to the model configuration YAML file."
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="cuda" if torch.cuda.is_available() else "cpu",
+        help="Device to run the model on (e.g., 'cuda', 'cpu')."
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=7860,
+        help="Port to run the Gradio app on."
+    )
+    parser.add_argument(
+        "--share",
+        action="store_true",
+        default=False,
+        help="Set to True for public sharing (Hugging Face Spaces)."
+    )
+
+    args = parser.parse_args()
+
+    demo = create_demo(args.config_path, args.device)
+    demo.launch(server_port=args.port, share=args.share)

apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/1/config.json

@@ -0,0 +1,11 @@
+{
+    "prompt": "a serene landscape in Ghibli style",
+    "height": 256,
+    "width": 512,
+    "num_inference_steps": 50,
+    "guidance_scale": 3.5,
+    "seed": 42,
+    "image": "result.png",
+    "use_lora": false,
+    "finetune_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+}

apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/2/config.json

@@ -0,0 +1,11 @@
+{
+    "prompt": "Donald Trump",
+    "height": 512,
+    "width": 512,
+    "num_inference_steps": 100,
+    "guidance_scale": 9,
+    "seed": 200,
+    "image": "result.png",
+    "use_lora": false,
+    "finetune_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+}

apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/3/config.json

@@ -0,0 +1,11 @@
+{
+    "prompt": "a dancer in Ghibli style",
+    "height": 384,
+    "width": 192,
+    "num_inference_steps": 50,
+    "guidance_scale": 15.5,
+    "seed": 4223,
+    "image": "result.png",
+    "use_lora": false,
+    "finetune_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+}

apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/4/config.json

@@ -0,0 +1,11 @@
+{
+    "prompt": "Ghibli style, the peace beach",
+    "height": 1024,
+    "width": 2048,
+    "num_inference_steps": 100,
+    "guidance_scale": 7.5,
+    "seed": 5678,
+    "image": "result.png",
+    "use_lora": false,
+    "finetune_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+}

apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/1/config.json

@@ -0,0 +1,13 @@
+{
+    "prompt": "a cat is laying on a sofa in Ghibli style",
+    "height": 512,
+    "width": 768,
+    "num_inference_steps": 100,
+    "guidance_scale": 10,
+    "seed": 789,
+    "image": "result.png",
+    "use_lora": true,
+    "lora_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA",
+    "base_model_id": "stabilityai/stable-diffusion-2-1",
+    "lora_scale": 0.9
+}

apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/2/config.json

@@ -0,0 +1,13 @@
+{
+    "prompt": "Ghibli style, a majestic mountain towers, casting shadows on the serene beach.",
+    "height": 1024,
+    "width": 2048,
+    "num_inference_steps": 75,
+    "guidance_scale": 14.5,
+    "seed": 9999,
+    "image": "result.png",
+    "use_lora": true,
+    "lora_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA",
+    "base_model_id": "stabilityai/stable-diffusion-2-1",
+    "lora_scale": 1
+}

apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/3/config.json

@@ -0,0 +1,13 @@
+{
+    "prompt": "In a soft, Ghibli style, Elon Musk is in a suit.",
+    "height": 512,
+    "width": 512,
+    "num_inference_steps": 82,
+    "guidance_scale": 18,
+    "seed": 1,
+    "image": "result.png",
+    "use_lora": true,
+    "lora_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA",
+    "base_model_id": "stabilityai/stable-diffusion-2-1",
+    "lora_scale": 1.4
+}

apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA/4/config.json

@@ -0,0 +1,13 @@
+{
+    "prompt": "In a Ghibli-esque world, A close-up shows a race car's soft, sun-drenched, whimsical details.",
+    "height": 1024,
+    "width": 1024,
+    "num_inference_steps": 42,
+    "guidance_scale": 20,
+    "seed": 1589,
+    "image": "result.png",
+    "use_lora": true,
+    "lora_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA",
+    "base_model_id": "stabilityai/stable-diffusion-2-1",
+    "lora_scale": 0.7
+}

apps/gradio_app/config_loader.py

@@ -0,0 +1,5 @@
+import yaml
+
+def load_model_configs(config_path: str = "configs/model_ckpts.yaml") -> dict:
+    with open(config_path, 'r') as f:
+        return {cfg['model_id']: cfg for cfg in yaml.safe_load(f)}

apps/gradio_app/example_handler.py

@@ -0,0 +1,60 @@
+import os
+import json
+from typing import Union, List
+from PIL import Image
+
+def get_examples(examples_dir: Union[str, List[str]] = None, use_lora: bool = None) -> List:
+    directories = [examples_dir] if isinstance(examples_dir, str) else examples_dir or []
+    valid_dirs = [d for d in directories if os.path.isdir(d)]
+    if not valid_dirs:
+        return get_provided_examples(use_lora)
+
+    examples = []
+    for dir_path in valid_dirs:
+        for subdir in sorted(os.path.join(dir_path, d) for d in os.listdir(dir_path) if os.path.isdir(os.path.join(dir_path, d))):
+            config_path = os.path.join(subdir, "config.json")
+            image_path = os.path.join(subdir, "result.png")
+            if not (os.path.isfile(config_path) and os.path.isfile(image_path)):
+                continue
+
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+
+            required_keys = ["prompt", "height", "width", "num_inference_steps", "guidance_scale", "seed", "image"]
+            if config.get("use_lora", False):
+                required_keys.extend(["lora_model_id", "base_model_id", 
+                                    #   "lora_rank", 
+                                      "lora_scale"])
+            else:
+                required_keys.append("finetune_model_id")
+
+            if set(required_keys) - set(config.keys()) or config["image"] != "result.png":
+                continue
+
+            try:
+                image = Image.open(image_path)
+            except Exception:
+                continue
+
+            if use_lora is not None and config.get("use_lora", False) != use_lora:
+                continue
+
+            example = [config["prompt"], config["height"], config["width"], config["num_inference_steps"], 
+                       config["guidance_scale"], config["seed"], image]
+            example.extend([config["lora_model_id"], config["base_model_id"], 
+                            # config["lora_rank"], 
+                            config["lora_scale"]] 
+                          if config.get("use_lora", False) else [config["finetune_model_id"]])
+            examples.append(example)
+
+    return examples or get_provided_examples(use_lora)
+
+def get_provided_examples(use_lora: bool = False) -> list:
+    example_path = f"apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-{'LoRA' if use_lora else 'Base-finetuning'}/1/result.png"
+    image = Image.open(example_path) if os.path.exists(example_path) else None
+    return [[
+        "a cat is laying on a sofa in Ghibli style" if use_lora else "a serene landscape in Ghibli style",
+        512, 768 if use_lora else 512, 100 if use_lora else 50, 10.0 if use_lora else 3.5, 789 if use_lora else 42,
+        image, "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA" if use_lora else "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning",
+        "stabilityai/stable-diffusion-2-1" if use_lora else None, 64 if use_lora else None, 0.9 if use_lora else None
+    ]]

apps/gradio_app/gui_components.py

@@ -0,0 +1,120 @@
+import gradio as gr
+import torch
+import os
+from .example_handler import get_examples
+from .image_generator import generate_image
+from .project_info import intro_markdown_1, intro_markdown_2, outro_markdown_1
+
+def load_example_image_full_finetuning(prompt, height, width, num_inference_steps, guidance_scale, seed, image, finetune_model_id):
+    return prompt, height, width, num_inference_steps, guidance_scale, seed, image, finetune_model_id, "Loaded example successfully"
+
+def load_example_image_lora(prompt, height, width, num_inference_steps, guidance_scale, seed, image, lora_model_id, base_model_id, lora_scale):
+    return prompt, height, width, num_inference_steps, guidance_scale, seed, image, lora_model_id, base_model_id or "stabilityai/stable-diffusion-2-1", lora_scale or 1.2, "Loaded example successfully"
+
+def create_gui(model_configs, device):
+    finetune_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning'), None)
+    lora_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora'), None)
+    
+    if not finetune_model_id or not lora_model_id:
+        raise ValueError("Missing model IDs in config.")
+
+    base_model_id = model_configs[lora_model_id].get('base_model_id', 'stabilityai/stable-diffusion-2-1')
+    device = torch.device(device)
+    dtype = torch.float16 if device.type == "cuda" else torch.float32
+    config_path = "configs/model_ckpts.yaml"    
+
+    custom_css = open("apps/gradio_app/static/styles.css", "r").read() if os.path.exists("apps/gradio_app/static/styles.css") else ""
+
+    examples_full_finetuning = get_examples("apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning", use_lora=False)
+    examples_lora = get_examples("apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA", use_lora=True)
+
+    with gr.Blocks(css=custom_css, theme="ocean") as demo:
+        gr.Markdown("# Ghibli Stable Diffusion Synthesis")
+        gr.HTML(intro_markdown_1)
+        gr.HTML(intro_markdown_2)
+        with gr.Tabs():
+            with gr.Tab(label="Full Finetuning"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Image Generation Settings")
+                        prompt_ft = gr.Textbox(label="Prompt", placeholder="e.g., 'a serene landscape in Ghibli style'", lines=2)
+                        with gr.Group():
+                            gr.Markdown("#### Image Dimensions")
+                            with gr.Row():                                
+                                height_ft = gr.Slider(32, 4096, 512, step=8, label="Height")
+                                width_ft = gr.Slider(32, 4096, 512, step=8, label="Width")
+                        with gr.Accordion("Advanced Settings", open=False):
+                            num_inference_steps_ft = gr.Slider(1, 100, 50, step=1, label="Inference Steps")
+                            guidance_scale_ft = gr.Slider(1.0, 20.0, 3.5, step=0.5, label="Guidance Scale")
+                            random_seed_ft = gr.Checkbox(label="Use Random Seed")
+                            seed_ft = gr.Slider(0, 4294967295, 42, step=1, label="Seed")
+                        gr.Markdown("#### Model Configuration")
+                        finetune_model_path_ft = gr.Dropdown(label="Fine-tuned Model", choices=[mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning'], value=finetune_model_id)
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Generated Result")
+                        output_image_ft = gr.Image(label="Generated Image", interactive=False, height=512)
+                        output_text_ft = gr.Textbox(label="Status", interactive=False, lines=3)
+                        generate_btn_ft = gr.Button("Generate Image", variant="primary")
+                        stop_btn_ft = gr.Button("Stop Generation")
+                gr.Markdown("### Examples for Full Finetuning")
+                gr.Examples(examples=examples_full_finetuning, inputs=[prompt_ft, height_ft, width_ft, num_inference_steps_ft, guidance_scale_ft, seed_ft, output_image_ft, finetune_model_path_ft], 
+                            outputs=[prompt_ft, height_ft, width_ft, num_inference_steps_ft, guidance_scale_ft, seed_ft, output_image_ft, finetune_model_path_ft, output_text_ft], 
+                            fn=load_example_image_full_finetuning, cache_examples=False, examples_per_page=4)
+
+            with gr.Tab(label="LoRA"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Image Generation Settings")
+                        prompt_lora = gr.Textbox(label="Prompt", placeholder="e.g., 'a serene landscape in Ghibli style'", lines=2)
+                        with gr.Group():
+                            gr.Markdown("#### Image Dimensions")
+                            with gr.Row():
+                                height_lora = gr.Slider(32, 4096, 512, step=8, label="Height")
+                                width_lora = gr.Slider(32, 4096, 512, step=8, label="Width")
+                        with gr.Accordion("Advanced Settings", open=False):
+                            num_inference_steps_lora = gr.Slider(1, 100, 50, step=1, label="Inference Steps")
+                            guidance_scale_lora = gr.Slider(1.0, 20.0, 3.5, step=0.5, label="Guidance Scale")
+                            lora_scale_lora = gr.Slider(0.0, 2.0, 1.2, step=0.1, label="LoRA Scale")
+                            random_seed_lora = gr.Checkbox(label="Use Random Seed")
+                            seed_lora = gr.Slider(0, 4294967295, 42, step=1, label="Seed")
+                        gr.Markdown("#### Model Configuration")
+                        lora_model_path_lora = gr.Dropdown(label="LoRA Model", choices=[mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora'], value=lora_model_id)
+                        base_model_path_lora = gr.Dropdown(label="Base Model", choices=[model_configs[mid].get('base_model_id') for mid in model_configs if model_configs[mid].get('base_model_id')], value=base_model_id)
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Generated Result")
+                        output_image_lora = gr.Image(label="Generated Image", interactive=False, height=512)
+                        output_text_lora = gr.Textbox(label="Status", interactive=False, lines=3)
+                        generate_btn_lora = gr.Button("Generate Image", variant="primary")
+                        stop_btn_lora = gr.Button("Stop Generation")
+                gr.Markdown("### Examples for LoRA")
+                gr.Examples(examples=examples_lora, inputs=[prompt_lora, height_lora, width_lora, num_inference_steps_lora, guidance_scale_lora, seed_lora, output_image_lora, lora_model_path_lora, base_model_path_lora, lora_scale_lora], 
+                            outputs=[prompt_lora, height_lora, width_lora, num_inference_steps_lora, guidance_scale_lora, seed_lora, output_image_lora, lora_model_path_lora, base_model_path_lora, lora_scale_lora, output_text_lora], 
+                            fn=load_example_image_lora, cache_examples=False, examples_per_page=4)
+
+        gr.HTML(outro_markdown_1)
+
+        generate_event_ft = generate_btn_ft.click(
+            fn=generate_image, 
+            inputs=[prompt_ft, height_ft, width_ft, 
+                    num_inference_steps_ft, guidance_scale_ft, seed_ft, 
+                    random_seed_ft, gr.State(False), finetune_model_path_ft, 
+                    gr.State(None), gr.State(None), gr.State(None), 
+                    gr.State(config_path), gr.State(device), gr.State(dtype)], 
+            outputs=[output_image_ft, output_text_ft]
+        )
+        generate_event_lora = generate_btn_lora.click(
+            fn=generate_image, 
+            inputs=[prompt_lora, height_lora, width_lora, 
+                    num_inference_steps_lora, guidance_scale_lora, seed_lora, 
+                    random_seed_lora, gr.State(True), gr.State(None), 
+                    lora_model_path_lora, base_model_path_lora, lora_scale_lora, 
+                    gr.State(config_path), gr.State(device), gr.State(dtype)], 
+            outputs=[output_image_lora, output_text_lora]
+        )
+
+        stop_btn_ft.click(fn=None, inputs=None, outputs=None, cancels=[generate_event_ft])
+        stop_btn_lora.click(fn=None, inputs=None, outputs=None, cancels=[generate_event_lora])
+
+        demo.unload(lambda: torch.cuda.empty_cache())
+
+    return demo

apps/gradio_app/image_generator.py

@@ -0,0 +1,54 @@
+import os
+import sys
+import torch
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 
+                                             'src', 'ghibli_stable_diffusion_synthesis', 
+                                             'inference')))
+
+from full_finetuning import inference_process as full_finetuning_inference
+from lora import inference_process as lora_inference
+
+def generate_image(prompt, height, width, num_inference_steps, guidance_scale, seed, 
+                   random_seed, use_lora, finetune_model_id, lora_model_id, base_model_id, 
+                  lora_scale, config_path, device, dtype):
+    batch_size = 1
+    if random_seed:
+        seed = torch.randint(0, 4294967295, (1,)).item()
+    try:
+        model_id = finetune_model_id
+        if not use_lora:
+            pil_image = full_finetuning_inference(
+                prompt=prompt,
+                height=height,
+                width=width,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale,
+                batch_size=batch_size,
+                seed=seed,
+                config_path=config_path,
+                model_id=model_id,
+                device=device,
+                dtype=dtype
+            )
+        else:
+            model_id = lora_model_id
+            pil_image = lora_inference(
+                prompt=prompt,
+                height=height,
+                width=width,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale,
+                batch_size=batch_size,
+                seed=seed,
+                lora_scale=lora_scale,
+                config_path=config_path,
+                model_id=model_id,
+                # base_model_id=base_model_id,
+                device=device,
+                dtype=dtype
+            )
+        return pil_image, f"Generated image successfully! Seed used: {seed}"
+    except Exception as e:
+        return None, f"Failed to generate image: {e}"
+    

apps/gradio_app/old-image_generator.py

@@ -0,0 +1,77 @@
+import torch
+from PIL import Image
+import numpy as np
+from transformers import CLIPTextModel, CLIPTokenizer
+from diffusers import (
+    AutoencoderKL, UNet2DConditionModel, 
+    PNDMScheduler, StableDiffusionPipeline
+)
+
+from tqdm import tqdm
+from .config_loader import load_model_configs
+
+def generate_image(prompt, height, width, num_inference_steps, guidance_scale, seed, 
+                   random_seed, use_lora, finetune_model_id, lora_model_id, base_model_id, 
+                  lora_scale, config_path, device, dtype):
+    if not prompt or height % 8 != 0 or width % 8 != 0 or num_inference_steps not in range(1, 101) or \
+       guidance_scale < 1.0 or guidance_scale > 20.0 or seed < 0 or seed > 4294967295 or \
+       (use_lora and (lora_scale < 0.0 or lora_scale > 2.0)):
+        return None, "Invalid input parameters."
+
+    model_configs = load_model_configs(config_path)
+    finetune_model_path = model_configs.get(finetune_model_id, {}).get('local_dir', finetune_model_id)
+    lora_model_path = model_configs.get(lora_model_id, {}).get('local_dir', lora_model_id)
+    base_model_path = model_configs.get(base_model_id, {}).get('local_dir', base_model_id)
+    
+    generator = torch.Generator(device=device).manual_seed(torch.randint(0, 4294967295, (1,)).item() if random_seed else int(seed))
+
+    try:
+        if use_lora:
+            # Load base pipeline
+            pipe = StableDiffusionPipeline.from_pretrained(base_model_path, torch_dtype=dtype, use_safetensors=True)
+            
+            # Add LoRA weights with specified rank and scale
+            pipe.load_lora_weights(lora_model_path, adapter_name="ghibli-lora", 
+                                   lora_scale=lora_scale)
+            
+            pipe = pipe.to(device)
+            vae, tokenizer, text_encoder, unet, scheduler = pipe.vae, pipe.tokenizer, pipe.text_encoder, pipe.unet, PNDMScheduler.from_config(pipe.scheduler.config)
+        else:
+            vae = AutoencoderKL.from_pretrained(finetune_model_path, subfolder="vae", torch_dtype=dtype).to(device)
+            tokenizer = CLIPTokenizer.from_pretrained(finetune_model_path, subfolder="tokenizer")
+            text_encoder = CLIPTextModel.from_pretrained(finetune_model_path, subfolder="text_encoder", torch_dtype=dtype).to(device)
+            unet = UNet2DConditionModel.from_pretrained(finetune_model_path, subfolder="unet", torch_dtype=dtype).to(device)
+            scheduler = PNDMScheduler.from_pretrained(finetune_model_path, subfolder="scheduler")
+
+        text_input = tokenizer([prompt], padding="max_length", max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")
+        text_embeddings = text_encoder(text_input.input_ids.to(device))[0].to(dtype=dtype)
+
+        uncond_input = tokenizer([""] * 1, padding="max_length", max_length=text_input.input_ids.shape[-1], return_tensors="pt")
+        uncond_embeddings = text_encoder(uncond_input.input_ids.to(device))[0].to(dtype=dtype)
+        text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
+
+        latents = torch.randn((1, unet.config.in_channels, height // 8, width // 8), generator=generator, dtype=dtype, device=device)
+        scheduler.set_timesteps(num_inference_steps)
+        latents = latents * scheduler.init_noise_sigma
+
+        for t in tqdm(scheduler.timesteps, desc="Generating image"):
+            latent_model_input = torch.cat([latents] * 2)
+            latent_model_input = scheduler.scale_model_input(latent_model_input, t)
+            noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+            noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+            noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+            latents = scheduler.step(noise_pred, t, latents).prev_sample
+
+        image = vae.decode(latents / vae.config.scaling_factor).sample
+        image = (image / 2 + 0.5).clamp(0, 1).detach().cpu().permute(0, 2, 3, 1).numpy()
+        pil_image = Image.fromarray((image[0] * 255).round().astype("uint8"))
+
+        if use_lora:
+            del pipe
+        else:
+            del vae, tokenizer, text_encoder, unet, scheduler
+        torch.cuda.empty_cache()
+
+        return pil_image, f"Generated image successfully! Seed used: {seed}"
+    except Exception as e:
+        return None, f"Failed to generate image: {e}"

apps/gradio_app/project_info.py

@@ -0,0 +1,36 @@
+intro_markdown_1 = """
+    <h3>Create Studio Ghibli-style art with Stable Diffusion AI.</h3>
+    """.strip()
+
+intro_markdown_2 = """
+    <div style="text-align: left; font-size: 14px; display: flex; flex-direction: column; gap: 10px;">
+        <div style="display: flex; align-items: center; justify-content: left; gap: 8px;">
+            You can explore this GitHub Source code: <a href="https://github.com/danhtran2mind/Ghibli-Stable-Diffusion-Synthesis">
+                <img src="https://img.shields.io/badge/GitHub-danhtran2mind%2FGhibli--Stable--Diffusion--Synthesis-blue?style=flat&logo=github" alt="GitHub Repo">
+            </a>
+        </div> 
+        <div style="display: flex; align-items: center; justify-content: left; gap: 8px;">
+        And HuggingFace Model Hubs: 
+            <a href="https://huggingface.co/danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--Base--finetuning-yellow?style=flat&logo=huggingface" alt="HuggingFace Model Hub">
+            </a>, and 
+            <a href="https://huggingface.co/danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--LoRA-yellow?style=flat&logo=huggingface" alt="HuggingFace Model Hub">
+            </a>
+        </div>
+    </div>
+    """.strip()
+
+outro_markdown_1 = """
+    <div style="text-align: left; font-size: 14px; display: flex; flex-direction: column; gap: 10px;">
+        <div style="display: flex; align-items: center; justify-content: left; gap: 8px;">
+            This is the pre-trained models on our Hugging Face Model Hubs: 
+            <a href="https://huggingface.co/stabilityai/stable-diffusion-2-1">
+                <img src="https://img.shields.io/badge/HuggingFace-stabilityai%2Fstable--diffusion--2--1-yellow?style=flat&logo=huggingface" alt="HuggingFace Model Hub">
+            </a>, and 
+            <a href="https://huggingface.co/stabilityai/stable-diffusion-2-1-base">
+                <img src="https://img.shields.io/badge/HuggingFace-stabilityai%2Fstable--diffusion--2--1--base-yellow?style=flat&logo=huggingface" alt="HuggingFace Model Hub">
+            </a>
+        </div>
+    </div>
+    """.strip()

apps/gradio_app/setup_scripts.py

@@ -0,0 +1,64 @@
+import subprocess
+import sys
+import os
+
+def run_script(script_path, args=None):
+    """
+    Run a Python script using subprocess with optional arguments and handle errors.
+    Returns True if successful, False otherwise.
+    """
+    if not os.path.isfile(script_path):
+        print(f"Script not found: {script_path}")
+        return False
+
+    try:
+        command = [sys.executable, script_path]
+        if args:
+            command.extend(args)
+        result = subprocess.run(
+            command,
+            check=True,
+            text=True,
+            capture_output=True
+        )
+        print(f"Successfully executed {script_path}")
+        print(result.stdout)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"Error executing {script_path}:")
+        print(e.stderr)
+        return False
+    except Exception as e:
+        print(f"Unexpected error executing {script_path}: {str(e)}")
+        return False
+
+def main():
+    """
+    Main function to execute download_ckpts.py with proper error handling.
+    """
+    scripts_dir = "scripts"
+    scripts = [
+        {
+            "path": os.path.join(scripts_dir, "download_ckpts.py"),
+            "args": []  # Empty list for args to avoid NoneType issues
+        },
+        # Uncomment and add arguments if needed for setup_third_party.py
+        # {
+        #     "path": os.path.join(scripts_dir, "setup_third_party.py"),
+        #     "args": []
+        # }
+    ]
+
+    for script in scripts:
+        script_path = script["path"]
+        args = script.get("args", [])  # Safely get args with default empty list
+        print(f"Starting execution of {script_path}{' with args: ' + ' '.join(args) if args else ''}\n")
+        
+        if not run_script(script_path, args):
+            print(f"Stopping execution due to error in {script_path}")
+            sys.exit(1)
+        
+        print(f"Completed execution of {script_path}\n")
+
+if __name__ == "__main__":
+    main()

apps/gradio_app/static/styles.css

@@ -0,0 +1,213 @@
+:root {
+    --primary-color: #10b981; /* Updated to success color */
+    --primary-hover: #0a8f66; /* Darkened shade of #10b981 for hover */
+    --accent-color: #8a1bf2; /* New variable for the second gradient color */
+    --accent-hover: #6b21a8; /* Darkened shade of #8a1bf2 for hover */
+    --secondary-color: #64748b;
+    --success-color: #10b981;
+    --warning-color: #f59e0b;
+    --danger-color: #ef4444;
+    --border-radius: 0.5rem; /* Relative unit */
+    --shadow-sm: 0 0.0625rem 0.125rem 0 rgba(0, 0, 0, 0.05);
+    --shadow-md: 0 0.25rem 0.375rem -0.0625rem rgba(0, 0, 0, 0.1);
+    --shadow-lg: 0 0.625rem 0.9375rem -0.1875rem rgba(0, 0, 0, 0.1);
+}
+
+/* Container Styles */
+.gradio-container {
+    max-width: 75rem !important; /* Relative to viewport */
+    margin: 0 auto !important;
+    padding: 1.25rem !important; /* Relative padding */
+    font-family: 'Segoe UI', system-ui, -apple-system, sans-serif !important;
+}
+
+/* Card/Panel Styles */
+.svelte-15lo0d9, .panel {
+    background: var(--block-background-fill) !important;
+    border-radius: var(--border-radius) !important;
+    box-shadow: var(--shadow-md) !important;
+    border: 0.0625rem solid var(--border-color-primary) !important;
+    backdrop-filter: blur(0.625rem) !important;
+}
+
+/* Button Styles */
+button.primary {
+    background: linear-gradient(135deg, var(--primary-color), var(--accent-color)) !important;
+    border: none !important;
+    border-radius: var(--border-radius) !important;
+    padding: 0.625rem 1.25rem !important; /* Relative padding */
+    font-weight: 600 !important;
+    font-size: 1rem !important; /* Relative font size */
+    transition: all 0.3s ease !important;
+    box-shadow: var(--shadow-sm) !important;
+}
+
+button.primary:hover {
+    background: linear-gradient(135deg, var(--primary-hover), var(--accent-hover)) !important;
+    transform: translateY(-0.0625rem) !important;
+    box-shadow: var(--shadow-md) !important;
+}
+
+button.secondary {
+    background: transparent !important;
+    border: 0.0625rem solid var(--border-color-primary) !important;
+    border-radius: var(--border-radius) !important;
+    color: var(--body-text-color) !important;
+    font-weight: 500 !important;
+    font-size: 0.875rem !important; /* Relative font size */
+}
+
+/* Slider Styles */
+.slider_input_container input[type="range"][name="cowbell"] {
+    -webkit-appearance: none !important;
+    width: 100% !important;
+    height: 0.5rem !important; /* Relative height */
+    border-radius: var(--border-radius) !important;
+    background: linear-gradient(90deg, var(--primary-color), var(--accent-color)) !important;
+    outline: none !important;
+}
+
+.slider_input_container input[type="range"][name="cowbell"]::-webkit-slider-thumb {
+    -webkit-appearance: none !important;
+    width: 1rem !important; /* Relative size */
+    height: 1rem !important;
+    border-radius: 50% !important;
+    background: var(--accent-color) !important;
+    cursor: pointer !important;
+    box-shadow: var(--shadow-sm) !important;
+    border: 0.0625rem solid var(--border-color-primary) !important;
+}
+
+.slider_input_container input[type="range"][name="cowbell"]::-webkit-slider-thumb:hover {
+    background: var(--accent-color) !important;
+    box-shadow: var(--shadow-md) !important;
+}
+
+.slider_input_container input[type="range"][name="cowbell"]::-moz-range-track {
+    height: 0.5rem !important; /* Relative height */
+    border-radius: var(--border-radius) !important;
+    background: linear-gradient(90deg, var(--primary-color), var(--accent-color)) !important;
+}
+
+.slider_input_container input[type="range"][name="cowbell"]::-moz-range-thumb {
+    width: 1rem !important; /* Relative size */
+    height: 1rem !important;
+    border-radius: 50% !important;
+    background: var(--accent-color) !important;
+    cursor: pointer !important;
+    box-shadow: var(--shadow-sm) !important;
+    border: 0.0625rem solid var(--border-color-primary) !important;
+}
+
+.slider_input_container input[type="range"][name="cowbell"]::-moz-range-thumb:hover {
+    background: var(--accent-color) !important;
+    box-shadow: var(--shadow-md) !important;
+}
+
+/* Header Styles */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: 700 !important;
+    color: var(--body-text-color) !important;
+    letter-spacing: -0.02em !important;
+}
+
+h1 {
+    font-size: 2.5rem !important; /* Kept as is, suitable for zooming */
+    margin-bottom: 1rem !important;
+}
+
+h2 {
+    font-size: 1.75rem !important; /* Kept as is, suitable for zooming */
+    margin: 1.5rem 0 1rem 0 !important;
+}
+
+/* Text Styles */
+p, .prose {
+    color: var(--body-text-color-subdued) !important;
+    line-height: 1.6 !important;
+    font-size: 1rem !important; /* Relative font size */
+}
+
+/* Alert/Notification Styles */
+.alert-info {
+    background: linear-gradient(135deg, #dbeafe, #bfdbfe) !important;
+    border: 0.0625rem solid #93c5fd !important;
+    border-radius: var(--border-radius) !important;
+    color: #1e40af !important;
+    font-size: 0.875rem !important; /* Relative font size */
+}
+
+.alert-warning {
+    background: linear-gradient(135deg, #fef3c7, #fde68a) !important;
+    border: 0.0625rem solid #fcd34d !important;
+    border-radius: var(--border-radius) !important;
+    color: #92400e !important;
+    font-size: 0.875rem !important; /* Relative font size */
+}
+
+.alert-error {
+    background: linear-gradient(135deg, #fecaca, #fca5a5) !important;
+    border: 0.0625rem solid #f87171 !important;
+    border-radius: var(--border-radius) !important;
+    color: #991b1b !important;
+    font-size: 0.875rem !important; /* Relative font size */
+}
+
+/* Scrollbar (Webkit browsers) */
+::-webkit-scrollbar {
+    width: 0.5rem !important; /* Relative size */
+    height: 0.5rem !important;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--background-fill-secondary) !important;
+    border-radius: 0.25rem !important;
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--secondary-color) !important;
+    border-radius: 0.25rem !important;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: var(--primary-color) !important;
+}
+
+/* Tab Styles */
+.gradio-container .tabs button {
+    font-size: 1.0625rem !important; /* Relative font size (17px equivalent) */
+    font-weight: bold !important;
+}
+
+/* Dark Theme Specific Overrides */
+@media (prefers-color-scheme: dark) {
+    :root {
+        --shadow-sm: 0 0.0625rem 0.125rem 0 rgba(0, 0, 0, 0.2);
+        --shadow-md: 0 0.25rem 0.375rem -0.0625rem rgba(0, 0, 0, 0.3);
+        --shadow-lg: 0 0.625rem 0.9375rem -0.1875rem rgba(0, 0, 0, 0.3);
+    }
+}
+
+/* Light Theme Specific Overrides */
+@media (prefers-color-scheme: light) {
+    .gradio-container {
+        background: linear-gradient(135deg, #f8fafc, #f1f5f9) !important;
+    }
+}
+
+/* Responsive adjustments for zoom */
+@media screen and (max-width: 48rem) { /* 768px equivalent */
+    .gradio-container {
+        padding: 0.625rem !important;
+    }
+    h1 {
+        font-size: 2rem !important;
+    }
+    h2 {
+        font-size: 1.5rem !important;
+    }
+    button.primary {
+        padding: 0.5rem 1rem !important;
+        font-size: 0.875rem !important;
+    }
+}

apps/old-gradio_app.py

@@ -0,0 +1,261 @@
+import argparse
+import json
+from pathlib import Path
+import os
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from transformers import CLIPTextModel, CLIPTokenizer
+from diffusers import AutoencoderKL, UNet2DConditionModel, PNDMScheduler
+from tqdm import tqdm
+from transformers import HfArgumentParser
+
+def get_examples(examples_dir: str = "apps/gradip_app/assets/examples/ghibli-fine-tuned-sd-2.1") -> list:
+    """
+    Load example data from the assets/examples directory.
+    Each example is a subdirectory containing a config.json and an image file.
+    Returns a list of [prompt, height, width, num_inference_steps, guidance_scale, seed, image_path].
+    """
+    # Check if the directory exists
+    if not os.path.exists(examples_dir) or not os.path.isdir(examples_dir):
+        raise ValueError(f"Directory {examples_dir} does not exist or is not a directory")
+
+    # Get list of subfolder paths (e.g., 1, 2, etc.)
+    all_examples_dir = [os.path.join(examples_dir, d) for d in os.listdir(examples_dir) 
+                        if os.path.isdir(os.path.join(examples_dir, d))]
+
+    ans = []
+    for example_dir in all_examples_dir:
+        config_path = os.path.join(example_dir, "config.json")
+        image_path = os.path.join(example_dir, "result.png")
+        
+        # Check if config.json and result.png exist
+        if not os.path.isfile(config_path):
+            print(f"Warning: config.json not found in {example_dir}")
+            continue
+        if not os.path.isfile(image_path):
+            print(f"Warning: result.png not found in {example_dir}")
+            continue
+        
+        try:
+            with open(config_path, 'r') as f:
+                example_dict = json.load(f)
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Error reading or parsing {config_path}: {e}")
+            continue
+        
+        # Required keys for the config
+        required_keys = ["prompt", "height", "width", "num_inference_steps", "guidance_scale", "seed", "image"]
+        if not all(key in example_dict for key in required_keys):
+            print(f"Warning: Missing required keys in {config_path}")
+            continue
+        
+        # Verify that the image key in config.json matches 'result.png'
+        if example_dict["image"] != "result.png":
+            print(f"Warning: Image key in {config_path} does not match 'result.png'")
+            continue
+        
+        try:
+            example_list = [
+                example_dict["prompt"],
+                example_dict["height"],
+                example_dict["width"],
+                example_dict["num_inference_steps"],
+                example_dict["guidance_scale"],
+                example_dict["seed"],
+                image_path  # Use verified image path
+            ]
+            ans.append(example_list)
+        except KeyError as e:
+            print(f"Error processing {config_path}: Missing key {e}")
+            continue
+    
+    if not ans:
+        ans = [
+            ["a serene landscape in Ghibli style", 64, 64, 50, 3.5, 42, None]
+        ]
+    return ans
+
+def create_demo(
+    model_name: str = "danhtran2mind/ghibli-fine-tuned-sd-2.1",
+    device: str = "cuda" if torch.cuda.is_available() else "cpu",
+):
+    # Convert device string to torch.device
+    device = torch.device(device)
+    dtype = torch.float16 if device.type == "cuda" else torch.float32
+
+    # Load models with consistent dtype
+    vae = AutoencoderKL.from_pretrained(model_name, subfolder="vae", torch_dtype=dtype).to(device)
+    tokenizer = CLIPTokenizer.from_pretrained(model_name, subfolder="tokenizer")
+    text_encoder = CLIPTextModel.from_pretrained(model_name, subfolder="text_encoder", torch_dtype=dtype).to(device)
+    unet = UNet2DConditionModel.from_pretrained(model_name, subfolder="unet", torch_dtype=dtype).to(device)
+    scheduler = PNDMScheduler.from_pretrained(model_name, subfolder="scheduler")
+
+    def generate_image(prompt, height, width, num_inference_steps, guidance_scale, seed, random_seed):
+        if not prompt:
+            return None, "Prompt cannot be empty."
+        if height % 8 != 0 or width % 8 != 0:
+            return None, "Height and width must be divisible by 8 (e.g., 256, 512, 1024)."
+        if num_inference_steps < 1 or num_inference_steps > 100:
+            return None, "Number of inference steps must be between 1 and 100."
+        if guidance_scale < 1.0 or guidance_scale > 20.0:
+            return None, "Guidance scale must be between 1.0 and 20.0."
+        if seed < 0 or seed > 4294967295:
+            return None, "Seed must be between 0 and 4294967295."
+
+        batch_size = 1
+        if random_seed:
+            seed = torch.randint(0, 4294967295, (1,)).item()
+        generator = torch.Generator(device=device).manual_seed(int(seed))
+
+        text_input = tokenizer(
+            [prompt], padding="max_length", max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt"
+        )
+        with torch.no_grad():
+            text_embeddings = text_encoder(text_input.input_ids.to(device))[0].to(dtype=dtype)
+
+        max_length = text_input.input_ids.shape[-1]
+        uncond_input = tokenizer(
+            [""] * batch_size, padding="max_length", max_length=max_length, return_tensors="pt"
+        )
+        with torch.no_grad():
+            uncond_embeddings = text_encoder(uncond_input.input_ids.to(device))[0].to(dtype=dtype)
+
+        text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
+
+        latents = torch.randn(
+            (batch_size, unet.config.in_channels, height // 8, width // 8),
+            generator=generator,
+            dtype=dtype,
+            device=device
+        )
+
+        scheduler.set_timesteps(num_inference_steps)
+        latents = latents * scheduler.init_noise_sigma
+
+        for t in tqdm(scheduler.timesteps, desc="Generating image"):
+            latent_model_input = torch.cat([latents] * 2)
+            latent_model_input = scheduler.scale_model_input(latent_model_input, t)
+
+            with torch.no_grad():
+                if device.type == "cuda":
+                    with torch.autocast(device_type="cuda", dtype=torch.float16):
+                        noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+                else:
+                    noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+
+            noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+            noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+            latents = scheduler.step(noise_pred, t, latents).prev_sample
+
+        with torch.no_grad():
+            latents = latents / vae.config.scaling_factor
+            image = vae.decode(latents).sample
+
+        image = (image / 2 + 0.5).clamp(0, 1)
+        image = image.detach().cpu().permute(0, 2, 3, 1).numpy()
+        image = (image * 255).round().astype("uint8")
+        pil_image = Image.fromarray(image[0])
+
+        return pil_image, f"Image generated successfully! Seed used: {seed}"
+
+    def load_example_image(prompt, height, width, num_inference_steps, guidance_scale, seed, image_path):
+        """
+        Load the image for the selected example and update input fields.
+        """
+        if image_path and Path(image_path).exists():
+            try:
+                image = Image.open(image_path)
+                return prompt, height, width, num_inference_steps, guidance_scale, seed, image, f"Loaded image: {image_path}"
+            except Exception as e:
+                return prompt, height, width, num_inference_steps, guidance_scale, seed, None, f"Error loading image: {e}"
+        return prompt, height, width, num_inference_steps, guidance_scale, seed, None, "No image available"
+
+    badges_text = r"""
+    <div style="text-align: center; display: flex; justify-content: left; gap: 5px;">
+    <a href="https://huggingface.co/spaces/danhtran2mind/ghibli-fine-tuned-sd-2.1"><img src="https://img.shields.io/static/v1?label=%F0%9F%A4%97%20Hugging%20Face&message=Space&color=orange"></a>
+    </div>
+    """.strip()
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# Ghibli-Style Image Generator")
+        gr.Markdown(badges_text)
+        gr.Markdown("Generate images in Ghibli style using a fine-tuned Stable Diffusion model. Select an example below to load a pre-generated image or enter a prompt to generate a new one.")
+        gr.Markdown("""**Note:** For CPU inference, execution time is long (e.g., for resolution 512 × 512) with 50 inference steps, time is approximately 1700 seconds).""")
+
+        with gr.Row():
+            with gr.Column():
+                prompt = gr.Textbox(label="Prompt", placeholder="e.g., 'a serene landscape in Ghibli style'")
+                with gr.Row():
+                    width = gr.Slider(32, 4096, 512, step=8, label="Generation Width")
+                    height = gr.Slider(32, 4096, 512, step=8, label="Generation Height")
+                with gr.Accordion("Advanced Options", open=False):
+                    num_inference_steps = gr.Slider(1, 100, 50, step=1, label="Number of Inference Steps")
+                    guidance_scale = gr.Slider(1.0, 20.0, 3.5, step=0.5, label="Guidance Scale")
+                    seed = gr.Number(42, label="Seed (0 to 4294967295)")
+                    random_seed = gr.Checkbox(label="Use Random Seed", value=False)
+                generate_btn = gr.Button("Generate Image")
+            
+            with gr.Column():
+                output_image = gr.Image(label="Generated Image")
+                output_text = gr.Textbox(label="Status")
+
+        examples = get_examples("assets/examples/ghibli-fine-tuned-sd-2.1")
+        gr.Examples(
+            examples=examples,
+            inputs=[prompt, height, width, num_inference_steps, guidance_scale, seed, output_image],
+            outputs=[prompt, height, width, num_inference_steps, guidance_scale, seed, output_image, output_text],
+            fn=load_example_image,
+            cache_examples=False
+        )
+
+        generate_btn.click(
+            fn=generate_image,
+            inputs=[prompt, height, width, num_inference_steps, guidance_scale, seed, random_seed],
+            outputs=[output_image, output_text]
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Ghibli-Style Image Generator using a fine-tuned Stable Diffusion model.")
+    parser.add_argument(
+        "--local_model",
+        action="store_true",
+        default=True,
+        help="Use local model path instead of Hugging Face model."
+    )
+    parser.add_argument(
+        "--model_name",
+        type=str,
+        default="danhtran2mind/ghibli-fine-tuned-sd-2.1",
+        help="Model name or path for the fine-tuned Stable Diffusion model."
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="cuda" if torch.cuda.is_available() else "cpu",
+        help="Device to run the model on (e.g., 'cuda', 'cpu')."
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=7860,
+        help="Port to run the Gradio app on."
+    )
+    parser.add_argument(
+        "--share",
+        action="store_true",
+        default=False,
+        help="Set to True for public sharing (Hugging Face Spaces)."
+    )
+
+    args = parser.parse_args()
+
+    # Set model_name based on local_model flag
+    if args.local_model:
+        args.model_name = "./checkpoints/ghibli-fine-tuned-sd-2.1"
+
+    demo = create_demo(args.model_name, args.device)
+    demo.launch(server_port=args.port, share=args.share)

apps/old2-gradio_app.py

@@ -0,0 +1,376 @@
+import argparse
+import json
+from pathlib import Path
+import os
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from transformers import CLIPTextModel, CLIPTokenizer
+from diffusers import AutoencoderKL, UNet2DConditionModel, PNDMScheduler, StableDiffusionPipeline
+from tqdm import tqdm
+import yaml
+
+def load_model_configs(config_path: str = "configs/model_ckpts.yaml") -> dict:
+    """
+    Load model configurations from a YAML file.
+    Returns a dictionary with model IDs and their details.
+    """
+    try:
+        with open(config_path, 'r') as f:
+            configs = yaml.safe_load(f)
+        return {cfg['model_id']: cfg for cfg in configs}
+    except (IOError, yaml.YAMLError) as e:
+        raise ValueError(f"Error loading {config_path}: {e}")
+
+def get_examples(examples_dir: str = "apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning") -> list:
+    """
+    Load example data from the assets/examples directory.
+    Each example is a subdirectory containing a config.json and an image file.
+    Returns a list of [prompt, height, width, num_inference_steps, guidance_scale, seed, image_path, use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale].
+    """
+    if not os.path.exists(examples_dir) or not os.path.isdir(examples_dir):
+        raise ValueError(f"Directory {examples_dir} does not exist or is not a directory")
+
+    all_examples_dir = [os.path.join(examples_dir, d) for d in os.listdir(examples_dir) 
+                        if os.path.isdir(os.path.join(examples_dir, d))]
+
+    ans = []
+    for example_dir in all_examples_dir:
+        config_path = os.path.join(example_dir, "config.json")
+        image_path = os.path.join(example_dir, "result.png")
+        
+        if not os.path.isfile(config_path):
+            print(f"Warning: config.json not found in {example_dir}")
+            continue
+        if not os.path.isfile(image_path):
+            print(f"Warning: result.png not found in {example_dir}")
+            continue
+        
+        try:
+            with open(config_path, 'r') as f:
+                example_dict = json.load(f)
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Error reading or parsing {config_path}: {e}")
+            continue
+        
+        required_keys = ["prompt", "height", "width", "num_inference_steps", "guidance_scale", "seed", "image"]
+        if not all(key in example_dict for key in required_keys):
+            print(f"Warning: Missing required keys in {config_path}")
+            continue
+        
+        if example_dict["image"] != "result.png":
+            print(f"Warning: Image key in {config_path} does not match 'result.png'")
+            continue
+        
+        try:
+            example_list = [
+                example_dict["prompt"],
+                example_dict["height"],
+                example_dict["width"],
+                example_dict["num_inference_steps"],
+                example_dict["guidance_scale"],
+                example_dict["seed"],
+                image_path,
+                example_dict.get("use_lora", False),
+                example_dict.get("finetune_model_path", "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"),
+                example_dict.get("lora_model_path", "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA"),
+                example_dict.get("base_model_path", "stabilityai/stable-diffusion-2-1"),
+                example_dict.get("lora_rank", 64),
+                example_dict.get("lora_scale", 1.2)
+            ]
+            ans.append(example_list)
+        except KeyError as e:
+            print(f"Error processing {config_path}: Missing key {e}")
+            continue
+    
+    if not ans:
+        model_configs = load_model_configs("configs/model_ckpts.yaml")
+        finetune_model_id = "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+        lora_model_id = "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA"
+        base_model_id = model_configs[lora_model_id]['base_model_id'] if lora_model_id in model_configs else "stabilityai/stable-diffusion-2-1"
+        ans = [
+            ["a serene landscape in Ghibli style", 512, 512, 50, 3.5, 42, None, False,
+             model_configs.get(finetune_model_id, {}).get('local_dir', finetune_model_id),
+             model_configs.get(lora_model_id, {}).get('local_dir', lora_model_id),
+             base_model_id, 64, 1.2]
+        ]
+    return ans
+
+def create_demo(
+    config_path: str = "configs/model_ckpts.yaml",
+    device: str = "cuda" if torch.cuda.is_available() else "cpu",
+):
+    # Load model configurations
+    model_configs = load_model_configs(config_path)
+    finetune_model_id = "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+    lora_model_id = "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA"
+    finetune_model_path = model_configs[finetune_model_id]['local_dir'] if model_configs[finetune_model_id]['platform'] == "Local" else finetune_model_id
+    lora_model_path = model_configs[lora_model_id]['local_dir'] if model_configs[lora_model_id]['platform'] == "Local" else lora_model_id
+    base_model_path = model_configs[lora_model_id]['base_model_id']
+
+    # Convert device string to torch.device
+    device = torch.device(device)
+    dtype = torch.float16 if device.type == "cuda" else torch.float32
+
+    # Extract model IDs for dropdown choices based on type
+    finetune_model_ids = [mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full-finetuning']
+    lora_model_ids = [mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora']
+    base_model_ids = [model_configs[mid]['base_model_id'] for mid in model_configs if 'base_model_id' in model_configs[mid]]
+
+    def update_model_path_visibility(use_lora):
+        """
+        Update visibility of model path dropdowns based on use_lora checkbox.
+        """
+        if use_lora:
+            return gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)
+        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
+    
+    def generate_image(prompt, height, width, num_inference_steps, guidance_scale, seed, random_seed, use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale):
+        if not prompt:
+            return None, "Prompt cannot be empty."
+        if height % 8 != 0 or width % 8 != 0:
+            return None, "Height and width must be divisible by 8 (e.g., 256, 512, 1024)."
+        if num_inference_steps < 1 or num_inference_steps > 100:
+            return None, "Number of inference steps must be between 1 and 100."
+        if guidance_scale < 1.0 or guidance_scale > 20.0:
+            return None, "Guidance scale must be between 1.0 and 20.0."
+        if seed < 0 or seed > 4294967295:
+            return None, "Seed must be between 0 and 4294967295."
+        if use_lora and (not lora_model_path or not os.path.exists(lora_model_path) and not lora_model_path.startswith("danhtran2mind/")):
+            return None, f"LoRA model path {lora_model_path} does not exist or is invalid."
+        if use_lora and (not base_model_path or not os.path.exists(base_model_path) and not base_model_path.startswith("stabilityai/")):
+            return None, f"Base model path {base_model_path} does not exist or is invalid."
+        if not use_lora and (not finetune_model_path or not os.path.exists(finetune_model_path) and not finetune_model_path.startswith("danhtran2mind/")):
+            return None, f"Fine-tuned model path {finetune_model_path} does not exist or is invalid."
+        if use_lora and (lora_rank < 1 or lora_rank > 128):
+            return None, "LoRA rank must be between 1 and 128."
+        if use_lora and (lora_scale < 0.0 or lora_scale > 2.0):
+            return None, "LoRA scale must be between 0.0 and 2.0."
+
+        batch_size = 1
+        if random_seed:
+            seed = torch.randint(0, 4294967295, (1,)).item()
+        generator = torch.Generator(device=device).manual_seed(int(seed))
+
+        # Load models based on use_lora
+        if use_lora:
+            try:
+                pipe = StableDiffusionPipeline.from_pretrained(
+                    base_model_path,
+                    torch_dtype=dtype,
+                    use_safetensors=True
+                )
+                pipe.load_lora_weights(lora_model_path, adapter_name="ghibli-lora", lora_scale=lora_scale)
+                pipe = pipe.to(device)
+                vae = pipe.vae
+                tokenizer = pipe.tokenizer
+                text_encoder = pipe.text_encoder
+                unet = pipe.unet
+                scheduler = PNDMScheduler.from_config(pipe.scheduler.config)
+            except Exception as e:
+                return None, f"Error loading LoRA model from {lora_model_path} or base model from {base_model_path}: {e}"
+        else:
+            try:
+                vae = AutoencoderKL.from_pretrained(finetune_model_path, subfolder="vae", torch_dtype=dtype).to(device)
+                tokenizer = CLIPTokenizer.from_pretrained(finetune_model_path, subfolder="tokenizer")
+                text_encoder = CLIPTextModel.from_pretrained(finetune_model_path, subfolder="text_encoder", torch_dtype=dtype).to(device)
+                unet = UNet2DConditionModel.from_pretrained(finetune_model_path, subfolder="unet", torch_dtype=dtype).to(device)
+                scheduler = PNDMScheduler.from_pretrained(finetune_model_path, subfolder="scheduler")
+            except Exception as e:
+                return None, f"Error loading fine-tuned model from {finetune_model_path}: {e}"
+
+        text_input = tokenizer(
+            [prompt], padding="max_length", max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt"
+        )
+        with torch.no_grad():
+            text_embeddings = text_encoder(text_input.input_ids.to(device))[0].to(dtype=dtype)
+
+        max_length = text_input.input_ids.shape[-1]
+        uncond_input = tokenizer(
+            [""] * batch_size, padding="max_length", max_length=max_length, return_tensors="pt"
+        )
+        with torch.no_grad():
+            uncond_embeddings = text_encoder(uncond_input.input_ids.to(device))[0].to(dtype=dtype)
+
+        text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
+
+        latents = torch.randn(
+            (batch_size, unet.config.in_channels, height // 8, width // 8),
+            generator=generator,
+            dtype=dtype,
+            device=device
+        )
+
+        scheduler.set_timesteps(num_inference_steps)
+        latents = latents * scheduler.init_noise_sigma
+
+        for t in tqdm(scheduler.timesteps, desc="Generating image"):
+            latent_model_input = torch.cat([latents] * 2)
+            latent_model_input = scheduler.scale_model_input(latent_model_input, t)
+
+            with torch.no_grad():
+                if device.type == "cuda":
+                    with torch.autocast(device_type="cuda", dtype=torch.float16):
+                        noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+                else:
+                    noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+
+            noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+            noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+            latents = scheduler.step(noise_pred, t, latents).prev_sample
+
+        with torch.no_grad():
+            latents = latents / vae.config.scaling_factor
+            image = vae.decode(latents).sample
+
+        image = (image / 2 + 0.5).clamp(0, 1)
+        image = image.detach().cpu().permute(0, 2, 3, 1).numpy()
+        image = (image * 255).round().astype("uint8")
+        pil_image = Image.fromarray(image[0])
+
+        return pil_image, f"Image generated successfully! Seed used: {seed}"
+
+    def load_example_image(prompt, height, width, num_inference_steps, guidance_scale, seed, image_path, use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale):
+        """
+        Load the image for the selected example and update input fields.
+        """
+        if image_path and Path(image_path).exists():
+            try:
+                image = Image.open(image_path)
+                return (
+                    prompt, height, width, num_inference_steps, guidance_scale, seed, image,
+                    use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale,
+                    f"Loaded image: {image_path}"
+                )
+            except Exception as e:
+                return (
+                    prompt, height, width, num_inference_steps, guidance_scale, seed, None,
+                    use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale,
+                    f"Error loading image: {e}"
+                )
+        return (
+            prompt, height, width, num_inference_steps, guidance_scale, seed, None,
+            use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale,
+            "No image available"
+        )
+
+    badges_text = r"""
+    <div style="text-align: left; font-size: 14px; display: flex; flex-direction: column; gap: 10px;">
+        <div style="display: flex; align-items: center; justify-content: left; gap: 8px;">
+            You can explore GitHub repository: 
+            <a href="https://github.com/danhtran2mind/Ghibli-Stable-Diffusion-Synthesis">
+                <img src="https://img.shields.io/badge/GitHub-danhtran2mind%2FGhibli--Stable--Diffusion--Synthesis-blue?style=flat&logo=github" alt="GitHub Repo">
+            </a>.
+        </div>
+        <div style="display: flex; align-items: center; justify-content: left; gap: 8px;">
+            And you can explore HuggingFace Model Hub:
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--Base--finetuning-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+            and
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--LoRA-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+        </div>
+    </div>
+    """.strip()
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# Ghibli-Style Image Generator")
+        gr.Markdown(badges_text)
+        gr.Markdown("Generate images in Ghibli style using a fine-tuned Stable Diffusion model or Stable Diffusion 2.1 with LoRA weights. Select an example below to load a pre-generated image or enter a prompt to generate a new one.")
+        gr.Markdown("""**Note:** For CPU inference, execution time is long (e.g., for resolution 512 × 512 with 50 inference steps, time is approximately 1700 seconds).""")
+
+        with gr.Row():
+            with gr.Column():
+                prompt = gr.Textbox(label="Prompt", placeholder="e.g., 'a serene landscape in Ghibli style'")
+                with gr.Row():
+                    width = gr.Slider(32, 4096, 512, step=8, label="Generation Width")
+                    height = gr.Slider(32, 4096, 512, step=8, label="Generation Height")
+                with gr.Accordion("Advanced Options", open=False):
+                    num_inference_steps = gr.Slider(1, 100, 50, step=1, label="Number of Inference Steps")
+                    guidance_scale = gr.Slider(1.0, 20.0, 3.5, step=0.5, label="Guidance Scale")
+                    seed = gr.Number(42, label="Seed (0 to 4294967295)")
+                    random_seed = gr.Checkbox(label="Use Random Seed", value=False)
+                    use_lora = gr.Checkbox(label="Use LoRA Weights", value=False)
+                    finetune_model_path = gr.Dropdown(
+                        label="Fine-tuned Model Path",
+                        choices=finetune_model_ids,
+                        value=finetune_model_id,
+                        visible=not use_lora.value
+                    )
+                    lora_model_path = gr.Dropdown(
+                        label="LoRA Model Path",
+                        choices=lora_model_ids,
+                        value=lora_model_id,
+                        visible=use_lora.value
+                    )
+                    base_model_path = gr.Dropdown(
+                        label="Base Model Path",
+                        choices=base_model_ids,
+                        value=base_model_path,
+                        visible=use_lora.value
+                    )
+                    lora_rank = gr.Slider(1, 128, 64, step=1, label="LoRA Rank", visible=use_lora.value)
+                    lora_scale = gr.Slider(0.0, 2.0, 1.2, step=0.1, label="LoRA Scale", visible=use_lora.value)
+                generate_btn = gr.Button("Generate Image")
+
+            with gr.Column():
+                output_image = gr.Image(label="Generated Image")
+                output_text = gr.Textbox(label="Status")
+
+        examples = get_examples("assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning")
+        gr.Examples(
+            examples=examples,
+            inputs=[prompt, height, width, num_inference_steps, guidance_scale, seed, output_image, use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale],
+            outputs=[prompt, height, width, num_inference_steps, guidance_scale, seed, output_image, use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale, output_text],
+            fn=load_example_image,
+            cache_examples=False
+        )
+
+        use_lora.change(
+            fn=update_model_path_visibility,
+            inputs=use_lora,
+            outputs=[lora_model_path, base_model_path, finetune_model_path]
+        )
+
+        generate_btn.click(
+            fn=generate_image,
+            inputs=[prompt, height, width, num_inference_steps, guidance_scale, seed, random_seed, use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale],
+            outputs=[output_image, output_text]
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Ghibli-Style Image Generator using a fine-tuned Stable Diffusion model or Stable Diffusion 2.1 with LoRA weights.")
+    parser.add_argument(
+        "--config_path",
+        type=str,
+        default="configs/model_ckpts.yaml",
+        help="Path to the model configuration YAML file."
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="cuda" if torch.cuda.is_available() else "cpu",
+        help="Device to run the model on (e.g., 'cuda', 'cpu')."
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=7860,
+        help="Port to run the Gradio app on."
+    )
+    parser.add_argument(
+        "--share",
+        action="store_true",
+        default=False,
+        help="Set to True for public sharing (Hugging Face Spaces)."
+    )
+
+    args = parser.parse_args()
+
+    demo = create_demo(args.config_path, args.device)
+    demo.launch(server_port=args.port, share=args.share)

apps/old3-gradio_app.py

@@ -0,0 +1,438 @@
+import argparse
+import json
+from pathlib import Path
+import os
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from transformers import CLIPTextModel, CLIPTokenizer
+from diffusers import AutoencoderKL, UNet2DConditionModel, PNDMScheduler, StableDiffusionPipeline
+from tqdm import tqdm
+import yaml
+
+def load_model_configs(config_path: str = "configs/model_ckpts.yaml") -> dict:
+    """
+    Load model configurations from a YAML file.
+    Returns a dictionary with model IDs and their details.
+    """
+    try:
+        with open(config_path, 'r') as f:
+            configs = yaml.safe_load(f)
+        return {cfg['model_id']: cfg for cfg in configs}
+    except (IOError, yaml.YAMLError) as e:
+        raise ValueError(f"Error loading {config_path}: {e}")
+
+def get_examples(examples_dir: str = "apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning") -> list:
+    """
+    Load example data from the assets/examples directory.
+    Each example is a subdirectory containing a config.json and an image file.
+    Returns a list of [prompt, height, width, num_inference_steps, guidance_scale, seed, image_path, use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale].
+    """
+    if not os.path.exists(examples_dir) or not os.path.isdir(examples_dir):
+        raise ValueError(f"Directory {examples_dir} does not exist or is not a directory")
+
+    all_examples_dir = [os.path.join(examples_dir, d) for d in os.listdir(examples_dir) 
+                        if os.path.isdir(os.path.join(examples_dir, d))]
+
+    ans = []
+    for example_dir in all_examples_dir:
+        config_path = os.path.join(example_dir, "config.json")
+        image_path = os.path.join(example_dir, "result.png")
+        
+        if not os.path.isfile(config_path):
+            print(f"Warning: config.json not found in {example_dir}")
+            continue
+        if not os.path.isfile(image_path):
+            print(f"Warning: result.png not found in {example_dir}")
+            continue
+        
+        try:
+            with open(config_path, 'r') as f:
+                example_dict = json.load(f)
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Error reading or parsing {config_path}: {e}")
+            continue
+        
+        required_keys = ["prompt", "height", "width", "num_inference_steps", "guidance_scale", "seed", "image"]
+        if not all(key in example_dict for key in required_keys):
+            print(f"Warning: Missing required keys in {config_path}")
+            continue
+        
+        if example_dict["image"] != "result.png":
+            print(f"Warning: Image key in {config_path} does not match 'result.png'")
+            continue
+        
+        try:
+            model_configs = load_model_configs("configs/model_ckpts.yaml")
+            finetune_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning'), None)
+            lora_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora'), None)
+            
+            example_list = [
+                example_dict["prompt"],
+                example_dict["height"],
+                example_dict["width"],
+                example_dict["num_inference_steps"],
+                example_dict["guidance_scale"],
+                example_dict["seed"],
+                image_path,
+                example_dict.get("use_lora", False),
+                finetune_model_id if finetune_model_id else "stabilityai/stable-diffusion-2-1-base",
+                lora_model_id if lora_model_id else "stabilityai/stable-diffusion-2-1",
+                model_configs.get(lora_model_id, {}).get('base_model_id', "stabilityai/stable-diffusion-2-1") if lora_model_id else "stabilityai/stable-diffusion-2-1",
+                example_dict.get("lora_rank", 64),
+                example_dict.get("lora_scale", 1.2)
+            ]
+            ans.append(example_list)
+        except KeyError as e:
+            print(f"Error processing {config_path}: Missing key {e}")
+            continue
+    
+    if not ans:
+        model_configs = load_model_configs("configs/model_ckpts.yaml")
+        finetune_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning'), "stabilityai/stable-diffusion-2-1-base")
+        lora_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora'), "stabilityai/stable-diffusion-2-1")
+        base_model_id = model_configs.get(lora_model_id, {}).get('base_model_id', "stabilityai/stable-diffusion-2-1")
+        
+        ans = [
+            ["a serene landscape in Ghibli style", 512, 512, 50, 3.5, 42, None, False,
+             finetune_model_id,
+             lora_model_id,
+             base_model_id, 64, 1.2]
+        ]
+    return ans
+
+def create_demo(
+    config_path: str = "configs/model_ckpts.yaml",
+    device: str = "cuda" if torch.cuda.is_available() else "cpu",
+):
+    # Load model configurations
+    model_configs = load_model_configs(config_path)
+    
+    # Load model IDs from YAML
+    finetune_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning'), None)
+    lora_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora'), None)
+    
+    if not finetune_model_id or not lora_model_id:
+        raise ValueError("Could not find full_finetuning or lora model IDs in the configuration file.")
+
+    # Determine finetune model path
+    finetune_config = model_configs.get(finetune_model_id, {})
+    finetune_local_dir = finetune_config.get('local_dir')
+    if finetune_local_dir and os.path.exists(finetune_local_dir) and any(os.path.isfile(os.path.join(finetune_local_dir, f)) for f in os.listdir(finetune_local_dir)):
+        finetune_model_path = finetune_local_dir
+    else:
+        print(f"Local model directory for fine-tuned model '{finetune_model_id}' does not exist or is empty at '{finetune_local_dir}'. Falling back to model ID.")
+        finetune_model_path = finetune_model_id
+
+    # Determine LoRA model path
+    lora_config = model_configs.get(lora_model_id, {})
+    lora_local_dir = lora_config.get('local_dir')
+    if lora_local_dir and os.path.exists(lora_local_dir) and any(os.path.isfile(os.path.join(lora_local_dir, f)) for f in os.listdir(lora_local_dir)):
+        lora_model_path = lora_local_dir
+    else:
+        print(f"Local model directory for LoRA model '{lora_model_id}' does not exist or is empty at '{lora_local_dir}'. Falling back to model ID.")
+        lora_model_path = lora_model_id
+
+    # Determine base model path
+    base_model_id = lora_config.get('base_model_id', 'stabilityai/stable-diffusion-2-1')
+    base_model_config = model_configs.get(base_model_id, {})
+    base_local_dir = base_model_config.get('local_dir')
+    if base_local_dir and os.path.exists(base_local_dir) and any(os.path.isfile(os.path.join(base_local_dir, f)) for f in os.listdir(base_local_dir)):
+        base_model_path = base_local_dir
+    else:
+        print(f"Local model directory for base model '{base_model_id}' does not exist or is empty at '{base_local_dir}'. Falling back to model ID.")
+        base_model_path = base_model_id
+
+    # Convert device string to torch.device
+    device = torch.device(device)
+    dtype = torch.float16 if device.type == "cuda" else torch.float32
+
+    # Extract model IDs for dropdown choices based on type
+    finetune_model_ids = [mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning']
+    lora_model_ids = [mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora']
+    base_model_ids = [model_configs[mid]['base_model_id'] for mid in model_configs if 'base_model_id' in model_configs[mid]]
+
+    def update_model_path_visibility(use_lora):
+        """
+        Update visibility of model path dropdowns and LoRA sliders based on use_lora checkbox.
+        """
+        if use_lora:
+            return gr.update(visible=True), gr.update(visible=True), gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)
+        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+    
+    def generate_image(prompt, height, width, num_inference_steps, guidance_scale, seed, random_seed, use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale):
+        # Resolve model paths for generation
+        model_configs = load_model_configs(config_path)
+        finetune_config = model_configs.get(finetune_model_id, {})
+        finetune_local_dir = finetune_config.get('local_dir')
+        finetune_model_path = finetune_local_dir if finetune_local_dir and os.path.exists(finetune_local_dir) and any(os.path.isfile(os.path.join(finetune_local_dir, f)) for f in os.listdir(finetune_local_dir)) else finetune_model_id
+        
+        lora_config = model_configs.get(lora_model_id, {})
+        lora_local_dir = lora_config.get('local_dir')
+        lora_model_path = lora_local_dir if lora_local_dir and os.path.exists(lora_local_dir) and any(os.path.isfile(os.path.join(lora_local_dir, f)) for f in os.listdir(lora_local_dir)) else lora_model_id
+        
+        base_model_config = model_configs.get(base_model_id, {})
+        base_local_dir = base_model_config.get('local_dir')
+        base_model_path = base_local_dir if base_local_dir and os.path.exists(base_local_dir) and any(os.path.isfile(os.path.join(base_local_dir, f)) for f in os.listdir(base_local_dir)) else base_model_id
+
+        if not prompt:
+            return None, "Prompt cannot be empty."
+        if height % 8 != 0 or width % 8 != 0:
+            return None, "Height and width must be divisible by 8 (e.g., 256, 512, 1024)."
+        if num_inference_steps < 1 or num_inference_steps > 100:
+            return None, "Number of inference steps must be between 1 and 100."
+        if guidance_scale < 1.0 or guidance_scale > 20.0:
+            return None, "Guidance scale must be between 1.0 and 20.0."
+        if seed < 0 or seed > 4294967295:
+            return None, "Seed must be between 0 and 4294967295."
+        if use_lora and (not lora_model_path or not os.path.exists(lora_model_path) and not lora_model_path.startswith("danhtran2mind/")):
+            return None, f"LoRA model path {lora_model_path} does not exist or is invalid."
+        if use_lora and (not base_model_path or not os.path.exists(base_model_path) and not base_model_path.startswith("stabilityai/")):
+            return None, f"Base model path {base_model_path} does not exist or is invalid."
+        if not use_lora and (not finetune_model_path or not os.path.exists(finetune_model_path) and not finetune_model_path.startswith("danhtran2mind/")):
+            return None, f"Fine-tuned model path {finetune_model_path} does not exist or is invalid."
+        if use_lora and (lora_rank < 1 or lora_rank > 128):
+            return None, "LoRA rank must be between 1 and 128."
+        if use_lora and (lora_scale < 0.0 or lora_scale > 2.0):
+            return None, "LoRA scale must be between 0.0 and 2.0."
+
+        batch_size = 1
+        if random_seed:
+            seed = torch.randint(0, 4294967295, (1,)).item()
+        generator = torch.Generator(device=device).manual_seed(int(seed))
+
+        # Load models based on use_lora
+        if use_lora:
+            try:
+                pipe = StableDiffusionPipeline.from_pretrained(
+                    base_model_path,
+                    torch_dtype=dtype,
+                    use_safetensors=True
+                )
+                pipe.load_lora_weights(lora_model_path, adapter_name="ghibli-lora", lora_scale=lora_scale)
+                pipe = pipe.to(device)
+                vae = pipe.vae
+                tokenizer = pipe.tokenizer
+                text_encoder = pipe.text_encoder
+                unet = pipe.unet
+                scheduler = PNDMScheduler.from_config(pipe.scheduler.config)
+            except Exception as e:
+                return None, f"Error loading LoRA model from {lora_model_path} or base model from {base_model_path}: {e}"
+        else:
+            try:
+                vae = AutoencoderKL.from_pretrained(finetune_model_path, subfolder="vae", torch_dtype=dtype).to(device)
+                tokenizer = CLIPTokenizer.from_pretrained(finetune_model_path, subfolder="tokenizer")
+                text_encoder = CLIPTextModel.from_pretrained(finetune_model_path, subfolder="text_encoder", torch_dtype=dtype).to(device)
+                unet = UNet2DConditionModel.from_pretrained(finetune_model_path, subfolder="unet", torch_dtype=dtype).to(device)
+                scheduler = PNDMScheduler.from_pretrained(finetune_model_path, subfolder="scheduler")
+            except Exception as e:
+                return None, f"Error loading fine-tuned model from {finetune_model_path}: {e}"
+
+        text_input = tokenizer(
+            [prompt], padding="max_length", max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt"
+        )
+        with torch.no_grad():
+            text_embeddings = text_encoder(text_input.input_ids.to(device))[0].to(dtype=dtype)
+
+        max_length = text_input.input_ids.shape[-1]
+        uncond_input = tokenizer(
+            [""] * batch_size, padding="max_length", max_length=max_length, return_tensors="pt"
+        )
+        with torch.no_grad():
+            uncond_embeddings = text_encoder(uncond_input.input_ids.to(device))[0].to(dtype=dtype)
+
+        text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
+
+        latents = torch.randn(
+            (batch_size, unet.config.in_channels, height // 8, width // 8),
+            generator=generator,
+            dtype=dtype,
+            device=device
+        )
+
+        scheduler.set_timesteps(num_inference_steps)
+        latents = latents * scheduler.init_noise_sigma
+
+        for t in tqdm(scheduler.timesteps, desc="Generating image"):
+            latent_model_input = torch.cat([latents] * 2)
+            latent_model_input = scheduler.scale_model_input(latent_model_input, t)
+
+            with torch.no_grad():
+                if device.type == "cuda":
+                    with torch.autocast(device_type="cuda", dtype=torch.float16):
+                        noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+                else:
+                    noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+
+            noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+            noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+            latents = scheduler.step(noise_pred, t, latents).prev_sample
+
+        with torch.no_grad():
+            latents = latents / vae.config.scaling_factor
+            image = vae.decode(latents).sample
+
+        image = (image / 2 + 0.5).clamp(0, 1)
+        image = image.detach().cpu().permute(0, 2, 3, 1).numpy()
+        image = (image * 255).round().astype("uint8")
+        pil_image = Image.fromarray(image[0])
+
+        # Success message includes LoRA Path and LoRA Scale when use_lora is True
+        if use_lora:
+            return pil_image, f"Image generated successfully! Seed used: {seed}, LoRA Path: {lora_model_path}, LoRA Scale: {lora_scale}"
+        return pil_image, f"Image generated successfully! Seed used: {seed}"
+
+    def load_example_image(prompt, height, width, num_inference_steps, guidance_scale, seed, image_path, use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale):
+        """
+        Load the image for the selected example and update input fields.
+        """
+        if image_path and Path(image_path).exists():
+            try:
+                image = Image.open(image_path)
+                return (
+                    prompt, height, width, num_inference_steps, guidance_scale, seed, image,
+                    use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale,
+                    f"Loaded image: {image_path}"
+                )
+            except Exception as e:
+                return (
+                    prompt, height, width, num_inference_steps, guidance_scale, seed, None,
+                    use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale,
+                    f"Error loading image: {e}"
+                )
+        return (
+            prompt, height, width, num_inference_steps, guidance_scale, seed, None,
+            use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale,
+            "No image available"
+        )
+
+    badges_text = r"""
+    <div style="text-align: left; font-size: 14px; display: flex; flex-direction: column; gap: 10px;">
+        <div style="display: flex; align-items: center; justify-content: left; gap: 8px;">
+            You can explore GitHub repository: 
+            <a href="https://github.com/danhtran2mind/Ghibli-Stable-Diffusion-Synthesis">
+                <img src="https://img.shields.io/badge/GitHub-danhtran2mind%2FGhibli--Stable--Diffusion--Synthesis-blue?style=flat&logo=github" alt="GitHub Repo">
+            </a>. And you can explore HuggingFace Model Hub:
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--Base--finetuning-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+            and
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--LoRA-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+        </div>
+    </div>
+    """.strip()
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# Ghibli-Style Image Generator")
+        gr.Markdown(badges_text)
+        gr.Markdown("Generate images in Ghibli style using a fine-tuned Stable Diffusion model or Stable Diffusion 2.1 with LoRA weights. Select an example below to load a pre-generated image or enter a prompt to generate a new one.")
+        gr.Markdown("""**Note:** For CPU inference, execution time is long (e.g., for resolution 512 × 512 with 50 inference steps, time is approximately 1700 seconds).""")
+
+        with gr.Row():
+            with gr.Column():
+                prompt = gr.Textbox(label="Prompt", placeholder="e.g., 'a serene landscape in Ghibli style'")
+                with gr.Row():
+                    width = gr.Slider(32, 4096, 512, step=8, label="Generation Width")
+                    height = gr.Slider(32, 4096, 512, step=8, label="Generation Height")
+                with gr.Accordion("Advanced Options", open=False):
+                    num_inference_steps = gr.Slider(1, 100, 50, step=1, label="Number of Inference Steps")
+                    guidance_scale = gr.Slider(1.0, 20.0, 3.5, step=0.5, label="Guidance Scale")
+                    seed = gr.Number(42, label="Seed (0 to 4294967295)")
+                    random_seed = gr.Checkbox(label="Use Random Seed", value=False)
+                    use_lora = gr.Checkbox(label="Use LoRA Weights", value=False)
+                    finetune_model_path = gr.Dropdown(
+                        label="Fine-tuned Model Path",
+                        choices=finetune_model_ids,
+                        value=finetune_model_id,
+                        visible=not use_lora.value
+                    )
+                    lora_model_path = gr.Dropdown(
+                        label="LoRA Model Path",
+                        choices=lora_model_ids,
+                        value=lora_model_id,
+                        visible=use_lora.value
+                    )
+                    base_model_path = gr.Dropdown(
+                        label="Base Model Path",
+                        choices=base_model_ids,
+                        value=base_model_id,
+                        visible=use_lora.value
+                    )
+                    
+                with gr.Group(visible=use_lora.value):
+                    gr.Markdown("### LoRA Configuration")
+                    lora_rank = gr.Slider(
+                        1, 128, 64, step=1, 
+                        label="LoRA Rank (controls model complexity)", 
+                        visible=use_lora.value, 
+                        info="Adjusts the rank of LoRA weights, affecting model complexity and memory usage."
+                    )
+                    lora_scale = gr.Slider(
+                        0.0, 2.0, 1.2, step=0.1, 
+                        label="LoRA Scale (controls weight influence)", 
+                        visible=use_lora.value, 
+                        info="Adjusts the influence of LoRA weights on the base model."
+                    )
+            generate_btn = gr.Button("Generate Image")
+
+            with gr.Column():
+                output_image = gr.Image(label="Generated Image")
+                output_text = gr.Textbox(label="Status")
+
+        examples = get_examples("apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning")
+        gr.Examples(
+            examples=examples,
+            inputs=[prompt, height, width, num_inference_steps, guidance_scale, seed, output_image, use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale],
+            outputs=[prompt, height, width, num_inference_steps, guidance_scale, seed, output_image, use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale, output_text],
+            fn=load_example_image,
+            cache_examples=False
+        )
+
+        use_lora.change(
+            fn=update_model_path_visibility,
+            inputs=use_lora,
+            outputs=[lora_model_path, base_model_path, finetune_model_path, lora_rank, lora_scale]
+        )
+
+        generate_btn.click(
+            fn=generate_image,
+            inputs=[prompt, height, width, num_inference_steps, guidance_scale, seed, random_seed, use_lora, finetune_model_path, lora_model_path, base_model_path, lora_rank, lora_scale],
+            outputs=[output_image, output_text]
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Ghibli-Style Image Generator using a fine-tuned Stable Diffusion model or Stable Diffusion 2.1 with LoRA weights.")
+    parser.add_argument(
+        "--config_path",
+        type=str,
+        default="configs/model_ckpts.yaml",
+        help="Path to the model configuration YAML file."
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="cuda" if torch.cuda.is_available() else "cpu",
+        help="Device to run the model on (e.g., 'cuda', 'cpu')."
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=7860,
+        help="Port to run the Gradio app on."
+    )
+    parser.add_argument(
+        "--share",
+        action="store_true",
+        default=False,
+        help="Set to True for public sharing (Hugging Face Spaces)."
+    )
+
+    args = parser.parse_args()
+
+    demo = create_demo(args.config_path, args.device)
+    demo.launch(server_port=args.port, share=args.share)

apps/old4-gradio_app.py

@@ -0,0 +1,548 @@
+import argparse
+import json
+from pathlib import Path
+import os
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from transformers import CLIPTextModel, CLIPTokenizer
+from diffusers import AutoencoderKL, UNet2DConditionModel, PNDMScheduler, StableDiffusionPipeline
+from tqdm import tqdm
+import yaml
+
+def load_model_configs(config_path: str = "configs/model_ckpts.yaml") -> dict:
+    """
+    Load model configurations from a YAML file.
+    Returns a dictionary with model IDs and their details.
+    """
+    try:
+        with open(config_path, 'r') as f:
+            configs = yaml.safe_load(f)
+        return {cfg['model_id']: cfg for cfg in configs}
+    except (IOError, yaml.YAMLError) as e:
+        raise ValueError(f"Error loading {config_path}: {e}")
+
+def get_examples(examples_dir: str = "apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning") -> list:
+    
+    if not os.path.exists(examples_dir) or not os.path.isdir(examples_dir):
+        raise ValueError(f"Directory {examples_dir} does not exist or is not a directory")
+
+    all_examples_dir = [os.path.join(examples_dir, d) for d in os.listdir(examples_dir) 
+                        if os.path.isdir(os.path.join(examples_dir, d))]
+
+    ans = []
+    for example_dir in all_examples_dir:
+        config_path = os.path.join(example_dir, "config.json")
+        image_path = os.path.join(example_dir, "result.png")
+        
+        if not os.path.isfile(config_path):
+            print(f"Warning: config.json not found in {example_dir}")
+            continue
+        if not os.path.isfile(image_path):
+            print(f"Warning: result.png not found in {example_dir}")
+            continue
+        
+        try:
+            with open(config_path, 'r') as f:
+                example_dict = json.load(f)
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Error reading or parsing {config_path}: {e}")
+            continue
+        
+        # Required keys for all configs
+        required_keys = ["prompt", "height", "width", "num_inference_steps", "guidance_scale", "seed", "image"]
+        if not all(key in example_dict for key in required_keys):
+            print(f"Warning: Missing required keys in {config_path}")
+            continue
+        
+        if example_dict["image"] != "result.png":
+            print(f"Warning: Image key in {config_path} does not match 'result.png'")
+            continue
+        
+        try:
+            use_lora = example_dict.get("use_lora", False)
+            example_list = [
+                example_dict["prompt"],
+                example_dict["height"],
+                example_dict["width"],
+                example_dict["num_inference_steps"],
+                example_dict["guidance_scale"],
+                example_dict["seed"],
+                image_path,
+                use_lora
+            ]
+            
+            if use_lora:
+                # Additional required keys for LoRA config
+                lora_required_keys = ["lora_model_id", "base_model_id", "lora_rank", "lora_scale"]
+                if not all(key in example_dict for key in lora_required_keys):
+                    print(f"Warning: Missing required LoRA keys in {config_path}")
+                    continue
+                    
+                example_list.extend([
+                    None,  # finetune_model_id (not used for LoRA)
+                    example_dict["lora_model_id"],
+                    example_dict["base_model_id"],
+                    example_dict["lora_rank"],
+                    example_dict["lora_scale"]
+                ])
+            else:
+                # Additional required key for non-LoRA config
+                if "finetune_model_id" not in example_dict:
+                    print(f"Warning: Missing finetune_model_id in {config_path}")
+                    continue
+                    
+                example_list.extend([
+                    example_dict["finetune_model_id"],
+                    None,  # lora_model_id
+                    None,  # base_model_id
+                    None,  # lora_rank
+                    None   # lora_scale
+                ])
+            
+            ans.append(example_list)
+        except KeyError as e:
+            print(f"Error processing {config_path}: Missing key {e}")
+            continue
+    
+    if not ans:
+        # Default example for non-LoRA
+        ans = [
+            ["a serene landscape in Ghibli style", 512, 512, 50, 3.5, 42, None, False,
+             "stabilityai/stable-diffusion-2-1-base",
+             None, None, None, None]
+        ]
+        # Default example for LoRA
+        ans.append(
+            ["a serene landscape in Ghibli style", 512, 512, 50, 3.5, 42, None, True,
+             None,
+             "stabilityai/stable-diffusion-2-1",
+             "stabilityai/stable-diffusion-2-1",
+             64, 1.2]
+        )
+    
+    return ans
+
+def create_demo(
+    config_path: str = "configs/model_ckpts.yaml",
+    device: str = "cuda" if torch.cuda.is_available() else "cpu",
+):
+    # Load model configurations
+    model_configs = load_model_configs(config_path)
+    
+    # Load model IDs from YAML
+    finetune_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning'), None)
+    lora_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora'), None)
+    
+    if not finetune_model_id or not lora_model_id:
+        raise ValueError("Could not find full_finetuning or lora model IDs in the configuration file.")
+
+    # Determine finetune model path
+    finetune_config = model_configs.get(finetune_model_id, {})
+    finetune_local_dir = finetune_config.get('local_dir')
+    if finetune_local_dir and os.path.exists(finetune_local_dir) and any(os.path.isfile(os.path.join(finetune_local_dir, f)) for f in os.listdir(finetune_local_dir)):
+        finetune_model_path = finetune_local_dir
+    else:
+        print(f"Local model directory for fine-tuned model '{finetune_model_id}' does not exist or is empty at '{finetune_local_dir}'. Falling back to model ID.")
+        finetune_model_path = finetune_model_id
+
+    # Determine LoRA model path
+    lora_config = model_configs.get(lora_model_id, {})
+    lora_local_dir = lora_config.get('local_dir')
+    if lora_local_dir and os.path.exists(lora_local_dir) and any(os.path.isfile(os.path.join(lora_local_dir, f)) for f in os.listdir(lora_local_dir)):
+        lora_model_path = lora_local_dir
+    else:
+        print(f"Local model directory for LoRA model '{lora_model_id}' does not exist or is empty at '{lora_local_dir}'. Falling back to model ID.")
+        lora_model_path = lora_model_id
+
+    # Determine base model path
+    base_model_id = lora_config.get('base_model_id', 'stabilityai/stable-diffusion-2-1')
+    base_model_config = model_configs.get(base_model_id, {})
+    base_local_dir = base_model_config.get('local_dir')
+    if base_local_dir and os.path.exists(base_local_dir) and any(os.path.isfile(os.path.join(base_local_dir, f)) for f in os.listdir(base_local_dir)):
+        base_model_path = base_local_dir
+    else:
+        print(f"Local model directory for base model '{base_model_id}' does not exist or is empty at '{base_local_dir}'. Falling back to model ID.")
+        base_model_path = base_model_id
+
+    # Convert device string to torch.device
+    device = torch.device(device)
+    dtype = torch.float16 if device.type == "cuda" else torch.float32
+
+    # Extract model IDs for dropdown choices based on type
+    finetune_model_ids = [mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning']
+    lora_model_ids = [mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora']
+    base_model_ids = [model_configs[mid]['base_model_id'] for mid in model_configs if 'base_model_id' in model_configs[mid]]
+
+    def update_model_path_visibility(use_lora):
+        """
+        Update visibility of model path dropdowns and LoRA sliders based on use_lora checkbox.
+        """
+        if use_lora:
+            return gr.update(visible=True), gr.update(visible=True), gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)
+        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+    
+    def generate_image(prompt, height, width, num_inference_steps, guidance_scale, seed, random_seed, use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale):
+        # Resolve model paths for generation
+        model_configs = load_model_configs(config_path)
+        finetune_config = model_configs.get(finetune_model_id, {})
+        finetune_local_dir = finetune_config.get('local_dir')
+        finetune_model_path = finetune_local_dir if finetune_local_dir and os.path.exists(finetune_local_dir) and any(os.path.isfile(os.path.join(finetune_local_dir, f)) for f in os.listdir(finetune_local_dir)) else finetune_model_id
+        
+        lora_config = model_configs.get(lora_model_id, {})
+        lora_local_dir = lora_config.get('local_dir')
+        lora_model_path = lora_local_dir if lora_local_dir and os.path.exists(lora_local_dir) and any(os.path.isfile(os.path.join(lora_local_dir, f)) for f in os.listdir(lora_local_dir)) else lora_model_id
+        
+        base_model_config = model_configs.get(base_model_id, {})
+        base_local_dir = base_model_config.get('local_dir')
+        base_model_path = base_local_dir if base_local_dir and os.path.exists(base_local_dir) and any(os.path.isfile(os.path.join(base_local_dir, f)) for f in os.listdir(base_local_dir)) else base_model_id
+
+        if not prompt:
+            return None, "Prompt cannot be empty."
+        if height % 8 != 0 or width % 8 != 0:
+            return None, "Height and width must be divisible by 8 (e.g., 256, 512, 1024)."
+        if num_inference_steps < 1 or num_inference_steps > 100:
+            return None, "Number of inference steps must be between 1 and 100."
+        if guidance_scale < 1.0 or guidance_scale > 20.0:
+            return None, "Guidance scale must be between 1.0 and 20.0."
+        if seed < 0 or seed > 4294967295:
+            return None, "Seed must be between 0 and 4294967295."
+        if use_lora and (not lora_model_path or not os.path.exists(lora_model_path) and not lora_model_path.startswith("danhtran2mind/")):
+            return None, f"LoRA model path {lora_model_path} does not exist or is invalid."
+        if use_lora and (not base_model_path or not os.path.exists(base_model_path) and not base_model_path.startswith("stabilityai/")):
+            return None, f"Base model path {base_model_path} does not exist or is invalid."
+        if not use_lora and (not finetune_model_path or not os.path.exists(finetune_model_path) and not finetune_model_path.startswith("danhtran2mind/")):
+            return None, f"Fine-tuned model path {finetune_model_path} does not exist or is invalid."
+        if use_lora and (lora_rank < 1 or lora_rank > 128):
+            return None, "LoRA rank must be between 1 and 128."
+        if use_lora and (lora_scale < 0.0 or lora_scale > 2.0):
+            return None, "LoRA scale must be between 0.0 and 2.0."
+
+        batch_size = 1
+        if random_seed:
+            seed = torch.randint(0, 4294967295, (1,)).item()
+        generator = torch.Generator(device=device).manual_seed(int(seed))
+
+        # Load models based on use_lora
+        if use_lora:
+            try:
+                pipe = StableDiffusionPipeline.from_pretrained(
+                    base_model_path,
+                    torch_dtype=dtype,
+                    use_safetensors=True
+                )
+                pipe.load_lora_weights(lora_model_path, adapter_name="ghibli-lora", lora_scale=lora_scale)
+                pipe = pipe.to(device)
+                vae = pipe.vae
+                tokenizer = pipe.tokenizer
+                text_encoder = pipe.text_encoder
+                unet = pipe.unet
+                scheduler = PNDMScheduler.from_config(pipe.scheduler.config)
+            except Exception as e:
+                return None, f"Error loading LoRA model from {lora_model_path} or base model from {base_model_path}: {e}"
+        else:
+            try:
+                vae = AutoencoderKL.from_pretrained(finetune_model_path, subfolder="vae", torch_dtype=dtype).to(device)
+                tokenizer = CLIPTokenizer.from_pretrained(finetune_model_path, subfolder="tokenizer")
+                text_encoder = CLIPTextModel.from_pretrained(finetune_model_path, subfolder="text_encoder", torch_dtype=dtype).to(device)
+                unet = UNet2DConditionModel.from_pretrained(finetune_model_path, subfolder="unet", torch_dtype=dtype).to(device)
+                scheduler = PNDMScheduler.from_pretrained(finetune_model_path, subfolder="scheduler")
+            except Exception as e:
+                return None, f"Error loading fine-tuned model from {finetune_model_path}: {e}"
+
+        text_input = tokenizer(
+            [prompt], padding="max_length", max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt"
+        )
+        with torch.no_grad():
+            text_embeddings = text_encoder(text_input.input_ids.to(device))[0].to(dtype=dtype)
+
+        max_length = text_input.input_ids.shape[-1]
+        uncond_input = tokenizer(
+            [""] * batch_size, padding="max_length", max_length=max_length, return_tensors="pt"
+        )
+        with torch.no_grad():
+            uncond_embeddings = text_encoder(uncond_input.input_ids.to(device))[0].to(dtype=dtype)
+
+        text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
+
+        latents = torch.randn(
+            (batch_size, unet.config.in_channels, height // 8, width // 8),
+            generator=generator,
+            dtype=dtype,
+            device=device
+        )
+
+        scheduler.set_timesteps(num_inference_steps)
+        latents = latents * scheduler.init_noise_sigma
+
+        for t in tqdm(scheduler.timesteps, desc="Generating image"):
+            latent_model_input = torch.cat([latents] * 2)
+            latent_model_input = scheduler.scale_model_input(latent_model_input, t)
+
+            with torch.no_grad():
+                if device.type == "cuda":
+                    with torch.autocast(device_type="cuda", dtype=torch.float16):
+                        noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+                else:
+                    noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+
+            noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+            noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+            latents = scheduler.step(noise_pred, t, latents).prev_sample
+
+        with torch.no_grad():
+            latents = latents / vae.config.scaling_factor
+            image = vae.decode(latents).sample
+
+        image = (image / 2 + 0.5).clamp(0, 1)
+        image = image.detach().cpu().permute(0, 2, 3, 1).numpy()
+        image = (image * 255).round().astype("uint8")
+        pil_image = Image.fromarray(image[0])
+
+        # Success message includes LoRA Path and LoRA Scale when use_lora is True
+        if use_lora:
+            return pil_image, f"Image generated successfully! Seed used: {seed}, LoRA Path: {lora_model_path}, LoRA Scale: {lora_scale}"
+        return pil_image, f"Image generated successfully! Seed used: {seed}"
+
+    def load_example_image(prompt, height, width, num_inference_steps, guidance_scale,
+                            seed, image_path, use_lora, finetune_model_id, lora_model_id,
+                            base_model_id, lora_rank, lora_scale):
+        """
+        Load the image for the selected example and update input fields.
+        """
+        if image_path and Path(image_path).exists():
+            try:
+                image = Image.open(image_path)
+                return (
+                    prompt, height, width, num_inference_steps, guidance_scale, seed, image,
+                    use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale,
+                    f"Loaded image: {image_path}"
+                )
+            except Exception as e:
+                return (
+                    prompt, height, width, num_inference_steps, guidance_scale, seed, None,
+                    use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale,
+                    f"Error loading image: {e}"
+                )
+        return (
+            prompt, height, width, num_inference_steps, guidance_scale, seed, None,
+            use_lora, finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale,
+            "No image available"
+        )
+
+    badges_text = r"""
+    <div style="text-align: left; font-size: 14px; display: flex; flex-direction: column; gap: 10px;">
+        <div style="display: flex; align-items: center; justify-content: left; gap: 8px;">
+            You can explore GitHub repository: 
+            <a href="https://github.com/danhtran2mind/Ghibli-Stable-Diffusion-Synthesis">
+                <img src="https://img.shields.io/badge/GitHub-danhtran2mind%2FGhibli--Stable--Diffusion--Synthesis-blue?style=flat&logo=github" alt="GitHub Repo">
+            </a>. And you can explore HuggingFace Model Hub:
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--Base--finetuning-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+            and
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--LoRA-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+        </div>
+    </div>
+    """.strip()
+
+    with gr.Blocks() as demo:
+        # Main Layout: Split into Input and Output Columns
+        with gr.Row():
+            # Input Column
+            with gr.Column(scale=1):
+                gr.Markdown("## Image Generation Settings")
+                
+                # Prompt Input
+                prompt = gr.Textbox(
+                    label="Prompt",
+                    placeholder="e.g., 'a serene landscape in Ghibli style'",
+                    lines=2
+                )
+                
+                # Image Dimensions
+                with gr.Group():
+                    gr.Markdown("### Image Dimensions")
+                    with gr.Row():
+                        width = gr.Slider(
+                            minimum=32,
+                            maximum=4096,
+                            value=512,
+                            step=8,
+                            label="Width"
+                        )
+                        height = gr.Slider(
+                            minimum=32,
+                            maximum=4096,
+                            value=512,
+                            step=8,
+                            label="Height"
+                        )
+                
+                # Advanced Settings Accordion
+                with gr.Accordion("Advanced Settings", open=False):
+                    num_inference_steps = gr.Slider(
+                        minimum=1,
+                        maximum=100,
+                        value=50,
+                        step=1,
+                        label="Inference Steps",
+                        info="Higher steps improve quality but increase generation time."
+                    )
+                    guidance_scale = gr.Slider(
+                        minimum=1.0,
+                        maximum=20.0,
+                        value=3.5,
+                        step=0.5,
+                        label="Guidance Scale",
+                        info="Controls how closely the image follows the prompt."
+                    )
+                    lora_rank = gr.Slider(
+                        minimum=1,
+                        maximum=128,
+                        value=64,
+                        step=1,
+                        visible=False,  # Initially hidden
+                        label="LoRA Rank",
+                        info="Controls model complexity and memory usage."
+                    )
+                    lora_scale = gr.Slider(
+                        minimum=0.0,
+                        maximum=2.0,
+                        value=1.2,
+                        step=0.1,
+                        visible=False,  # Initially hidden
+                        label="LoRA Scale",
+                        info="Adjusts the influence of LoRA weights."
+                    )
+                    random_seed = gr.Checkbox(
+                        label="Use Random Seed",
+                        value=False
+                    )
+                    seed = gr.Slider(
+                        minimum=0,
+                        maximum=4294967295,
+                        value=42,
+                        step=1,
+                        label="Seed (0–4294967295)",
+                        info="Set a specific seed for reproducible results."
+                    )
+                
+                # Model Selection
+                with gr.Group():
+                    gr.Markdown("### Model Configuration")
+                    use_lora = gr.Checkbox(
+                        label="Use LoRA Weights",
+                        value=False,
+                        info="Enable to use LoRA weights with a base model."
+                    )
+                    
+                    # Model Path Dropdowns
+                    finetune_model_path = gr.Dropdown(
+                        label="Fine-tuned Model",
+                        choices=finetune_model_ids,
+                        value=finetune_model_id,
+                        visible=not use_lora.value
+                    )
+                    lora_model_path = gr.Dropdown(
+                        label="LoRA Model",
+                        choices=lora_model_ids,
+                        value=lora_model_id,
+                        visible=use_lora.value
+                    )
+                    base_model_path = gr.Dropdown(
+                        label="Base Model",
+                        choices=base_model_ids,
+                        value=base_model_id,
+                        visible=use_lora.value
+                    )
+                
+                # Generate Button
+                generate_btn = gr.Button("Generate Image", variant="primary")
+
+            # Output Column
+            with gr.Column(scale=1):
+                gr.Markdown("## Generated Result")
+                output_image = gr.Image(
+                    label="Generated Image",
+                    interactive=False,
+                    height=512
+                )
+                output_text = gr.Textbox(
+                    label="Generation Status",
+                    interactive=False,
+                    lines=3
+                )
+
+        # Examples Section
+        gr.Markdown("## Try an Example")
+        examples = get_examples("apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning")
+        gr.Examples(
+            examples=examples,
+            inputs=[
+                prompt, height, width, num_inference_steps, guidance_scale, seed,
+                use_lora, finetune_model_path, lora_model_path, base_model_path,
+                lora_rank, lora_scale
+            ],
+            outputs=[
+                prompt, height, width, num_inference_steps, guidance_scale, seed,
+                output_image, use_lora, finetune_model_path, lora_model_path,
+                base_model_path, lora_rank, lora_scale, output_text
+            ],
+            fn=load_example_image,
+            cache_examples=False
+        )
+
+        # Event Handlers
+        use_lora.change(
+            fn=update_model_path_visibility,
+            inputs=use_lora,
+            outputs=[lora_model_path, base_model_path, finetune_model_path, lora_rank, lora_scale]
+        )
+
+        generate_btn.click(
+            fn=generate_image,
+            inputs=[
+                prompt, height, width, num_inference_steps, guidance_scale, seed,
+                random_seed, use_lora, finetune_model_path, lora_model_path,
+                base_model_path, lora_rank, lora_scale
+            ],
+            outputs=[output_image, output_text]
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Ghibli-Style Image Generator using a fine-tuned Stable Diffusion model or Stable Diffusion 2.1 with LoRA weights.")
+    parser.add_argument(
+        "--config_path",
+        type=str,
+        default="configs/model_ckpts.yaml",
+        help="Path to the model configuration YAML file."
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="cuda" if torch.cuda.is_available() else "cpu",
+        help="Device to run the model on (e.g., 'cuda', 'cpu')."
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=7860,
+        help="Port to run the Gradio app on."
+    )
+    parser.add_argument(
+        "--share",
+        action="store_true",
+        default=False,
+        help="Set to True for public sharing (Hugging Face Spaces)."
+    )
+
+    args = parser.parse_args()
+
+    demo = create_demo(args.config_path, args.device)
+    demo.launch(server_port=args.port, share=args.share)

apps/old5-gradio_app.py

@@ -0,0 +1,258 @@
+import argparse
+import json
+from typing import Union, List
+from pathlib import Path
+import os
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from transformers import CLIPTextModel, CLIPTokenizer
+from diffusers import AutoencoderKL, UNet2DConditionModel, PNDMScheduler, StableDiffusionPipeline
+from tqdm import tqdm
+import yaml
+
+def load_model_configs(config_path: str = "configs/model_ckpts.yaml") -> dict:
+    with open(config_path, 'r') as f:
+        return {cfg['model_id']: cfg for cfg in yaml.safe_load(f)}
+
+def get_examples(examples_dir: Union[str, List[str]] = None, use_lora: bool = None) -> List:
+    directories = [examples_dir] if isinstance(examples_dir, str) else examples_dir or []
+    valid_dirs = [d for d in directories if os.path.isdir(d)]
+    if not valid_dirs:
+        return get_provided_examples(use_lora)
+
+    examples = []
+    for dir_path in valid_dirs:
+        for subdir in sorted(os.path.join(dir_path, d) for d in os.listdir(dir_path) if os.path.isdir(os.path.join(dir_path, d))):
+            config_path = os.path.join(subdir, "config.json")
+            image_path = os.path.join(subdir, "result.png")
+            if not (os.path.isfile(config_path) and os.path.isfile(image_path)):
+                continue
+
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+
+            required_keys = ["prompt", "height", "width", "num_inference_steps", "guidance_scale", "seed", "image"]
+            if config.get("use_lora", False):
+                required_keys.extend(["lora_model_id", "base_model_id", "lora_rank", "lora_scale"])
+            else:
+                required_keys.append("finetune_model_id")
+
+            if set(required_keys) - set(config.keys()) or config["image"] != "result.png":
+                continue
+
+            try:
+                image = Image.open(image_path)
+            except Exception:
+                continue
+
+            if use_lora is not None and config.get("use_lora", False) != use_lora:
+                continue
+
+            example = [config["prompt"], config["height"], config["width"], config["num_inference_steps"], 
+                       config["guidance_scale"], config["seed"], image]
+            example.extend([config["lora_model_id"], config["base_model_id"], config["lora_rank"], config["lora_scale"]] 
+                          if config.get("use_lora", False) else [config["finetune_model_id"]])
+            examples.append(example)
+
+    return examples or get_provided_examples(use_lora)
+
+def get_provided_examples(use_lora: bool = False) -> list:
+    example_path = f"apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-{'LoRA' if use_lora else 'Base-finetuning'}/1/result.png"
+    image = Image.open(example_path) if os.path.exists(example_path) else None
+    return [[
+        "a cat is laying on a sofa in Ghibli style" if use_lora else "a serene landscape in Ghibli style",
+        512, 768 if use_lora else 512, 100 if use_lora else 50, 10.0 if use_lora else 3.5, 789 if use_lora else 42,
+        image, "danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA" if use_lora else "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning",
+        "stabilityai/stable-diffusion-2-1" if use_lora else None, 64 if use_lora else None, 0.9 if use_lora else None
+    ]]
+
+def create_demo(config_path: str = "configs/model_ckpts.yaml", device: str = "cuda" if torch.cuda.is_available() else "cpu"):
+    model_configs = load_model_configs(config_path)
+    finetune_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning'), None)
+    lora_model_id = next((mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora'), None)
+    
+    if not finetune_model_id or not lora_model_id:
+        raise ValueError("Missing model IDs in config.")
+
+    finetune_model_path = model_configs[finetune_model_id].get('local_dir', finetune_model_id)
+    lora_model_path = model_configs[lora_model_id].get('local_dir', lora_model_id)
+    base_model_id = model_configs[lora_model_id].get('base_model_id', 'stabilityai/stable-diffusion-2-1')
+    base_model_path = model_configs.get(base_model_id, {}).get('local_dir', base_model_id)
+
+    device = torch.device(device)
+    dtype = torch.float16 if device.type == "cuda" else torch.float32
+
+    def generate_image(prompt, height, width, num_inference_steps, guidance_scale, seed, random_seed, use_lora, 
+                      finetune_model_id, lora_model_id, base_model_id, lora_rank, lora_scale):
+        if not prompt or height % 8 != 0 or width % 8 != 0 or num_inference_steps not in range(1, 101) or \
+           guidance_scale < 1.0 or guidance_scale > 20.0 or seed < 0 or seed > 4294967295 or \
+           (use_lora and (lora_rank < 1 or lora_rank > 128 or lora_scale < 0.0 or lora_scale > 2.0)):
+            return None, "Invalid input parameters."
+
+        model_configs = load_model_configs(config_path)
+        finetune_model_path = model_configs.get(finetune_model_id, {}).get('local_dir', finetune_model_id)
+        lora_model_path = model_configs.get(lora_model_id, {}).get('local_dir', lora_model_id)
+        base_model_path = model_configs.get(base_model_id, {}).get('local_dir', base_model_id)
+
+        generator = torch.Generator(device=device).manual_seed(torch.randint(0, 4294967295, (1,)).item() if random_seed else int(seed))
+
+        try:
+            if use_lora:
+                pipe = StableDiffusionPipeline.from_pretrained(base_model_path, torch_dtype=dtype, use_safetensors=True)
+                pipe.load_lora_weights(lora_model_path, adapter_name="ghibli-lora", lora_scale=lora_scale)
+                pipe = pipe.to(device)
+                vae, tokenizer, text_encoder, unet, scheduler = pipe.vae, pipe.tokenizer, pipe.text_encoder, pipe.unet, PNDMScheduler.from_config(pipe.scheduler.config)
+            else:
+                vae = AutoencoderKL.from_pretrained(finetune_model_path, subfolder="vae", torch_dtype=dtype).to(device)
+                tokenizer = CLIPTokenizer.from_pretrained(finetune_model_path, subfolder="tokenizer")
+                text_encoder = CLIPTextModel.from_pretrained(finetune_model_path, subfolder="text_encoder", torch_dtype=dtype).to(device)
+                unet = UNet2DConditionModel.from_pretrained(finetune_model_path, subfolder="unet", torch_dtype=dtype).to(device)
+                scheduler = PNDMScheduler.from_pretrained(finetune_model_path, subfolder="scheduler")
+
+            text_input = tokenizer([prompt], padding="max_length", max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")
+            text_embeddings = text_encoder(text_input.input_ids.to(device))[0].to(dtype=dtype)
+
+            uncond_input = tokenizer([""] * 1, padding="max_length", max_length=text_input.input_ids.shape[-1], return_tensors="pt")
+            uncond_embeddings = text_encoder(uncond_input.input_ids.to(device))[0].to(dtype=dtype)
+            text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
+
+            latents = torch.randn((1, unet.config.in_channels, height // 8, width // 8), generator=generator, dtype=dtype, device=device)
+            scheduler.set_timesteps(num_inference_steps)
+            latents = latents * scheduler.init_noise_sigma
+
+            for t in tqdm(scheduler.timesteps, desc="Generating image"):
+                latent_model_input = torch.cat([latents] * 2)
+                latent_model_input = scheduler.scale_model_input(latent_model_input, t)
+                noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+                noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+                noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+                latents = scheduler.step(noise_pred, t, latents).prev_sample
+
+            image = vae.decode(latents / vae.config.scaling_factor).sample
+            image = (image / 2 + 0.5).clamp(0, 1).detach().cpu().permute(0, 2, 3, 1).numpy()
+            pil_image = Image.fromarray((image[0] * 255).round().astype("uint8"))
+
+            if use_lora:
+                del pipe
+            else:
+                del vae, tokenizer, text_encoder, unet, scheduler
+            torch.cuda.empty_cache()
+
+            return pil_image, f"Generated image successfully! Seed used: {seed}"
+        except Exception as e:
+            return None, f"Failed to generate image: {e}"
+
+    def load_example_image_full_finetuning(prompt, height, width, num_inference_steps, guidance_scale, seed, image, finetune_model_id):
+        return prompt, height, width, num_inference_steps, guidance_scale, seed, image, finetune_model_id, "Loaded example successfully"
+
+    def load_example_image_lora(prompt, height, width, num_inference_steps, guidance_scale, seed, image, lora_model_id, base_model_id, lora_rank, lora_scale):
+        return prompt, height, width, num_inference_steps, guidance_scale, seed, image, lora_model_id, base_model_id or "stabilityai/stable-diffusion-2-1", lora_rank or 64, lora_scale or 1.2, "Loaded example successfully"
+
+    badges_text = """
+    <div style="text-align: left; font-size: 14px; display: flex; flex-direction: column; gap: 10px;">
+        <div style="display: flex; align-items: center; justify-content: left; gap: 8px;">
+            GitHub: <a href="https://github.com/danhtran2mind/Ghibli-Stable-Diffusion-Synthesis">
+                <img src="https://img.shields.io/badge/GitHub-danhtran2mind%2FGhibli--Stable--Diffusion--Synthesis-blue?style=flat&logo=github" alt="GitHub Repo">
+            </a> HuggingFace: 
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--Base--finetuning-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+            <a href="https://huggingface.co/spaces/danhtran2mind/Ghibli-Stable-Diffusion-2.1-LoRA">
+                <img src="https://img.shields.io/badge/HuggingFace-danhtran2mind%2FGhibli--Stable--Diffusion--2.1--LoRA-yellow?style=flat&logo=huggingface" alt="HuggingFace Space Demo">
+            </a>
+        </div>
+    </div>
+    """
+
+    custom_css = open("apps/gradio_app/static/styles.css", "r").read() if os.path.exists("apps/gradio_app/static/styles.css") else ""
+
+    examples_full_finetuning = get_examples("apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning", use_lora=False)
+    examples_lora = get_examples("apps/gradio_app/assets/examples/Ghibli-Stable-Diffusion-2.1-LoRA", use_lora=True)
+
+    with gr.Blocks(css=custom_css, theme="ocean") as demo:
+        gr.Markdown("## Ghibli-Style Image Generator")
+        with gr.Tabs():
+            with gr.Tab(label="Full Finetuning"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Image Generation Settings")
+                        prompt_ft = gr.Textbox(label="Prompt", placeholder="e.g., 'a serene landscape in Ghibli style'", lines=2)
+                        with gr.Group():
+                            gr.Markdown("#### Image Dimensions")
+                            with gr.Row():
+                                width_ft = gr.Slider(32, 4096, 512, step=8, label="Width")
+                                height_ft = gr.Slider(32, 4096, 512, step=8, label="Height")
+                        with gr.Accordion("Advanced Settings", open=False):
+                            num_inference_steps_ft = gr.Slider(1, 100, 50, step=1, label="Inference Steps")
+                            guidance_scale_ft = gr.Slider(1.0, 20.0, 3.5, step=0.5, label="Guidance Scale")
+                            random_seed_ft = gr.Checkbox(label="Use Random Seed")
+                            seed_ft = gr.Slider(0, 4294967295, 42, step=1, label="Seed")
+                        gr.Markdown("#### Model Configuration")
+                        finetune_model_path_ft = gr.Dropdown(label="Fine-tuned Model", choices=[mid for mid, cfg in model_configs.items() if cfg.get('type') == 'full_finetuning'], value=finetune_model_id)
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Generated Result")
+                        output_image_ft = gr.Image(label="Generated Image", interactive=False, height=512)
+                        output_text_ft = gr.Textbox(label="Status", interactive=False, lines=3)
+                        generate_btn_ft = gr.Button("Generate Image", variant="primary")
+                        stop_btn_ft = gr.Button("Stop Generation")
+                gr.Markdown("### Examples for Full Finetuning")
+                gr.Examples(examples=examples_full_finetuning, inputs=[prompt_ft, height_ft, width_ft, num_inference_steps_ft, guidance_scale_ft, seed_ft, output_image_ft, finetune_model_path_ft], 
+                            outputs=[prompt_ft, height_ft, width_ft, num_inference_steps_ft, guidance_scale_ft, seed_ft, output_image_ft, finetune_model_path_ft, output_text_ft], 
+                            fn=load_example_image_full_finetuning, cache_examples=False, examples_per_page=4)
+
+            with gr.Tab(label="LoRA"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Image Generation Settings")
+                        prompt_lora = gr.Textbox(label="Prompt", placeholder="e.g., 'a serene landscape in Ghibli style'", lines=2)
+                        with gr.Group():
+                            gr.Markdown("#### Image Dimensions")
+                            with gr.Row():
+                                width_lora = gr.Slider(32, 4096, 512, step=8, label="Width")
+                                height_lora = gr.Slider(32, 4096, 512, step=8, label="Height")
+                        with gr.Accordion("Advanced Settings", open=False):
+                            num_inference_steps_lora = gr.Slider(1, 100, 50, step=1, label="Inference Steps")
+                            guidance_scale_lora = gr.Slider(1.0, 20.0, 3.5, step=0.5, label="Guidance Scale")
+                            lora_rank_lora = gr.Slider(1, 128, 64, step=1, label="LoRA Rank")
+                            lora_scale_lora = gr.Slider(0.0, 2.0, 1.2, step=0.1, label="LoRA Scale")
+                            random_seed_lora = gr.Checkbox(label="Use Random Seed")
+                            seed_lora = gr.Slider(0, 4294967295, 42, step=1, label="Seed")
+                        gr.Markdown("#### Model Configuration")
+                        lora_model_path_lora = gr.Dropdown(label="LoRA Model", choices=[mid for mid, cfg in model_configs.items() if cfg.get('type') == 'lora'], value=lora_model_id)
+                        base_model_path_lora = gr.Dropdown(label="Base Model", choices=[model_configs[mid].get('base_model_id') for mid in model_configs if model_configs[mid].get('base_model_id')], value=base_model_id)
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Generated Result")
+                        output_image_lora = gr.Image(label="Generated Image", interactive=False, height=512)
+                        output_text_lora = gr.Textbox(label="Status", interactive=False, lines=3)
+                        generate_btn_lora = gr.Button("Generate Image", variant="primary")
+                        stop_btn_lora = gr.Button("Stop Generation")
+                gr.Markdown("### Examples for LoRA")
+                gr.Examples(examples=examples_lora, inputs=[prompt_lora, height_lora, width_lora, num_inference_steps_lora, guidance_scale_lora, seed_lora, output_image_lora, lora_model_path_lora, base_model_path_lora, lora_rank_lora, lora_scale_lora], 
+                            outputs=[prompt_lora, height_lora, width_lora, num_inference_steps_lora, guidance_scale_lora, seed_lora, output_image_lora, lora_model_path_lora, base_model_path_lora, lora_rank_lora, lora_scale_lora, output_text_lora], 
+                            fn=load_example_image_lora, cache_examples=False, examples_per_page=4)
+
+        gr.Markdown(badges_text)
+
+        generate_event_ft = generate_btn_ft.click(fn=generate_image, inputs=[prompt_ft, height_ft, width_ft, num_inference_steps_ft, guidance_scale_ft, seed_ft, random_seed_ft, gr.State(False), finetune_model_path_ft, gr.State(None), gr.State(None), gr.State(None), gr.State(None)], 
+                                                 outputs=[output_image_ft, output_text_ft])
+        generate_event_lora = generate_btn_lora.click(fn=generate_image, inputs=[prompt_lora, height_lora, width_lora, num_inference_steps_lora, guidance_scale_lora, seed_lora, random_seed_lora, gr.State(True), gr.State(None), lora_model_path_lora, base_model_path_lora, lora_rank_lora, lora_scale_lora], 
+                                                     outputs=[output_image_lora, output_text_lora])
+
+        stop_btn_ft.click(fn=None, inputs=None, outputs=None, cancels=[generate_event_ft])
+        stop_btn_lora.click(fn=None, inputs=None, outputs=None, cancels=[generate_event_lora])
+
+        demo.unload(lambda: torch.cuda.empty_cache())
+
+    return demo
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Ghibli-Style Image Generator")
+    parser.add_argument("--config_path", type=str, default="configs/model_ckpts.yaml")
+    parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu")
+    parser.add_argument("--port", type=int, default=7860)
+    parser.add_argument("--share", action="store_true")
+    args = parser.parse_args()
+    demo = create_demo(args.config_path, args.device)
+    demo.launch(server_port=args.port, share=args.share)

assets/.gitkeep

@@ -0,0 +1 @@
+

assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/1/config.json

@@ -0,0 +1,11 @@
+{
+    "prompt": "a serene landscape in Ghibli style",
+    "height": 256,
+    "width": 512,
+    "num_inference_steps": 50,
+    "guidance_scale": 3.5,
+    "seed": 42,
+    "image": "result.png",
+    "use_lora": false,
+    "finetune_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+}

assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/2/config.json

@@ -0,0 +1,11 @@
+{
+    "prompt": "Donald Trump",
+    "height": 512,
+    "width": 512,
+    "num_inference_steps": 100,
+    "guidance_scale": 9,
+    "seed": 200,
+    "image": "result.png",
+    "use_lora": false,
+    "finetune_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+}

assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/3/config.json

@@ -0,0 +1,11 @@
+{
+    "prompt": "a dancer in Ghibli style",
+    "height": 384,
+    "width": 192,
+    "num_inference_steps": 50,
+    "guidance_scale": 15.5,
+    "seed": 4223,
+    "image": "result.png",
+    "use_lora": false,
+    "finetune_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+}

assets/examples/Ghibli-Stable-Diffusion-2.1-Base-finetuning/4/config.json

@@ -0,0 +1,11 @@
+{
+    "prompt": "Ghibli style, the peace beach",
+    "height": 1024,
+    "width": 2048,
+    "num_inference_steps": 100,
+    "guidance_scale": 7.5,
+    "seed": 5678,
+    "image": "result.png",
+    "use_lora": false,
+    "finetune_model_id": "danhtran2mind/Ghibli-Stable-Diffusion-2.1-Base-finetuning"
+}