Update app.py

app.py

@@ -1,370 +1,297 @@
+import random
 import os
+import uuid
+from datetime import datetime
 import gradio as gr
-import json
-import logging
+import numpy as np
+import spaces
 import torch
+from diffusers import DiffusionPipeline
 from PIL import Image
-import spaces
-from diffusers import DiffusionPipeline, AutoencoderTiny, AutoencoderKL
-from live_preview_helpers import calculate_shift, retrieve_timesteps, flux_pipe_call_that_returns_an_iterable_of_images
-from huggingface_hub import hf_hub_download, HfFileSystem, ModelCard, snapshot_download
-import copy
-import random
-import time
-from transformers import pipeline
-import sqlite3
-from datetime import datetime
-
-# 데이터베이스 초기화
-def init_db():
-    conn = sqlite3.connect('gallery.db')
-    c = conn.cursor()
-    c.execute('''CREATE TABLE IF NOT EXISTS images
-                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
-                  model_name TEXT,
-                  prompt TEXT,
-                  image_path TEXT,
-                  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''')
-    conn.commit()
-    conn.close()
-
-# 이미지 저장 함수
-def save_image(image, model_name, prompt):
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"gallery_{timestamp}.png"
-    image.save(os.path.join("gallery", filename))
-    
-    conn = sqlite3.connect('gallery.db')
-    c = conn.cursor()
-    c.execute("INSERT INTO images (model_name, prompt, image_path) VALUES (?, ?, ?)",
-              (model_name, prompt, filename))
-    conn.commit()
-    conn.close()
-
-# 갤러리 이미지 로드 함수
-def load_gallery_images():
-    conn = sqlite3.connect('gallery.db')
-    c = conn.cursor()
-    c.execute("SELECT model_name, prompt, image_path FROM images ORDER BY created_at DESC")
-    rows = c.fetchall()
-    conn.close()
-    
-    return [(os.path.join("gallery", row[2]), f"{row[0]}: {row[1]}") for row in rows]
-
-# CPU에서 실행되는 번역기 초기화
-translator = pipeline("translation", model="Helsinki-NLP/opus-mt-ko-en", device=-1)
-
-# 프롬프트 처리 함수
-def process_prompt(prompt):
-    if any('\u3131' <= char <= '\u3163' or '\uac00' <= char <= '\ud7a3' for char in prompt):
-        translated = translator(prompt)[0]['translation_text']
-        return prompt, translated
-    return prompt, prompt
-
 
-KEY_JSON = os.getenv("KEY_JSON")
-with open(KEY_JSON, 'r') as f:
-    loras = json.load(f)
+# Create permanent storage directory
+SAVE_DIR = "saved_images"  # Gradio will handle the persistence
+if not os.path.exists(SAVE_DIR):
+    os.makedirs(SAVE_DIR, exist_ok=True)
 
-# 기본 모델 초기화
-dtype = torch.bfloat16
 device = "cuda" if torch.cuda.is_available() else "cpu"
-base_model = "black-forest-labs/FLUX.1-dev"
+repo_id = "black-forest-labs/FLUX.1-dev"
+adapter_id = "openfree/pierre-auguste-renoir"  # Changed to Renoir model
 
-taef1 = AutoencoderTiny.from_pretrained("madebyollin/taef1", torch_dtype=dtype).to(device)
-good_vae = AutoencoderKL.from_pretrained(base_model, subfolder="vae", torch_dtype=dtype).to(device)
-pipe = DiffusionPipeline.from_pretrained(base_model, torch_dtype=dtype, vae=taef1).to(device)
+pipeline = DiffusionPipeline.from_pretrained(repo_id, torch_dtype=torch.bfloat16)
+pipeline.load_lora_weights(adapter_id)
+pipeline = pipeline.to(device)
 
-MAX_SEED = 2**32-1
+MAX_SEED = np.iinfo(np.int32).max
+MAX_IMAGE_SIZE = 1024
 
-pipe.flux_pipe_call_that_returns_an_iterable_of_images = flux_pipe_call_that_returns_an_iterable_of_images.__get__(pipe)
-
-class calculateDuration:
-    def __init__(self, activity_name=""):
-        self.activity_name = activity_name
-
-    def __enter__(self):
-        self.start_time = time.time()
-        return self
+def save_generated_image(image, prompt):
+    # Generate unique filename with timestamp
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    unique_id = str(uuid.uuid4())[:8]
+    filename = f"{timestamp}_{unique_id}.png"
+    filepath = os.path.join(SAVE_DIR, filename)
     
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.end_time = time.time()
-        self.elapsed_time = self.end_time - self.start_time
-        if self.activity_name:
-            print(f"Elapsed time for {self.activity_name}: {self.elapsed_time:.6f} seconds")
-        else:
-            print(f"Elapsed time: {self.elapsed_time:.6f} seconds")
-
-def update_selection(evt: gr.SelectData, width, height):
-    selected_lora = loras[evt.index]
-    new_placeholder = f"{selected_lora['title']}를 위한 프롬프트를 입력하세요"
-    lora_repo = selected_lora["repo"]
-    updated_text = f"### 선택됨: [{lora_repo}](https://huggingface.co/{lora_repo}) ✨"
-    if "aspect" in selected_lora:
-        if selected_lora["aspect"] == "portrait":
-            width = 768
-            height = 1024
-        elif selected_lora["aspect"] == "landscape":
-            width = 1024
-            height = 768
-        else:
-            width = 1024
-            height = 1024
-    return (
-        gr.update(placeholder=new_placeholder),
-        updated_text,
-        evt.index,
-        width,
-        height,
-    )
-
-@spaces.GPU(duration=70)
-def generate_image(prompt_mash, steps, seed, cfg_scale, width, height, lora_scale, progress):
-    pipe.to("cuda")
-    generator = torch.Generator(device="cuda").manual_seed(seed)
-    with calculateDuration("이미지 생성"):
-        # Generate image
-        for img in pipe.flux_pipe_call_that_returns_an_iterable_of_images(
-            prompt=prompt_mash,
-            num_inference_steps=steps,
-            guidance_scale=cfg_scale,
-            width=width,
-            height=height,
-            generator=generator,
-            joint_attention_kwargs={"scale": lora_scale},
-            output_type="pil",
-            good_vae=good_vae,
-        ):
-            yield img
-
-@spaces.GPU(duration=70)
-def run_lora(prompt, cfg_scale, steps, selected_index, randomize_seed, seed, width, height, lora_scale, progress=gr.Progress(track_tqdm=True)):
-    if selected_index is None:
-        raise gr.Error("진행하기 전에 LoRA를 선택해야 합니다.")
+    # Save the image
+    image.save(filepath)
     
-    original_prompt, english_prompt = process_prompt(prompt)
+    # Save metadata
+    metadata_file = os.path.join(SAVE_DIR, "metadata.txt")
+    with open(metadata_file, "a", encoding="utf-8") as f:
+        f.write(f"{filename}|{prompt}|{timestamp}\n")
     
-    selected_lora = loras[selected_index]
-    lora_path = selected_lora["repo"]
-    trigger_word = selected_lora["trigger_word"]
-    if(trigger_word):
-        if "trigger_position" in selected_lora:
-            if selected_lora["trigger_position"] == "prepend":
-                prompt_mash = f"{trigger_word} {english_prompt}"
-            else:
-                prompt_mash = f"{english_prompt} {trigger_word}"
-        else:
-            prompt_mash = f"{trigger_word} {english_prompt}"
-    else:
-        prompt_mash = english_prompt
+    return filepath
 
-    with calculateDuration("LoRA 언로드"):
-        pipe.unload_lora_weights()
-        
-    # LoRA 가중치 로드
-    with calculateDuration(f"{selected_lora['title']}의 LoRA 가중치 로드"):
-        if "weights" in selected_lora:
-            pipe.load_lora_weights(lora_path, weight_name=selected_lora["weights"])
-        else:
-            pipe.load_lora_weights(lora_path)
-
-    # 재현성을 위한 시드 설정
-    with calculateDuration("시드 무작위화"):
-        if randomize_seed:
-            seed = random.randint(0, MAX_SEED)
-
-    image_generator = generate_image(prompt_mash, steps, seed, cfg_scale, width, height, lora_scale, progress)
+def load_generated_images():
+    if not os.path.exists(SAVE_DIR):
+        return []
     
-    # 최종 이미지를 얻기 위해 제너레이터 소비
-    final_image = None
-    step_counter = 0
-    for image in image_generator:
-        step_counter+=1
-        final_image = image
-        progress_bar = f'<div class="progress-container"><div class="progress-bar" style="--current: {step_counter}; --total: {steps};"></div></div>'
-        yield image, seed, gr.update(value=progress_bar, visible=True), original_prompt, english_prompt
+    # Load all images from the directory
+    image_files = [os.path.join(SAVE_DIR, f) for f in os.listdir(SAVE_DIR) 
+                  if f.endswith(('.png', '.jpg', '.jpeg', '.webp'))]
+    # Sort by creation time (newest first)
+    image_files.sort(key=lambda x: os.path.getctime(x), reverse=True)
+    return image_files
+
+def load_predefined_images():
+    predefined_images = [
+        "assets/r1.webp",
+        "assets/r2.webp",
+        "assets/r3.webp",
+        "assets/r4.webp",
+        "assets/r5.webp",
+        "assets/r6.webp",
+    ]
+    return predefined_images
+
+@spaces.GPU(duration=120)
+def inference(
+    prompt: str,
+    seed: int,
+    randomize_seed: bool,
+    width: int,
+    height: int,
+    guidance_scale: float,
+    num_inference_steps: int,
+    lora_scale: float,
+    progress: gr.Progress = gr.Progress(track_tqdm=True),
+):
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    generator = torch.Generator(device=device).manual_seed(seed)
     
-    # 갤러리에 이미지 저장
-    save_image(final_image, selected_lora['title'], original_prompt)
+    image = pipeline(
+        prompt=prompt,
+        guidance_scale=guidance_scale,
+        num_inference_steps=num_inference_steps,
+        width=width,
+        height=height,
+        generator=generator,
+        joint_attention_kwargs={"scale": lora_scale},
+    ).images[0]
     
-    yield final_image, seed, gr.update(value=progress_bar, visible=False), original_prompt, english_prompt
-
-def get_huggingface_safetensors(link):
-    split_link = link.split("/")
-    if(len(split_link) == 2):
-        model_card = ModelCard.load(link)
-        base_model = model_card.data.get("base_model")
-        print(base_model)
-        if((base_model != "black-forest-labs/FLUX.1-dev") and (base_model != "black-forest-labs/FLUX.1-schnell")):
-            raise Exception("Not a FLUX LoRA!")
-        image_path = model_card.data.get("widget", [{}])[0].get("output", {}).get("url", None)
-        trigger_word = model_card.data.get("instance_prompt", "")
-        image_url = f"https://huggingface.co/{link}/resolve/main/{image_path}" if image_path else None
-        fs = HfFileSystem()
-        try:
-            list_of_files = fs.ls(link, detail=False)
-            for file in list_of_files:
-                if(file.endswith(".safetensors")):
-                    safetensors_name = file.split("/")[-1]
-                if (not image_url and file.lower().endswith((".jpg", ".jpeg", ".png", ".webp"))):
-                    image_elements = file.split("/")
-                    image_url = f"https://huggingface.co/{link}/resolve/main/{image_elements[-1]}"
-        except Exception as e:
-            print(e)
-            gr.Warning(f"You didn't include a link neither a valid Hugging Face repository with a *.safetensors LoRA")
-            raise Exception(f"You didn't include a link neither a valid Hugging Face repository with a *.safetensors LoRA")
-        return split_link[1], link, safetensors_name, trigger_word, image_url
-
-def check_custom_model(link):
-    if(link.startswith("https://")):
-        if(link.startswith("https://huggingface.co") or link.startswith("https://www.huggingface.co")):
-            link_split = link.split("huggingface.co/")
-            return get_huggingface_safetensors(link_split[1])
-    else: 
-        return get_huggingface_safetensors(link)
-
-def add_custom_lora(custom_lora):
-    global loras
-    if(custom_lora):
-        try:
-            title, repo, path, trigger_word, image = check_custom_model(custom_lora)
-            print(f"Loaded custom LoRA: {repo}")
-            card = f'''
-            <div class="custom_lora_card">
-              <span>Loaded custom LoRA:</span>
-              <div class="card_internal">
-                <img src="{image}" />
-                <div>
-                    <h3>{title}</h3>
-                    <small>{"Using: <code><b>"+trigger_word+"</code></b> as the trigger word" if trigger_word else "No trigger word found. If there's a trigger word, include it in your prompt"}<br></small>
-                </div>
-              </div>
-            </div>
-            '''
-            existing_item_index = next((index for (index, item) in enumerate(loras) if item['repo'] == repo), None)
-            if(not existing_item_index):
-                new_item = {
-                    "image": image,
-                    "title": title,
-                    "repo": repo,
-                    "weights": path,
-                    "trigger_word": trigger_word
-                }
-                print(new_item)
-                existing_item_index = len(loras)
-                loras.append(new_item)
-        
-            return gr.update(visible=True, value=card), gr.update(visible=True), gr.Gallery(selected_index=None), f"Custom: {path}", existing_item_index, trigger_word
-        except Exception as e:
-            gr.Warning(f"Invalid LoRA: either you entered an invalid link, or a non-FLUX LoRA")
-            return gr.update(visible=True, value=f"Invalid LoRA: either you entered an invalid link, a non-FLUX LoRA"), gr.update(visible=True), gr.update(), "", None, ""
-    else:
-        return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None, ""
-
-def remove_custom_lora():
-    return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None, ""
-
-run_lora.zerogpu = True
-
-css = """
+    # Save the generated image
+    filepath = save_generated_image(image, prompt)
+    
+    # Return the image, seed, and updated gallery
+    return image, seed, load_generated_images()
+
+examples = [
+    "Renoir's painting of a lively outdoor dance scene at Moulin de la Galette, with dappled sunlight filtering through trees, illuminating well-dressed Parisians enjoying a summer afternoon. Couples dance while others socialize at tables, capturing the joie de vivre of 1870s Montmartre. [trigger]",
+    "Renoir's intimate portrait of a young woman with rosy cheeks and lips, soft blonde hair, and a gentle smile. She wears a vibrant blue dress against a background of lush flowers and greenery, showcasing his mastery of depicting feminine beauty with warm, luminous skin tones. [trigger]",
+    "Renoir's painting of two young girls seated at a piano, captured in his distinctive soft focus style. The scene shows one girl playing while the other stands beside her, both wearing delicate white dresses. The interior setting features warm colors and loose brushwork typical of his mature period. [trigger]",
+    "Renoir's painting of an elegant boating party, with fashionably dressed men and women relaxing on a restaurant terrace overlooking the Seine. The scene captures the leisurely atmosphere of 1880s French society, with sparkling water reflections and a bright, airy palette of blues, whites, and warm flesh tones. [trigger]",
+    "Renoir's painting of a sun-dappled garden scene with children playing. The composition features vibrant flowers in full bloom, lush greenery, and Renoir's characteristic luminous treatment of sunlight filtering through foliage, creating patches of brilliant color across the canvas. [trigger]",
+    "Renoir's depiction of bathers by a riverbank, with several female figures arranged in a harmonious composition. The painting showcases his later style with fuller figures rendered in pearlescent flesh tones against a backdrop of shimmering water and verdant landscape, demonstrating his unique approach to the nude figure in nature. [trigger]"
+]
+
+# Brighter custom CSS with vibrant colors
+custom_css = """
+:root {
+    --color-primary: #FF9E6C;
+    --color-secondary: #FFD8A9;
+}
 footer {
     visibility: hidden;
 }
+.gradio-container {
+    background: linear-gradient(to right, #FFF4E0, #FFEDDB);
+}
+.title {
+    color: #E25822 !important;
+    font-size: 2.5rem !important;
+    font-weight: 700 !important;
+    text-align: center;
+    margin: 1rem 0;
+    text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
+}
+.subtitle {
+    color: #2B3A67 !important;
+    font-size: 1.2rem !important;
+    text-align: center;
+    margin-bottom: 2rem;
+}
+.model-description {
+    background-color: rgba(255, 255, 255, 0.7);
+    border-radius: 10px;
+    padding: 20px;
+    margin: 20px 0;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    border-left: 5px solid #E25822;
+}
+button.primary {
+    background-color: #E25822 !important;
+}
+button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+}
+.tabs {
+    margin-top: 20px;
+}
+.gallery {
+    background-color: rgba(255, 255, 255, 0.5);
+    border-radius: 10px;
+    padding: 10px;
+}
 """
 
-# 갤러리 디렉토리 생성
-if not os.path.exists('gallery'):
-    os.makedirs('gallery')
-
-# 데이터베이스 초기화
-init_db()
-
-with gr.Blocks(theme=gr.themes.Soft(), css=css) as app:
-    selected_index = gr.State(None)
+with gr.Blocks(css=custom_css, analytics_enabled=False) as demo:
+    gr.HTML('<div class="title">Pierre-Auguste Renoir STUDIO</div>')
     
-    with gr.Tabs():
-        with gr.TabItem("생성"):
-            with gr.Row():
-                with gr.Column(scale=3):
-                    prompt = gr.Textbox(label="프롬프트", lines=1, placeholder="LoRA를 선택한 후 프롬프트를 입력하세요 (한글 또는 영어)")
-                with gr.Column(scale=1, elem_id="gen_column"):
-                    generate_button = gr.Button("생성", variant="primary", elem_id="gen_btn")
-            with gr.Row():
-                with gr.Column():
-                    selected_info = gr.Markdown("")
-                    gallery = gr.Gallery(
-                        [(item["image"], item["title"]) for item in loras],
-                        label="LoRA 갤러리",
-                        allow_preview=False,
-                        columns=4,
-                        elem_id="gallery"
+    # Model description with the requested content
+    with gr.Group(elem_classes="model-description"):
+        gr.Markdown("""
+        # About This Model
+        
+        This studio features the **Pierre-Auguste Renoir** artistic style model from [openfree/pierre-auguste-renoir](https://huggingface.co/openfree/pierre-auguste-renoir). 
+        
+        Pierre-Auguste Renoir (1841-1919) was a leading painter in the development of the Impressionist style. His paintings are notable for their vibrant light and saturated color, focusing on people in intimate and candid compositions. The warmth of his palette often emphasized the sensual beauty of his subjects, particularly women.
+        
+        I developed a flux-based learning model trained on a curated collection of high-resolution masterpieces from renowned global artists. This LoRA fine-tuning process leveraged the exceptional quality of open-access imagery released by prestigious institutions including the Art Institute of Chicago. The resulting model demonstrates remarkable capability in capturing the nuanced artistic techniques and stylistic elements across diverse historical art movements.
+        
+        **How to use**: Simply enter a prompt describing a scene in Renoir's style and add [trigger] at the end.
+        """)
+
+    with gr.Tabs(elem_classes="tabs") as tabs:
+        with gr.Tab("Generation"):
+            with gr.Column(elem_id="col-container"):
+                with gr.Row():
+                    prompt = gr.Text(
+                        label="Prompt",
+                        show_label=False,
+                        max_lines=1,
+                        placeholder="Enter your prompt (add [trigger] at the end)",
+                        container=False,
                     )
-                    with gr.Group():
-                        custom_lora = gr.Textbox(label="커스텀 LoRA", info="LoRA Hugging Face 경로", placeholder="multimodalart/vintage-ads-flux")
-                        gr.Markdown("[FLUX LoRA 목록 확인](https://huggingface.co/models?other=base_model:adapter:black-forest-labs/FLUX.1-dev)", elem_id="lora_list")
-                    custom_lora_info = gr.HTML(visible=False)
-                    custom_lora_button = gr.Button("커스텀 LoRA 제거", visible=False)
-                with gr.Column():
-                    progress_bar = gr.Markdown(elem_id="progress",visible=False)
-                    result = gr.Image(label="생성된 이미지")
-                    original_prompt_display = gr.Textbox(label="원본 프롬프트")
-                    english_prompt_display = gr.Textbox(label="영어 프롬프트")
+                    run_button = gr.Button("Generate", variant="primary", scale=0)
 
-            with gr.Row():
-                with gr.Accordion("고급 설정", open=False):
-                    with gr.Column():
-                        with gr.Row():
-                            cfg_scale = gr.Slider(label="CFG 스케일", minimum=1, maximum=20, step=0.5, value=3.5)
-                            steps = gr.Slider(label="스텝", minimum=1, maximum=50, step=1, value=28)
-                        
-                        with gr.Row():
-                            width = gr.Slider(label="너비", minimum=256, maximum=1536, step=64, value=1024)
-                            height = gr.Slider(label="높이", minimum=256, maximum=1536, step=64, value=1024)
-                        
-                        with gr.Row():
-                            randomize_seed = gr.Checkbox(True, label="시드 무작위화")
-                            seed = gr.Slider(label="시드", minimum=0, maximum=MAX_SEED, step=1, value=0, randomize=True)
-                            lora_scale = gr.Slider(label="LoRA 스케일", minimum=0, maximum=3, step=0.01, value=0.95)
+                result = gr.Image(label="Result", show_label=False)
 
-        with gr.TabItem("갤러리"):
-            gallery_images = gr.Gallery(
-                load_gallery_images(),
-                label="생성된 이미지 갤러리",
+                with gr.Accordion("Advanced Settings", open=False):
+                    seed = gr.Slider(
+                        label="Seed",
+                        minimum=0,
+                        maximum=MAX_SEED,
+                        step=1,
+                        value=42,
+                    )
+                    randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+
+                    with gr.Row():
+                        width = gr.Slider(
+                            label="Width",
+                            minimum=256,
+                            maximum=MAX_IMAGE_SIZE,
+                            step=32,
+                            value=1024,
+                        )
+                        height = gr.Slider(
+                            label="Height",
+                            minimum=256,
+                            maximum=MAX_IMAGE_SIZE,
+                            step=32,
+                            value=768,
+                        )
+
+                    with gr.Row():
+                        guidance_scale = gr.Slider(
+                            label="Guidance scale",
+                            minimum=0.0,
+                            maximum=10.0,
+                            step=0.1,
+                            value=3.5,
+                        )
+                        num_inference_steps = gr.Slider(
+                            label="Number of inference steps",
+                            minimum=1,
+                            maximum=50,
+                            step=1,
+                            value=30,
+                        )
+                        lora_scale = gr.Slider(
+                            label="LoRA scale",
+                            minimum=0.0,
+                            maximum=1.0,
+                            step=0.1,
+                            value=1.0,
+                        )
+
+                gr.Examples(
+                    examples=examples,
+                    inputs=[prompt],
+                    outputs=[result, seed],
+                )
+
+        with gr.Tab("Gallery"):
+            gallery_header = gr.Markdown("### Your Generated Images")
+            generated_gallery = gr.Gallery(
+                label="Generated Images",
                 columns=3,
-                rows=3,
+                show_label=False,
+                value=load_generated_images(),
+                elem_id="generated_gallery",
+                elem_classes="gallery",
                 height="auto"
             )
-            refresh_button = gr.Button("갤러리 새로고침")
-
-    gallery.select(
-        update_selection,
-        inputs=[width, height],
-        outputs=[prompt, selected_info, selected_index, width, height]
-    )
-    
-    custom_lora.input(
-        add_custom_lora,
-        inputs=[custom_lora],
-        outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index, prompt]
-    )
-    
-    custom_lora_button.click(
-        remove_custom_lora,
-        outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index, custom_lora]
+            refresh_btn = gr.Button("🔄 Refresh Gallery", variant="primary")
+
+    # Add sample gallery section at the bottom
+    gr.Markdown("### Pierre-Auguste Renoir Style Examples")
+    predefined_gallery = gr.Gallery(
+        label="Sample Images", 
+        columns=3,
+        rows=2,
+        show_label=False, 
+        value=load_predefined_images(),
+        elem_classes="gallery"
     )
 
-    gr.on(
-        triggers=[generate_button.click, prompt.submit],
-        fn=run_lora,
-        inputs=[prompt, cfg_scale, steps, selected_index, randomize_seed, 
-                seed, width, height, lora_scale],
-        outputs=[result, seed, progress_bar, original_prompt_display, english_prompt_display]
+    # Event handlers
+    def refresh_gallery():
+        return load_generated_images()
+
+    refresh_btn.click(
+        fn=refresh_gallery,
+        inputs=None,
+        outputs=generated_gallery,
     )
 
-    refresh_button.click(
-        lambda: gr.update(value=load_gallery_images()),
-        outputs=[gallery_images]
+    gr.on(
+        triggers=[run_button.click, prompt.submit],
+        fn=inference,
+        inputs=[
+            prompt,
+            seed,
+            randomize_seed,
+            width,
+            height,
+            guidance_scale,
+            num_inference_steps,
+            lora_scale,
+        ],
+        outputs=[result, seed, generated_gallery],
     )
 
-app.queue()
-app.launch()
+demo.queue()
+demo.launch()