Update app.py

app.py

@@ -1,36 +1,26 @@
 import subprocess
 import os
 
+# 필수 패키지 설치 (이미 설치되어 있다면 무시됩니다)
 subprocess.run(
     "pip install flash-attn --no-build-isolation",
     env={"FLASH_ATTENTION_SKIP_CUDA_BUILD": "TRUE"},
     shell=True,
 )
+subprocess.run("pip install huggingface_hub==0.25.0", shell=True)
+subprocess.run("pip install numpy==1.26.4 sentencepiece sacremoses transformers gradio safetensors torchvision diffusers", shell=True)
 
-subprocess.run(
-    "pip install huggingface_hub==0.25.0",
-    shell=True,
-)
-
-subprocess.run(
-    "pip install numpy==1.26.4",
-    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(
-    repo_id="Alpha-VLLM/Lumina-Image-2.0", local_dir="/home/user/app/checkpoints"
-)
+snapshot_download(repo_id="Alpha-VLLM/Lumina-Image-2.0", local_dir="/home/user/app/checkpoints")
 
 hf_token = os.environ["HF_TOKEN"]
 
+# ★ 중요: CUDA 초기화 전에 spaces 패키지를 임포트합니다.
+import spaces
+
+# 이제 CUDA와 관련된 라이브러리들을 임포트합니다.
 import argparse
 import builtins
 import json
@@ -40,18 +30,16 @@ import random
 import socket
 import traceback
 
+import torch
 import gradio as gr
 import numpy as np
 from safetensors.torch import load_file
-import torch
 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
@@ -97,32 +85,26 @@ def encode_prompt(prompt_batch, text_encoder, tokenizer, proportion_empty_prompt
 
     return prompt_embeds, prompt_masks
 
-
 @torch.no_grad()
 def model_main(args, master_port, rank):
-    # Import here to avoid huggingface Tokenizer parallelism warnings
+    # diffusers, transformers 등의 내부 임포트를 위해 함수 내부에서 임포트합니다.
     from diffusers.models import AutoencoderKL
     from transformers import AutoModel, AutoTokenizer
 
-    # Override the default print function since the delay can be large for child processes
+    # 기본 print 함수를 오버라이드하여 출력 지연을 최소화합니다.
     original_print = builtins.print
-
     def print(*args, **kwargs):
         kwargs.setdefault("flush", True)
         original_print(*args, **kwargs)
-
     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))
 
     print(f"Creating lm: Gemma-2-2B")
-
     dtype = {"bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32}[args.precision]
 
-    text_encoder = AutoModel.from_pretrained(
-        "google/gemma-2-2b", torch_dtype=dtype, token=hf_token
-    ).eval().to("cuda")
+    text_encoder = AutoModel.from_pretrained("google/gemma-2-2b", torch_dtype=dtype, token=hf_token).eval().to("cuda")
     cap_feat_dim = text_encoder.config.hidden_size
     if args.num_gpus > 1:
         raise NotImplementedError("Inference with >1 GPUs not yet supported")
@@ -133,7 +115,6 @@ def model_main(args, master_port, rank):
     vae = AutoencoderKL.from_pretrained("black-forest-labs/FLUX.1-dev", subfolder="vae", token=hf_token).cuda()
 
     print(f"Creating DiT: {train_args.model}")
-
     model = models.__dict__[train_args.model](
         in_channels=16,
         qk_norm=train_args.qk_norm,
@@ -163,7 +144,6 @@ def model_main(args, master_port, rank):
     
     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]
@@ -211,7 +191,7 @@ def inference(args, infer_args, text_encoder, tokenizer, vae, model):
         print("> Parameters:", json.dumps(metadata, indent=2))
 
         try:
-            # Begin sampler
+            # 샘플러 설정
             if solver == "dpm":
                 transport = create_transport("Linear", "velocity")
                 sampler = Sampler(transport)
@@ -236,8 +216,7 @@ def inference(args, infer_args, text_encoder, tokenizer, vae, model):
                     reverse=args.reverse,
                     time_shifting_factor=t_shift,
                 )
-            # End sampler
-
+            # 해상도 및 latent 공간 크기 계산
             resolution = resolution.split(" ")[-1]
             w, h = resolution.split("x")
             w, h = int(w), int(h)
@@ -252,7 +231,7 @@ def inference(args, infer_args, text_encoder, tokenizer, vae, model):
                     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(
@@ -304,13 +283,11 @@ def inference(args, infer_args, text_encoder, tokenizer, vae, model):
             print(traceback.format_exc())
             return ModelFailure()
 
-
 def none_or_str(value):
     if value == "None":
         return None
     return value
 
-
 def parse_transport_args(parser):
     group = parser.add_argument_group("Transport arguments")
     group.add_argument(
@@ -337,7 +314,6 @@ def parse_transport_args(parser):
     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):
     group = parser.add_argument_group("ODE arguments")
     group.add_argument(
@@ -359,7 +335,6 @@ def parse_ode_args(parser):
         help="Enable likelihood calculation during the ODE solving process.",
     )
 
-
 def find_free_port() -> int:
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     sock.bind(("", 0))
@@ -367,22 +342,17 @@ def find_free_port() -> int:
     sock.close()
     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("--ema", action="store_true")
@@ -393,19 +363,16 @@ def main():
 
     parse_transport_args(parser)
     parse_ode_args(parser)
-
     args = parser.parse_known_args()[0]
 
     if args.num_gpus != 1:
         raise NotImplementedError("Multi-GPU Inference is not yet supported")
 
     master_port = find_free_port()
-
     text_encoder, tokenizer, vae, model = model_main(args, master_port, 0)
-
     description = "Lumina-Image 2.0 ([Github](https://github.com/Alpha-VLLM/Lumina-Image-2.0/tree/main))"
 
-    # Create a Gradio Blocks UI with custom CSS for a sleek, modern appearance.
+    # 커스텀 CSS로 모던한 UI 스타일 적용
     custom_css = """
     body {
         background: linear-gradient(135deg, #1a2a6c, #b21f1f, #fdbb2d);
@@ -436,14 +403,14 @@ def main():
                     label="Caption",
                     interactive=True,
                     value="Majestic landscape photograph of snow-capped mountains under a dramatic sky at sunset. The mountains dominate the lower half of the image, with rugged peaks and deep crevasses visible. A glacier flows down the right side, partially illuminated by the warm light. The sky is filled with fiery orange and golden clouds, contrasting with the cool tones of the snow. The central peak is partially obscured by clouds, adding a sense of mystery. The foreground features dark, shadowed forested areas, enhancing the depth. High contrast, natural lighting, warm color palette, photorealistic, expansive, awe-inspiring, serene, visually balanced, dynamic composition.",
-                    placeholder="Enter a caption.",
+                    placeholder="Enter a caption."
                 )
                 neg_cap = gr.Textbox(
                     lines=2,
                     label="Negative Caption",
                     interactive=True,
                     value="",
-                    placeholder="Enter a negative caption.",
+                    placeholder="Enter a negative caption."
                 )
                 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(
@@ -451,99 +418,36 @@ def main():
                     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 superior images with the superior degree of image-text alignment based on textual prompts or user prompts.",
-                        "",
+                        ""
                     ],
-                    label="System Type",
+                    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"
-                    resolution = gr.Dropdown(
-                        value=default_value, choices=res_choices, label="Resolution"
-                    )
+                    resolution = gr.Dropdown(value=default_value, choices=res_choices, label="Resolution")
                 with gr.Row():
-                    num_sampling_steps = gr.Slider(
-                        minimum=1,
-                        maximum=70,
-                        value=40,
-                        step=1,
-                        interactive=True,
-                        label="Sampling Steps",
-                    )
-                    seed = gr.Slider(
-                        minimum=0,
-                        maximum=int(1e5),
-                        value=0,
-                        step=1,
-                        interactive=True,
-                        label="Seed (0 for random)",
-                    )
-                    cfg_trunc = gr.Slider(
-                        minimum=0,
-                        maximum=1,
-                        value=0,
-                        step=0.01,
-                        interactive=True,
-                        label="CFG Truncation",
-                    )
+                    num_sampling_steps = gr.Slider(minimum=1, maximum=70, value=40, step=1, interactive=True, label="Sampling Steps")
+                    seed = gr.Slider(minimum=0, maximum=int(1e5), value=0, step=1, interactive=True, label="Seed (0 for random)")
+                    cfg_trunc = gr.Slider(minimum=0, maximum=1, value=0, step=0.01, interactive=True, label="CFG Truncation")
                 with gr.Row():
-                    solver = gr.Dropdown(
-                        value="euler",
-                        choices=["euler", "midpoint", "rk4"],
-                        label="Solver",
-                    )
-                    t_shift = gr.Slider(
-                        minimum=1,
-                        maximum=20,
-                        value=6,
-                        step=1,
-                        interactive=True,
-                        label="Time Shift",
-                    )
-                    cfg_scale = gr.Slider(
-                        minimum=1.0,
-                        maximum=20.0,
-                        value=4.0,
-                        interactive=True,
-                        label="CFG Scale",
-                    )
+                    solver = gr.Dropdown(value="euler", choices=["euler", "midpoint", "rk4"], label="Solver")
+                    t_shift = gr.Slider(minimum=1, maximum=20, value=6, step=1, interactive=True, label="Time Shift")
+                    cfg_scale = gr.Slider(minimum=1.0, maximum=20.0, value=4.0, interactive=True, label="CFG Scale")
                 with gr.Row():
-                    renorm_cfg = gr.Dropdown(
-                        value=True,
-                        choices=[True, False, 2.0],
-                        label="CFG Renorm",
-                    )
+                    renorm_cfg = gr.Dropdown(value=True, choices=[True, False, 2.0], label="CFG Renorm")
                 with gr.Accordion("Advanced Settings for Resolution Extrapolation", open=False):
                     with gr.Row():
-                        scaling_method = gr.Dropdown(
-                            value="Time-aware",
-                            choices=["Time-aware", "None"],
-                            label="RoPE Scaling Method",
-                        )
-                        scaling_watershed = gr.Slider(
-                            minimum=0.0,
-                            maximum=1.0,
-                            value=0.3,
-                            interactive=True,
-                            label="Linear/NTK Watershed",
-                        )
+                        scaling_method = gr.Dropdown(value="Time-aware", choices=["Time-aware", "None"], label="RoPE Scaling Method")
+                        scaling_watershed = gr.Slider(minimum=0.0, maximum=1.0, value=0.3, interactive=True, label="Linear/NTK Watershed")
                     with gr.Row():
-                        proportional_attn = gr.Checkbox(
-                            value=True,
-                            interactive=True,
-                            label="Proportional Attention",
-                        )
+                        proportional_attn = gr.Checkbox(value=True, interactive=True, label="Proportional Attention")
                 with gr.Row():
                     submit_btn = gr.Button("Submit", variant="primary")
             with gr.Column():
-                output_img = gr.Image(
-                    label="Generated Image",
-                    interactive=False,
-                )
+                output_img = gr.Image(label="Generated Image", interactive=False)
                 with gr.Accordion(label="Generation Parameters", open=True):
                     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.",
@@ -553,48 +457,26 @@ def main():
             ]
             prompts = [[p] for p in prompts]
             gr.Examples(prompts, [cap], label="Examples")
-
         @spaces.GPU(duration=200)
         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(
             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,
-            ],
+            [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],
             [output_img, gr_metadata],
         )
-
         def show_scaling_watershed(scaling_m):
             return gr.update(visible=scaling_m == "Time-aware")
-
         scaling_method.change(show_scaling_watershed, scaling_method, scaling_watershed)
-
     demo.queue().launch(server_name="0.0.0.0")
 
-
 if __name__ == "__main__":
     main()