Add application file

app.py

@@ -0,0 +1,148 @@
+import random
+import torch
+from PIL import Image
+import gradio as gr
+from diffusers import DiffusionPipeline
+
+# Configure deterministic behavior for reproducibility
+torch.backends.cudnn.deterministic = True
+torch.backends.cudnn.benchmark = False
+torch.backends.cuda.matmul.allow_tf32 = True
+
+MAX_SEED = 2**32 - 1
+
+class ModelManager:
+    """
+    Handles model initialization, LoRA weight loading, and image generation.
+    """
+    def __init__(self, base_model: str, lora_repo: str, trigger_word: str = ""):
+        self.trigger_word = trigger_word
+        self.pipe = DiffusionPipeline.from_pretrained(base_model, torch_dtype=torch.bfloat16)
+        self.pipe.load_lora_weights(lora_repo)
+        self.pipe.to("cuda")
+
+    def generate_image(self, prompt: str, cfg_scale: float, steps: int, seed: int, 
+                       width: int, height: int, lora_scale: float, progress_callback) -> Image.Image:
+        """
+        Generates an image based on the given prompt and parameters using a callback for progress updates.
+        """
+        # Establish reproducible generator
+        generator = torch.Generator(device="cuda").manual_seed(seed)
+        full_prompt = f"{prompt} {self.trigger_word}"
+
+        def callback_fn(step: int, timestep: int, latents):
+            percentage = int((step / steps) * 100)
+            message = f"Processing step {step} of {steps}..."
+            progress_callback(percentage, message)
+
+        # Generate image with integrated progress reporting
+        image = self.pipe(
+            prompt=full_prompt,
+            num_inference_steps=steps,
+            guidance_scale=cfg_scale,
+            width=width,
+            height=height,
+            generator=generator,
+            joint_attention_kwargs={"scale": lora_scale},
+            callback=callback_fn,
+            callback_steps=1,
+        ).images[0]
+
+        return image
+
+# Initialize the model manager with specified models and LoRA weights
+model_manager = ModelManager(
+    base_model="black-forest-labs/FLUX.1-dev",
+    lora_repo="XLabs-AI/flux-RealismLora",
+    trigger_word=""
+)
+
+def run_generation(prompt, cfg_scale, steps, randomize_seed, seed, width, height, lora_scale, progress=gr.Progress(track_tqdm=True)):
+    """
+    Gradio interface callback to manage seed randomization, progress updates, 
+    and image generation using the ModelManager.
+    """
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+
+    # Start the progress
+    progress(0, "Starting image generation...")
+
+    # Generate the image using the model manager with progress callback integration
+    image = model_manager.generate_image(
+        prompt, cfg_scale, steps, seed, width, height, lora_scale, progress
+    )
+
+    # Mark completion
+    progress(100, "Completed!")
+    return image, seed
+
+# Example parameters and image path for initializing the interface with defaults
+example_image_path = "example0.webp"
+example_prompt = (
+    "A Jelita Sukawati speaker is captured mid-speech. She has long, dark brown hair that cascades over her shoulders, "
+    "framing her radiant, smiling face. Her Latina features are highlighted by warm, sun-kissed skin and bright, "
+    "expressive eyes. She gestures with her left hand, displaying a delicate ring on her pinky finger, as she speaks passionately. "
+    "The woman is wearing a colorful, patterned dress with a green lanyard featuring multiple badges and logos hanging around her neck. "
+    "The lanyard prominently displays the 'CagliostroLab' text. Behind her, there is a blurred background with a white banner "
+    "containing logos and text, indicating a professional or conference setting. The overall scene captures the energy and vibrancy "
+    "of her presentation."
+)
+example_cfg_scale = 3.2
+example_steps = 32
+example_width = 1152
+example_height = 896
+example_seed = 3981632454
+example_lora_scale = 0.85
+
+def load_example():
+    # Load example image for initial display
+    example_image = Image.open(example_image_path)
+    return (
+        example_prompt, 
+        example_cfg_scale, 
+        example_steps, 
+        True, 
+        example_seed, 
+        example_width, 
+        example_height, 
+        example_lora_scale, 
+        example_image
+    )
+
+with gr.Blocks() as app:
+    gr.Markdown("# Flux RealismLora Image Generator")
+    with gr.Row():
+        with gr.Column(scale=3):
+            prompt = gr.TextArea(label="Prompt", placeholder="Type a prompt", lines=5)
+            generate_button = gr.Button("Generate")
+            cfg_scale = gr.Slider(label="CFG Scale", minimum=1, maximum=20, step=0.5, value=example_cfg_scale)
+            steps = gr.Slider(label="Steps", minimum=1, maximum=100, step=1, value=example_steps)
+            width = gr.Slider(label="Width", minimum=256, maximum=1536, step=64, value=example_width)
+            height = gr.Slider(label="Height", minimum=256, maximum=1536, step=64, value=example_height)
+            randomize_seed = gr.Checkbox(True, label="Randomize seed")
+            seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=example_seed)
+            lora_scale = gr.Slider(label="LoRA Scale", minimum=0, maximum=1, step=0.01, value=example_lora_scale)
+        with gr.Column(scale=1):
+            result = gr.Image(label="Generated Image")
+            gr.Markdown(
+                "Generate images using RealismLora and a text prompt.\n"
+                "[[non-commercial license, Flux.1 Dev](https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/LICENSE.md)]"
+            )
+
+    # Load example data on launch
+    app.load(
+        load_example, 
+        inputs=[], 
+        outputs=[prompt, cfg_scale, steps, randomize_seed, seed, width, height, lora_scale, result]
+    )
+    
+    # Set up button interaction
+    generate_button.click(
+        run_generation,
+        inputs=[prompt, cfg_scale, steps, randomize_seed, seed, width, height, lora_scale],
+        outputs=[result, seed]
+    )
+
+app.queue()
+app.launch()