Update app.py

app.py

@@ -1,14 +1,12 @@
 import gradio as gr
 import torch
-import random
 import time
+import random
 import re
-import numpy as np
 from diffusers import DiffusionPipeline, LCMScheduler
-from PIL import Image
 
 # -------------------------------------------------
-# MODEL SETUP (CPU-ONLY, FAST)
+# MODEL SETUP (CPU SAFE)
 # -------------------------------------------------
 model_id = "runwayml/stable-diffusion-v1-5"
 adapter_id = "latent-consistency/lcm-lora-sdv1-5"
@@ -24,140 +22,129 @@ pipe.to("cpu")
 
 pipe.enable_attention_slicing()
 pipe.enable_vae_slicing()
+pipe.set_progress_bar_config(disable=True)
 
 # -------------------------------------------------
-# FAST PROMPT ANALYZER (NO DELAYS)
+# EXCELLENT UNDERSTANDING ENGINE (FAST, NO ML)
 # -------------------------------------------------
-def analyze_prompt(prompt: str):
-    p = prompt.lower()
-
-    # Detect single-object intent
-    single_object = not re.search(r"\b(two|three|multiple|many|group|pile)\b", p)
+def refine_prompt(user_prompt: str):
+    p = user_prompt.lower()
 
-    # Detect scene
-    is_scene = any(k in p for k in [
-        "room", "street", "city", "forest", "landscape", "background"
-    ])
+    # Detect style intent
+    is_cute = any(k in p for k in ["cute", "adorable", "kawaii"])
+    is_realistic = any(k in p for k in ["realistic", "photo", "photograph"])
+    is_cartoon = any(k in p for k in ["cartoon", "anime", "illustration"])
 
-    if single_object and not is_scene:
-        optimized = (
-            f"single centered {prompt}, isolated object, plain background, "
-            f"sharp focus, product photo"
-        )
-        neg = (
-            "multiple objects, duplicates, crowd, background objects, clutter"
-        )
-    else:
-        optimized = f"{prompt}, high quality"
-        neg = "blurry, low quality"
+    # Detect animal
+    animal_match = re.search(
+        r"(snake|cat|dog|dragon|bird|fox|rabbit|lion|tiger)", p
+    )
 
-    return optimized, neg, is_scene
+    subject = animal_match.group(1) if animal_match else user_prompt
 
-# -------------------------------------------------
-# SMART AUTO-CROP (FAST, NO ML)
-# -------------------------------------------------
-def smart_crop(img: Image.Image, padding=5):
-    gray = np.array(img.convert("L"))
-    mask = gray > 20  # detect non-black-ish pixels
+    # Base object enforcement
+    prompt = f"a single {subject}, centered, isolated"
 
-    if not mask.any():
-        return img  # safety fallback
+    # Style refinement
+    if is_cute:
+        prompt += (
+            ", cute, friendly, rounded shapes, big expressive eyes, "
+            "soft lighting, smooth colors"
+        )
+    elif is_cartoon:
+        prompt += ", cartoon style, clean lines, vibrant colors"
+    elif is_realistic:
+        prompt += ", ultra realistic, sharp focus, professional photography"
+    else:
+        prompt += ", high quality, detailed"
 
-    coords = np.argwhere(mask)
-    y0, x0 = coords.min(axis=0)
-    y1, x1 = coords.max(axis=0)
+    prompt += ", simple background"
 
-    h, w = gray.shape
-    x0 = max(0, x0 - padding)
-    y0 = max(0, y0 - padding)
-    x1 = min(w, x1 + padding)
-    y1 = min(h, y1 + padding)
+    negative = (
+        "multiple subjects, duplicate, horror, scary, grotesque, "
+        "deformed, blurry, low quality, background clutter"
+    )
 
-    return img.crop((x0, y0, x1, y1))
+    return prompt, negative
 
 # -------------------------------------------------
-# GENERATION CORE (FAST <10s)
+# GENERATION
 # -------------------------------------------------
-def generate(
-    prompt,
-    size,
-    steps,
-    random_seed,
-    seed_val,
-    auto_res
-):
+def generate(prompt, resolution, steps):
     start = time.time()
 
-    optimized_prompt, neg_prompt, is_scene = analyze_prompt(prompt)
-
-    # Resolution logic
-    if auto_res and not is_scene:
-        width = height = 448
-    else:
-        width = height = int(size)
+    refined_prompt, neg_prompt = refine_prompt(prompt)
 
-    seed = random.randint(0, 999999) if random_seed else int(seed_val)
+    seed = random.randint(0, 10**9)
     gen = torch.Generator("cpu").manual_seed(seed)
 
-    image = pipe(
-        prompt=optimized_prompt,
+    img = pipe(
+        prompt=refined_prompt,
         negative_prompt=neg_prompt,
         num_inference_steps=int(steps),
-        guidance_scale=1.2,  # LCM sweet spot
-        width=width,
-        height=height,
+        guidance_scale=1.2,
+        width=int(resolution),
+        height=int(resolution),
         generator=gen
     ).images[0]
 
-    # Auto-crop ONLY for single objects
-    if auto_res and not is_scene:
-        image = smart_crop(image, padding=5)
-
     duration = round(time.time() - start, 2)
-    status = f"✅ Done in {duration}s | Seed: {seed}"
+    status = f"✅ Generated in {duration}s | Seed: {seed}"
 
-    return [image], status
+    return [img], status
 
 # -------------------------------------------------
-# ETA (CPU-REALISTIC)
+# FAST & REALISTIC ETA ( < 10 ms )
 # -------------------------------------------------
-def estimate_time(steps, size, auto):
-    base = 0.9  # model overhead
-    res = 448 if auto else int(size)
-    step_cost = 0.22 * (res / 512) ** 2
-    est = base + steps * step_cost
-    return f"⚡ Estimated: ~{round(est, 1)}s"
+def estimate_time(steps, resolution):
+    base_overhead = 1.2
+    res_factor = (int(resolution) / 512) ** 2
+    step_cost = 0.35
+
+    est = base_overhead + (steps * step_cost * res_factor)
+    return f"⚡ Estimated time: ~{round(est, 1)}s"
 
 # -------------------------------------------------
 # UI
 # -------------------------------------------------
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 👾 CREEPER AI — FAST SMART IMAGE CORE")
+    gr.Markdown("# 👾 CREEPER AI — IMAGE (SMART CORE)")
 
     with gr.Row():
         with gr.Column():
-            prompt_in = gr.Textbox(label="Prompt", placeholder="apple")
-            auto_res = gr.Checkbox(label="Smart Auto-Resolution", value=True)
-            size = gr.Radio([512, 768], value=512, label="Base Resolution")
-            steps = gr.Slider(2, 6, value=4, step=1, label="Steps")
-
-            random_seed = gr.Checkbox(label="Random Seed", value=True)
-            seed_val = gr.Number(label="Manual Seed", value=42, visible=False)
-
-            eta = gr.Markdown("⚡ Estimated: ~2.0s")
+            prompt_in = gr.Textbox(
+                label="Prompt",
+                placeholder="cute snake",
+                lines=2
+            )
+
+            resolution = gr.Radio(
+                [256, 512, 768, 1024],
+                value=512,
+                label="Resolution"
+            )
+
+            steps = gr.Slider(
+                minimum=2,
+                maximum=10,
+                value=4,
+                step=1,
+                label="Steps"
+            )
+
+            eta = gr.Markdown("⚡ Estimated time: ~2.5s")
             btn = gr.Button("Generate")
 
         with gr.Column():
             status = gr.Markdown("🟢 Ready")
             gallery = gr.Gallery(columns=1)
 
-    random_seed.change(lambda x: gr.update(visible=not x), random_seed, seed_val)
-    for ctrl in [steps, size, auto_res]:
-        ctrl.change(estimate_time, [steps, size, auto_res], eta)
+    for ctrl in [steps, resolution]:
+        ctrl.change(estimate_time, [steps, resolution], eta)
 
     btn.click(
         generate,
-        inputs=[prompt_in, size, steps, random_seed, seed_val, auto_res],
+        inputs=[prompt_in, resolution, steps],
         outputs=[gallery, status]
     )