app.py

import spaces
import argparse
import os
import time
import gc
from os import path
import shutil
from datetime import datetime
import traceback
from safetensors.torch import load_file
from huggingface_hub import hf_hub_download
import gradio as gr
import torch
from diffusers import FluxPipeline
from diffusers.pipelines.stable_diffusion import safety_checker
from PIL import Image

# Setup and initialization code
cache_path = path.join(path.dirname(path.abspath(__file__)), "models")

os.environ["TRANSFORMERS_CACHE"] = cache_path
os.environ["HF_HUB_CACHE"] = cache_path
os.environ["HF_HOME"] = cache_path

# GPU 메모리 설정 최적화
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.benchmark = True  # 반복적인 크기의 입력에 대해 성능 향상

def filter_prompt(prompt):
    # 부적절한 키워드 목록
    inappropriate_keywords = [
        # 음란/성적 키워드
        "nude", "naked", "nsfw", "porn", "sex", "explicit", "adult", "xxx",
        "erotic", "sensual", "seductive", "provocative", "intimate",
        # 폭력적 키워드
        "violence", "gore", "blood", "death", "kill", "murder", "torture",
        # 기타 부적절한 키워드
        "drug", "suicide", "abuse", "hate", "discrimination"
    ]
    
    prompt_lower = prompt.lower()
    
    # 부적절한 키워드 체크
    for keyword in inappropriate_keywords:
        if keyword in prompt_lower:
            return False, "부적절한 내용이 포함된 프롬프트입니다."
            
    return True, prompt

class timer:
    def __init__(self, method_name="timed process"):
        self.method = method_name
    def __enter__(self):
        self.start = time.time()
        print(f"{self.method} starts")
    def __exit__(self, exc_type, exc_val, exc_tb):
        end = time.time()
        print(f"{self.method} took {str(round(end - self.start, 2))}s")

# 글로벌 변수로 파이프라인 선언
pipe = None

# 모델 초기화 함수 (지연 로딩)
def initialize_model():
    global pipe
    
    # 이미 로드된 경우 다시 로드하지 않음
    if pipe is not None:
        return
    
    try:
        if not path.exists(cache_path):
            os.makedirs(cache_path, exist_ok=True)
        
        # 메모리 확보를 위한 가비지 컬렉션 실행
        gc.collect()
        torch.cuda.empty_cache()
        
        with timer("모델 로딩"):
            pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", torch_dtype=torch.bfloat16)
            lora_path = hf_hub_download("ByteDance/Hyper-SD", "Hyper-FLUX.1-dev-8steps-lora.safetensors")
            pipe.load_lora_weights(lora_path)
            pipe.fuse_lora(lora_scale=0.125)
            pipe.to(device="cuda", dtype=torch.bfloat16)
            
            # 안전 검사기 추가
            pipe.safety_checker = safety_checker.StableDiffusionSafetyChecker.from_pretrained("CompVis/stable-diffusion-safety-checker")
            
        print("모델 로딩 완료")
        return True
    except Exception as e:
        print(f"모델 로딩 중 오류 발생: {str(e)}")
        traceback.print_exc()
        return False

css = """
footer {display: none !important}
.gradio-container {
    max-width: 1200px;
    margin: auto;
}
.contain {
    background: rgba(255, 255, 255, 0.05);
    border-radius: 12px;
    padding: 20px;
}
.generate-btn {
    background: linear-gradient(90deg, #4B79A1 0%, #283E51 100%) !important;
    border: none !important;
    color: white !important;
}
.generate-btn:hover {
    transform: translateY(-2px);
    box-shadow: 0 5px 15px rgba(0,0,0,0.2);
}
.title {
    text-align: center;
    font-size: 2.5em;
    font-weight: bold;
    margin-bottom: 1em;
    background: linear-gradient(90deg, #4B79A1 0%, #283E51 100%);
    -webkit-background-clip: text;
    -webkit-text-fill-color: transparent;
}
.output-image {
    width: 100% !important;
    max-width: 100% !important;
}
.contain > div {
    width: 100% !important;
    max-width: 100% !important;
}
.fixed-width {
    width: 100% !important;
    max-width: 100% !important;
}
.loading-indicator {
    text-align: center;
    padding: 20px;
    font-weight: bold;
    color: #4B79A1;
}
.error-message {
    background-color: rgba(255, 0, 0, 0.1);
    color: red;
    padding: 10px;
    border-radius: 8px;
    margin-top: 10px;
    text-align: center;
}
"""

# Create Gradio interface
with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
    gr.HTML('<div class="title">AI Image Generator</div>')
    gr.HTML('<div style="text-align: center; margin-bottom: 2em; color: #666;">Create stunning images from your descriptions</div>')
    
    gr.HTML("""
        <div style="color: red; margin-bottom: 1em; text-align: center; padding: 10px; background: rgba(255,0,0,0.1); border-radius: 8px;">
            ⚠️ Explicit or inappropriate content cannot be generated.
        </div>
    """)

    # 상태 표시 변수
    error_message = gr.HTML(visible=False, elem_classes=["error-message"])
    loading_status = gr.HTML(visible=False, elem_classes=["loading-indicator"])

    with gr.Row():
        with gr.Column(scale=3):
            prompt = gr.Textbox(
                label="Image Description",
                placeholder="Describe the image you want to create...",
                lines=3
            )
            
            with gr.Accordion("Advanced Settings", open=False):
                with gr.Row():
                    height = gr.Slider(
                        label="Height",
                        minimum=256,
                        maximum=1152,
                        step=64,
                        value=1024
                    )
                    width = gr.Slider(
                        label="Width",
                        minimum=256,
                        maximum=1152,
                        step=64,
                        value=1024
                    )
                
                with gr.Row():
                    steps = gr.Slider(
                        label="Inference Steps",
                        minimum=6,
                        maximum=25,
                        step=1,
                        value=8
                    )
                    scales = gr.Slider(
                        label="Guidance Scale",
                        minimum=0.0,
                        maximum=5.0,
                        step=0.1,
                        value=3.5
                    )
                
                def get_random_seed():
                    return int(torch.randint(0, 1000000, (1,)).item())
                
                seed = gr.Number(
                    label="Seed (random by default, set for reproducibility)",
                    value=get_random_seed(),
                    precision=0
                )
                
                randomize_seed = gr.Button("🎲 Randomize Seed", elem_classes=["generate-btn"])
            
            generate_btn = gr.Button(
                "✨ Generate Image",
                elem_classes=["generate-btn"]
            )
            
            gr.HTML("""
                <div style="margin-top: 1em; padding: 1em; border-radius: 8px; background: rgba(255, 255, 255, 0.05);">
                    <h4 style="margin: 0 0 0.5em 0;">Example Prompts:</h4>
                    <div style="background: rgba(75, 121, 161, 0.1); padding: 1em; border-radius: 8px; margin-bottom: 1em;">
                        <p style="font-weight: bold; margin: 0 0 0.5em 0;">🌅 Cinematic Landscape</p>
                        <p style="margin: 0; font-style: italic;">"A breathtaking mountain vista at golden hour, dramatic sunbeams piercing through clouds, snow-capped peaks reflecting warm light, ultra-high detail photography, artistically composed, award-winning landscape photo, shot on Hasselblad"</p>
                    </div>
                    <div style="background: rgba(75, 121, 161, 0.1); padding: 1em; border-radius: 8px; margin-bottom: 1em;">
                        <p style="font-weight: bold; margin: 0 0 0.5em 0;">🖼️ Fantasy Portrait</p>
                        <p style="margin: 0; font-style: italic;">"Ethereal portrait of an elven queen with flowing silver hair, adorned with luminescent crystals, intricate crown of twisted gold and moonstone, soft ethereal lighting, detailed facial features, fantasy art style, highly detailed, painted by Artgerm and Charlie Bowater"</p>
                    </div>
                    <div style="background: rgba(75, 121, 161, 0.1); padding: 1em; border-radius: 8px; margin-bottom: 1em;">
                        <p style="font-weight: bold; margin: 0 0 0.5em 0;">🌃 Cyberpunk Scene</p>
                        <p style="margin: 0; font-style: italic;">"Neon-lit cyberpunk street market in rain, holographic advertisements reflecting in puddles, street vendors with glowing cyber-augmentations, dense urban environment, atmospheric fog, cinematic lighting, inspired by Blade Runner 2049"</p>
                    </div>
                    <div style="background: rgba(75, 121, 161, 0.1); padding: 1em; border-radius: 8px; margin-bottom: 1em;">
                        <p style="font-weight: bold; margin: 0 0 0.5em 0;">🎨 Abstract Art</p>
                        <p style="margin: 0; font-style: italic;">"Vibrant abstract composition of flowing liquid colors, dynamic swirls of iridescent purples and teals, golden geometric patterns emerging from chaos, luxury art style, ultra-detailed, painted in oil on canvas, inspired by James Jean and Gustav Klimt"</p>
                    </div>
                    <div style="background: rgba(75, 121, 161, 0.1); padding: 1em; border-radius: 8px; margin-bottom: 1em;">
                        <p style="font-weight: bold; margin: 0 0 0.5em 0;">🌿 Macro Nature</p>
                        <p style="margin: 0; font-style: italic;">"Extreme macro photography of a dewdrop on a butterfly wing, rainbow light refraction, crystalline clarity, intricate wing scales visible, natural bokeh background, professional studio lighting, shot with Canon MP-E 65mm lens"</p>
                    </div>
                </div>
            """)

        with gr.Column(scale=4, elem_classes=["fixed-width"]):
            output = gr.Image(
                label="Generated Image",
                elem_id="output-image",
                elem_classes=["output-image", "fixed-width"]
            )
    
    @spaces.GPU
    def process_image(height, width, steps, scales, prompt, seed):
        # 모델 초기화 상태 확인
        if pipe is None:
            loading_status.update("모델을 로딩 중입니다... 처음 실행 시 시간이 소요될 수 있습니다.", visible=True)
            
            model_loaded = initialize_model()
            if not model_loaded:
                error_message.update("모델 로딩 중 오류가 발생했습니다. 페이지를 새로고침하고 다시 시도해 주세요.", visible=True)
                loading_status.update(visible=False)
                return None
                
            loading_status.update(visible=False)
        
        # 입력값 검증
        if not prompt or prompt.strip() == "":
            error_message.update("이미지 설명을 입력해주세요.", visible=True)
            return None
            
        # 프롬프트 필터링
        is_safe, filtered_prompt = filter_prompt(prompt)
        if not is_safe:
            error_message.update("부적절한 내용이 포함된 프롬프트입니다.", visible=True)
            return None
            
        # 에러 메시지 초기화
        error_message.update(visible=False)
        loading_status.update("이미지를 생성 중입니다...", visible=True)
            
        try:
            # 메모리 확보를 위한 가비지 콜렉션
            gc.collect()
            torch.cuda.empty_cache()
            
            # 시드 값 확인 및 보정
            if seed is None or not isinstance(seed, (int, float)):
                seed = get_random_seed()
            else:
                seed = int(seed)  # 타입 변환 안전하게 처리
                
            # 이미지 생성
            with torch.inference_mode(), torch.autocast("cuda", dtype=torch.bfloat16), timer("inference"):
                generator = torch.Generator(device="cuda").manual_seed(seed)
                
                # 높이와 너비를 64의 배수로 조정 (FLUX 모델 요구사항)
                height = (int(height) // 64) * 64
                width = (int(width) // 64) * 64
                
                # 안전장치 - 최대값 제한
                steps = min(int(steps), 25)
                scales = max(min(float(scales), 5.0), 0.0)
                
                generated_image = pipe(
                    prompt=[filtered_prompt],
                    generator=generator,
                    num_inference_steps=steps,
                    guidance_scale=scales,
                    height=height,
                    width=width,
                    max_sequence_length=256
                ).images[0]
                
                loading_status.update(visible=False)
                return generated_image
                
        except Exception as e:
            error_msg = f"이미지 생성 중 오류가 발생했습니다: {str(e)}"
            print(error_msg)
            traceback.print_exc()
            error_message.update(error_msg, visible=True)
            loading_status.update(visible=False)
            
            # 오류 후 메모리 정리
            gc.collect()
            torch.cuda.empty_cache()
            
            return None
    
    def update_seed():
        return get_random_seed()
        
    # 버튼 클릭 이벤트 - 모든 UI 요소 초기화 추가
    def on_generate_click(height, width, steps, scales, prompt, seed):
        error_message.update(visible=False)
        return process_image(height, width, steps, scales, prompt, seed)

    generate_btn.click(
        on_generate_click,
        inputs=[height, width, steps, scales, prompt, seed],
        outputs=[output]
    )
    
    randomize_seed.click(
        update_seed,
        outputs=[seed]
    )

if __name__ == "__main__":
    # 앱 시작 시 모델 미리 로드하지 않음 (첫 요청 시 지연 로딩)
    demo.queue(max_size=10).launch()