Update app.py

app.py

@@ -17,6 +17,12 @@ subprocess.run(
     shell=True,
 )
 
+# Additional dependencies for translation and UI improvements
+subprocess.run(
+    "pip install transformers gradio safetensors torchvision diffusers",
+    shell=True,
+)
+
 os.makedirs("/home/user/app/checkpoints", exist_ok=True)
 from huggingface_hub import snapshot_download
 snapshot_download(
@@ -26,30 +32,31 @@ snapshot_download(
 hf_token = os.environ["HF_TOKEN"]
 
 import argparse
-import os
 import builtins
 import json
 import math
 import multiprocessing as mp
-import os
 import random
 import socket
 import traceback
 
-#import fairscale.nn.model_parallel.initialize as fs_init
 import gradio as gr
 import numpy as np
 from safetensors.torch import load_file
 import torch
-#i#mport torch.distributed as dist
 from torchvision.transforms.functional import to_pil_image
+
+# Import translation pipeline from transformers
+from transformers import pipeline
+translator = pipeline("translation", model="Helsinki-NLP/opus-mt-ko-en")
+
 import spaces
 
 from imgproc import generate_crop_size_list
 import models
 from transport import Sampler, create_transport
 
-from multiprocessing import Process,Queue,set_start_method,get_context
+from multiprocessing import Process, Queue, set_start_method, get_context
 
 class ModelFailure:
     pass
@@ -93,22 +100,19 @@ def encode_prompt(prompt_batch, text_encoder, tokenizer, proportion_empty_prompt
 
 @torch.no_grad()
 def model_main(args, master_port, rank):
-    # import here to avoid huggingface Tokenizer parallelism warnings
+    # Import here to avoid huggingface Tokenizer parallelism warnings
     from diffusers.models import AutoencoderKL
     from transformers import AutoModel, AutoTokenizer
 
-    # override the default print function since the delay can be large for child process
+    # Override the default print function since the delay can be large for child processes
     original_print = builtins.print
 
-    # Redefine the print function with flush=True by default
     def print(*args, **kwargs):
         kwargs.setdefault("flush", True)
         original_print(*args, **kwargs)
 
-    # Override the built-in print with the new version
     builtins.print = print
 
-
     train_args = torch.load(os.path.join(args.ckpt, "model_args.pth"))
     print("Loaded model arguments:", json.dumps(train_args.__dict__, indent=2))
 
@@ -139,8 +143,8 @@ def model_main(args, master_port, rank):
 
     assert train_args.model_parallel_size == args.num_gpus
     if args.ema:
-        print("Loading ema model.")
-    print('load model')
+        print("Loading EMA model.")
+    print('Loading model weights...')
     ckpt_path = os.path.join(
         args.ckpt,
         f"consolidated{'_ema' if args.ema else ''}.{rank:02d}-of-{args.num_gpus:02d}.safetensors",
@@ -155,158 +159,150 @@ def model_main(args, master_port, rank):
         assert os.path.exists(ckpt_path)
         ckpt = torch.load(ckpt_path, map_location="cuda")
     model.load_state_dict(ckpt, strict=True)
-    print('load model finish')
+    print('Model weights loaded.')
     
     return text_encoder, tokenizer, vae, model
 
 
 @torch.no_grad()
 def inference(args, infer_args, text_encoder, tokenizer, vae, model):
-    dtype = {"bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32}[
-        args.precision
-    ]
+    dtype = {"bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32}[args.precision]
     train_args = torch.load(os.path.join(args.ckpt, "model_args.pth"))
     torch.cuda.set_device(0)
     with torch.autocast("cuda", dtype):
-        while True:
-            (
-                cap,
-                neg_cap,
-                system_type,
-                resolution,
-                num_sampling_steps,
-                cfg_scale,
-                cfg_trunc,
-                renorm_cfg,
-                solver,
-                t_shift,
-                seed,
-                scaling_method,
-                scaling_watershed,
-                proportional_attn,
-            ) = infer_args
-
-           
-            system_prompt = system_type
-            cap = system_prompt + cap
-            if neg_cap != "":
-                neg_cap = system_prompt + neg_cap
-
-            metadata = dict(
-                real_cap=cap,
-                real_neg_cap=neg_cap,
-                system_type=system_type,
-                resolution=resolution,
-                num_sampling_steps=num_sampling_steps,
-                cfg_scale=cfg_scale,
-                cfg_trunc=cfg_trunc,
-                renorm_cfg=renorm_cfg,
-                solver=solver,
-                t_shift=t_shift,
-                seed=seed,
-                scaling_method=scaling_method,
-                scaling_watershed=scaling_watershed,
-                proportional_attn=proportional_attn,
-            )
-            print("> params:", json.dumps(metadata, indent=2))
-
-            try:
-                # begin sampler
-                if solver == "dpm":
-                    transport = create_transport(
-                    "Linear",
-                    "velocity",
-                    )
-                    sampler = Sampler(transport)
-                    sample_fn = sampler.sample_dpm(
+        (
+            cap,
+            neg_cap,
+            system_type,
+            resolution,
+            num_sampling_steps,
+            cfg_scale,
+            cfg_trunc,
+            renorm_cfg,
+            solver,
+            t_shift,
+            seed,
+            scaling_method,
+            scaling_watershed,
+            proportional_attn,
+        ) = infer_args
+
+        system_prompt = system_type
+        cap = system_prompt + cap
+        if neg_cap != "":
+            neg_cap = system_prompt + neg_cap
+
+        metadata = dict(
+            real_cap=cap,
+            real_neg_cap=neg_cap,
+            system_type=system_type,
+            resolution=resolution,
+            num_sampling_steps=num_sampling_steps,
+            cfg_scale=cfg_scale,
+            cfg_trunc=cfg_trunc,
+            renorm_cfg=renorm_cfg,
+            solver=solver,
+            t_shift=t_shift,
+            seed=seed,
+            scaling_method=scaling_method,
+            scaling_watershed=scaling_watershed,
+            proportional_attn=proportional_attn,
+        )
+        print("> Parameters:", json.dumps(metadata, indent=2))
+
+        try:
+            # Begin sampler
+            if solver == "dpm":
+                transport = create_transport("Linear", "velocity")
+                sampler = Sampler(transport)
+                sample_fn = sampler.sample_dpm(
                     model.forward_with_cfg,
                     model_kwargs=model_kwargs,
-                    )
-                else:
-                    transport = create_transport(
-                        args.path_type,
-                        args.prediction,
-                        args.loss_weight,
-                        args.train_eps,
-                        args.sample_eps,
-                    )
-                    sampler = Sampler(transport)
-                    sample_fn = sampler.sample_ode(
-                        sampling_method=solver,
-                        num_steps=num_sampling_steps,
-                        atol=args.atol,
-                        rtol=args.rtol,
-                        reverse=args.reverse,
-                        time_shifting_factor=t_shift,
-                    )  
-                # end sampler
-
-                resolution = resolution.split(" ")[-1]
-                w, h = resolution.split("x")
-                w, h = int(w), int(h)
-                latent_w, latent_h = w // 8, h // 8
-                if int(seed) != 0:
-                    torch.random.manual_seed(int(seed))
-                z = torch.randn([1, 16, latent_h, latent_w], device="cuda").to(dtype)
-                z = z.repeat(2, 1, 1, 1)
-
-                with torch.no_grad():
-                    if neg_cap != "":
-                        cap_feats, cap_mask = encode_prompt([cap] + [neg_cap], text_encoder, tokenizer, 0.0)
-                    else:
-                        cap_feats, cap_mask = encode_prompt([cap] + [""], text_encoder, tokenizer, 0.0)
-               
-                cap_mask = cap_mask.to(cap_feats.device)
-
-                model_kwargs = dict(
-                    cap_feats=cap_feats,
-                    cap_mask=cap_mask,
-                    cfg_scale=cfg_scale,
-                    cfg_trunc=1 - cfg_trunc,
-                    renorm_cfg=renorm_cfg,
                 )
-
-                #if dist.get_rank() == 0:
-                print(f"> caption: {cap}")
-                print(f"> num_sampling_steps: {num_sampling_steps}")
-                print(f"> cfg_scale: {cfg_scale}")
-                print("> start sample")
-                if solver == "dpm":
-                    samples = sample_fn(z, steps=num_sampling_steps, order=2, skip_type="time_uniform_flow", method="multistep", flow_shift=t_shift)
+            else:
+                transport = create_transport(
+                    args.path_type,
+                    args.prediction,
+                    args.loss_weight,
+                    args.train_eps,
+                    args.sample_eps,
+                )
+                sampler = Sampler(transport)
+                sample_fn = sampler.sample_ode(
+                    sampling_method=solver,
+                    num_steps=num_sampling_steps,
+                    atol=args.atol,
+                    rtol=args.rtol,
+                    reverse=args.reverse,
+                    time_shifting_factor=t_shift,
+                )
+            # End sampler
+
+            resolution = resolution.split(" ")[-1]
+            w, h = resolution.split("x")
+            w, h = int(w), int(h)
+            latent_w, latent_h = w // 8, h // 8
+            if int(seed) != 0:
+                torch.random.manual_seed(int(seed))
+            z = torch.randn([1, 16, latent_h, latent_w], device="cuda").to(dtype)
+            z = z.repeat(2, 1, 1, 1)
+
+            with torch.no_grad():
+                if neg_cap != "":
+                    cap_feats, cap_mask = encode_prompt([cap] + [neg_cap], text_encoder, tokenizer, 0.0)
                 else:
-                    samples = sample_fn(z, model.forward_with_cfg, **model_kwargs)[-1]
-                samples = samples[:1]
-                print("smaple_dtype", samples.dtype)
-
-                vae_scale = {
-                    "sdxl": 0.13025,
-                    "sd3": 1.5305,
-                    "ema": 0.18215,
-                    "mse": 0.18215,
-                    "cogvideox": 1.15258426,
-                    "flux": 0.3611,
-                }["flux"]
-                vae_shift = {
-                    "sdxl": 0.0,
-                    "sd3": 0.0609,
-                    "ema": 0.0,
-                    "mse": 0.0,
-                    "cogvideox": 0.0,
-                    "flux": 0.1159,
-                }["flux"]
-                print(f"> vae scale: {vae_scale}, shift: {vae_shift}")
-                print("samples.shape", samples.shape)
-                samples = vae.decode(samples / vae_scale + vae_shift).sample
-                samples = (samples + 1.0) / 2.0
-                samples.clamp_(0.0, 1.0)
-
-                img = to_pil_image(samples[0].float())
-                print("> generated image, done.")
-
-                return img, metadata
-            except Exception:
-                print(traceback.format_exc())
-                return ModelFailure()
+                    cap_feats, cap_mask = encode_prompt([cap] + [""], text_encoder, tokenizer, 0.0)
+
+            cap_mask = cap_mask.to(cap_feats.device)
+
+            model_kwargs = dict(
+                cap_feats=cap_feats,
+                cap_mask=cap_mask,
+                cfg_scale=cfg_scale,
+                cfg_trunc=1 - cfg_trunc,
+                renorm_cfg=renorm_cfg,
+            )
+
+            print(f"> Caption: {cap}")
+            print(f"> Number of sampling steps: {num_sampling_steps}")
+            print(f"> CFG scale: {cfg_scale}")
+            print("> Starting sampling...")
+            if solver == "dpm":
+                samples = sample_fn(z, steps=num_sampling_steps, order=2, skip_type="time_uniform_flow", method="multistep", flow_shift=t_shift)
+            else:
+                samples = sample_fn(z, model.forward_with_cfg, **model_kwargs)[-1]
+            samples = samples[:1]
+            print("Sample dtype:", samples.dtype)
+
+            vae_scale = {
+                "sdxl": 0.13025,
+                "sd3": 1.5305,
+                "ema": 0.18215,
+                "mse": 0.18215,
+                "cogvideox": 1.15258426,
+                "flux": 0.3611,
+            }["flux"]
+            vae_shift = {
+                "sdxl": 0.0,
+                "sd3": 0.0609,
+                "ema": 0.0,
+                "mse": 0.0,
+                "cogvideox": 0.0,
+                "flux": 0.1159,
+            }["flux"]
+            print(f"> VAE scale: {vae_scale}, shift: {vae_shift}")
+            print("Samples shape:", samples.shape)
+            samples = vae.decode(samples / vae_scale + vae_shift).sample
+            samples = (samples + 1.0) / 2.0
+            samples.clamp_(0.0, 1.0)
+
+            img = to_pil_image(samples[0].float())
+            print("> Generated image successfully.")
+
+            return img, metadata
+        except Exception:
+            print(traceback.format_exc())
+            return ModelFailure()
 
 
 def none_or_str(value):
@@ -322,24 +318,24 @@ def parse_transport_args(parser):
         type=str,
         default="Linear",
         choices=["Linear", "GVP", "VP"],
-        help="the type of path for transport: 'Linear', 'GVP' (Geodesic Vector Pursuit), or 'VP' (Vector Pursuit).",
+        help="Type of path for transport: 'Linear', 'GVP' (Geodesic Vector Pursuit), or 'VP' (Vector Pursuit).",
     )
     group.add_argument(
         "--prediction",
         type=str,
         default="velocity",
         choices=["velocity", "score", "noise"],
-        help="the prediction model for the transport dynamics.",
+        help="Prediction model for the transport dynamics.",
     )
     group.add_argument(
         "--loss-weight",
         type=none_or_str,
         default=None,
         choices=[None, "velocity", "likelihood"],
-        help="the weighting of different components in the loss function, can be 'velocity' for dynamic modeling, 'likelihood' for statistical consistency, or None for no weighting.",
+        help="Weighting of different loss components: 'velocity', 'likelihood', or None.",
     )
-    group.add_argument("--sample-eps", type=float, help="sampling in the transport model.")
-    group.add_argument("--train-eps", type=float, help="training to stabilize the learning process.")
+    group.add_argument("--sample-eps", type=float, help="Sampling parameter in the transport model.")
+    group.add_argument("--train-eps", type=float, help="Training epsilon to stabilize learning.")
 
 
 def parse_ode_args(parser):
@@ -356,11 +352,11 @@ def parse_ode_args(parser):
         default=1e-3,
         help="Relative tolerance for the ODE solver.",
     )
-    group.add_argument("--reverse", action="store_true", help="run the ODE solver in reverse.")
+    group.add_argument("--reverse", action="store_true", help="Run the ODE solver in reverse.")
     group.add_argument(
         "--likelihood",
         action="store_true",
-        help="Enable calculation of likelihood during the ODE solving process.",
+        help="Enable likelihood calculation during the ODE solving process.",
     )
 
 
@@ -372,14 +368,26 @@ def find_free_port() -> int:
     return port
 
 
+# Utility function to translate Korean text to English if needed.
+def translate_if_korean(text: str) -> str:
+    import re
+    # Check if any Korean characters are present
+    if re.search(r"[ㄱ-ㅎㅏ-ㅣ가-힣]", text):
+        print("Translating Korean prompt to English...")
+        translation = translator(text)
+        # Return the translated text from the pipeline output
+        return translation[0]["translation_text"]
+    return text
+
+
 def main():
     parser = argparse.ArgumentParser()
 
     parser.add_argument("--num_gpus", type=int, default=1)
-    parser.add_argument("--ckpt", type=str,default='/home/user/app/checkpoints', required=False)
+    parser.add_argument("--ckpt", type=str, default='/home/user/app/checkpoints', required=False)
     parser.add_argument("--ema", action="store_true")
     parser.add_argument("--precision", default="bf16", choices=["bf16", "fp32"])
-    parser.add_argument("--hf_token", type=str, default=None, help="huggingface read token for accessing gated repo.")
+    parser.add_argument("--hf_token", type=str, default=None, help="Hugging Face read token for accessing gated repo.")
     parser.add_argument("--res", type=int, default=1024, choices=[256, 512, 1024])
     parser.add_argument("--port", type=int, default=12123)
 
@@ -397,9 +405,30 @@ def main():
 
     description = "Lumina-Image 2.0 ([Github](https://github.com/Alpha-VLLM/Lumina-Image-2.0/tree/main))"
 
-    with gr.Blocks() as demo:
+    # Create a Gradio Blocks UI with custom CSS for a sleek, modern appearance.
+    custom_css = """
+    body {
+        background: linear-gradient(135deg, #1a2a6c, #b21f1f, #fdbb2d);
+        font-family: 'Helvetica', sans-serif;
+        color: #333;
+    }
+    .gradio-container {
+        background: #fff;
+        border-radius: 15px;
+        box-shadow: 0 8px 16px rgba(0, 0, 0, 0.25);
+        padding: 20px;
+    }
+    .gradio-title {
+        font-weight: bold;
+        font-size: 1.5em;
+        text-align: center;
+        margin-bottom: 10px;
+    }
+    """
+
+    with gr.Blocks(css=custom_css) as demo:
         with gr.Row():
-            gr.Markdown(description)
+            gr.Markdown(f"<div class='gradio-title'>{description}</div>")
         with gr.Row():
             with gr.Column():
                 cap = gr.Textbox(
@@ -416,21 +445,20 @@ def main():
                     value="",
                     placeholder="Enter a negative caption.",
                 )
-                default_value = "You are an assistant designed to generate superior images with the superior degree of image-text alignment based on textual prompts or user prompts."
+                default_value = "You are an assistant designed to generate high-quality images with the highest degree of image-text alignment based on textual prompts."
                 system_type = gr.Dropdown(
                     value=default_value,
                     choices=[
-                       "You are an assistant designed to generate high-quality images with the highest degree of image-text alignment based on textual prompts.",
+                        "You are an assistant designed to generate high-quality images with the highest degree of image-text alignment based on textual prompts.",
                         "You are an assistant designed to generate superior images with the superior degree of image-text alignment based on textual prompts or user prompts.",
                         "",
-                                            ],
+                    ],
                     label="System Type",
                 )
 
                 with gr.Row():
                     res_choices = [f"{w}x{h}" for w, h in generate_crop_size_list((args.res // 64) ** 2, 64)]
-                    default_value = "1024x1024"  # Set the default value to 256x256
-                    
+                    default_value = "1024x1024"
                     resolution = gr.Dropdown(
                         value=default_value, choices=res_choices, label="Resolution"
                     )
@@ -441,7 +469,7 @@ def main():
                         value=40,
                         step=1,
                         interactive=True,
-                        label="Sampling steps",
+                        label="Sampling Steps",
                     )
                     seed = gr.Slider(
                         minimum=0,
@@ -463,7 +491,7 @@ def main():
                     solver = gr.Dropdown(
                         value="euler",
                         choices=["euler", "midpoint", "rk4"],
-                        label="solver",
+                        label="Solver",
                     )
                     t_shift = gr.Slider(
                         minimum=1,
@@ -471,17 +499,17 @@ def main():
                         value=6,
                         step=1,
                         interactive=True,
-                        label="Time shift",
+                        label="Time Shift",
                     )
                     cfg_scale = gr.Slider(
                         minimum=1.0,
                         maximum=20.0,
                         value=4.0,
                         interactive=True,
-                        label="CFG scale",
+                        label="CFG Scale",
                     )
                 with gr.Row():
-                     renorm_cfg = gr.Dropdown(
+                    renorm_cfg = gr.Dropdown(
                         value=True,
                         choices=[True, False, 2.0],
                         label="CFG Renorm",
@@ -491,51 +519,52 @@ def main():
                         scaling_method = gr.Dropdown(
                             value="Time-aware",
                             choices=["Time-aware", "None"],
-                            label="RoPE scaling method",
+                            label="RoPE Scaling Method",
                         )
                         scaling_watershed = gr.Slider(
                             minimum=0.0,
                             maximum=1.0,
                             value=0.3,
                             interactive=True,
-                            label="Linear/NTK watershed",
+                            label="Linear/NTK Watershed",
                         )
                     with gr.Row():
                         proportional_attn = gr.Checkbox(
                             value=True,
                             interactive=True,
-                            label="Proportional attention",
+                            label="Proportional Attention",
                         )
                 with gr.Row():
                     submit_btn = gr.Button("Submit", variant="primary")
             with gr.Column():
                 output_img = gr.Image(
-                    label="Generated image",
+                    label="Generated Image",
                     interactive=False,
                 )
                 with gr.Accordion(label="Generation Parameters", open=True):
-                    gr_metadata = gr.JSON(label="metadata", show_label=False)
+                    gr_metadata = gr.JSON(label="Metadata", show_label=False)
 
         with gr.Row():
-           
-            prompts=[ "Close-up portrait of a young woman with light brown hair, looking to the right, illuminated by warm, golden sunlight. Her hair is gently tousled, catching the light and creating a halo effect around her head. She wears a white garment with a V-neck, visible in the lower left of the frame. The background is dark and out of focus, enhancing the contrast between her illuminated face and the shadows. Soft, ethereal lighting, high contrast, warm color palette, shallow depth of field, natural backlighting, serene and contemplative mood, cinematic quality, intimate and visually striking composition.",
-                     "一个剑客，武侠风，红色腰带，戴着斗笠，低头，盖住眼睛，白色背景，细致，精品，杰作，水墨画，墨烟，墨云，泼墨，色带，墨水，墨黑白莲花，光影艺术，笔触。",
-                     "Aesthetic photograph of a bouquet of pink and white ranunculus flowers in a clear glass vase, centrally positioned on a wooden surface. The flowers are in full bloom, displaying intricate layers of petals with a soft gradient from pale pink to white. The vase is filled with water, visible through the clear glass, and the stems are submerged. In the background, a blurred vase with green stems is partially visible, adding depth to the composition. The lighting is warm and natural, casting soft shadows and highlighting the delicate textures of the petals. The scene is serene and intimate, with a focus on the organic beauty of the flowers. Photorealistic, shallow depth of field, soft natural lighting, warm color palette, high contrast, glossy texture, tranquil, visually balanced.",
-                     "一只优雅的白猫穿着一件紫色的旗袍，旗袍上绣有精致的牡丹花图案，显得高贵典雅。它头上戴着一朵金色的发饰，嘴里叼着一根象征好运的红色丝带。周围环绕着许多飘动的纸鹤和金色的光点，营造出一种祥瑞和梦幻的氛围。超写实风格。"
-                ]
-            prompts = [[_] for _ in prompts]
-            gr.Examples(  # noqa
-                prompts,
-                [cap],
-                label="Examples",
-            )  # noqa
+            prompts = [
+                "Close-up portrait of a young woman with light brown hair, looking to the right, illuminated by warm, golden sunlight. Her hair is gently tousled, catching the light and creating a halo effect around her head. She wears a white garment with a V-neck, visible in the lower left of the frame. The background is dark and out of focus, enhancing the contrast between her illuminated face and the shadows. Soft, ethereal lighting, high contrast, warm color palette, shallow depth of field, natural backlighting, serene and contemplative mood, cinematic quality, intimate and visually striking composition.",
+                "하늘을 나는 용, 신비로운 분위기, 구름 위를 날며 빛나는 비늘을 가진, 전설 속의 존재, 강렬한 색채와 디테일한 묘사.",
+                "Aesthetic photograph of a bouquet of pink and white ranunculus flowers in a clear glass vase, centrally positioned on a wooden surface. The flowers are in full bloom, displaying intricate layers of petals with a soft gradient from pale pink to white. The vase is filled with water, visible through the clear glass, and the stems are submerged. In the background, a blurred vase with green stems is partially visible, adding depth to the composition. The lighting is warm and natural, casting soft shadows and highlighting the delicate textures of the petals. The scene is serene and intimate, with a focus on the organic beauty of the flowers. Photorealistic, shallow depth of field, soft natural lighting, warm color palette, high contrast, glossy texture, tranquil, visually balanced.",
+                "한只优雅的白猫穿着一件紫色的旗袍，旗袍上绣有精致的牡丹花图案，显得高贵典雅。它头上戴着一朵金色的发饰，嘴里叼着一根象征好运的红色丝带。周围环绕着许多飘动的纸鹤和金色的光点，营造出一种祥瑞和梦幻的氛围。超写实风格。"
+            ]
+            prompts = [[p] for p in prompts]
+            gr.Examples(prompts, [cap], label="Examples")
 
         @spaces.GPU(duration=200)
-        def on_submit(*infer_args, progress=gr.Progress(track_tqdm=True),):
+        def on_submit(cap, neg_cap, system_type, resolution, num_sampling_steps, cfg_scale, cfg_trunc, renorm_cfg, solver, t_shift, seed, scaling_method, scaling_watershed, proportional_attn, progress=gr.Progress(track_tqdm=True)):
+            # Translate the caption and negative caption if they contain Korean characters
+            cap = translate_if_korean(cap)
+            if neg_cap and neg_cap.strip():
+                neg_cap = translate_if_korean(neg_cap)
+            # Pack updated arguments and call inference
+            infer_args = (cap, neg_cap, system_type, resolution, num_sampling_steps, cfg_scale, cfg_trunc, renorm_cfg, solver, t_shift, seed, scaling_method, scaling_watershed, proportional_attn)
             result = inference(args, infer_args, text_encoder, tokenizer, vae, model)
             if isinstance(result, ModelFailure):
                 raise RuntimeError("Model failed to generate the image.")
-
             return result
 
         submit_btn.click(