Create app-backup.py

app-backup.py

@@ -0,0 +1,270 @@
+import random
+import torch
+import gradio as gr
+import numpy as np
+import spaces
+from diffusers import DiffusionPipeline
+from PIL import Image
+
+# --- [Optional Patch] ---------------------------------------------------------
+# This patch fixes potential JSON schema parsing issues in Gradio/Gradio-Client.
+import gradio_client.utils
+original_json_schema = gradio_client.utils._json_schema_to_python_type
+
+def patched_json_schema(schema, defs=None):
+    # Handle boolean schema directly
+    if isinstance(schema, bool):
+        return "bool"
+    
+    # If 'additionalProperties' is a boolean, replace it with a generic type
+    try:
+        if "additionalProperties" in schema and isinstance(schema["additionalProperties"], bool):
+            schema["additionalProperties"] = {"type": "any"}
+    except (TypeError, KeyError):
+        pass
+    
+    # Attempt to parse normally; fallback to "any" on error
+    try:
+        return original_json_schema(schema, defs)
+    except Exception:
+        return "any"
+
+gradio_client.utils._json_schema_to_python_type = patched_json_schema
+# -----------------------------------------------------------------------------
+
+# ----------------------------- Model Loading ----------------------------------
+device = "cuda" if torch.cuda.is_available() else "cpu"
+repo_id = "black-forest-labs/FLUX.1-dev"
+adapter_id = "openfree/flux-chatgpt-ghibli-lora"
+
+def load_model_with_retry(max_retries=5):
+    for attempt in range(max_retries):
+        try:
+            print(f"Loading model attempt {attempt+1}/{max_retries}...")
+            pipeline = DiffusionPipeline.from_pretrained(
+                repo_id,
+                torch_dtype=torch.bfloat16,
+                use_safetensors=True,
+                resume_download=True
+            )
+            print("Base model loaded successfully, now loading LoRA weights...")
+            pipeline.load_lora_weights(adapter_id)
+            pipeline = pipeline.to(device)
+            print("Pipeline is ready!")
+            return pipeline
+        except Exception as e:
+            if attempt < max_retries - 1:
+                wait_time = 10 * (attempt + 1)
+                print(f"Error loading model: {e}. Retrying in {wait_time} seconds...")
+                import time
+                time.sleep(wait_time)
+            else:
+                raise Exception(f"Failed to load model after {max_retries} attempts: {e}")
+
+pipeline = load_model_with_retry()
+
+# ----------------------------- Inference Function -----------------------------
+MAX_SEED = np.iinfo(np.int32).max
+MAX_IMAGE_SIZE = 1024
+
+@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,
+):
+    # If "randomize_seed" is selected, choose a random seed
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    generator = torch.Generator(device=device).manual_seed(seed)
+
+    try:
+        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]
+        return image, seed
+    except Exception as e:
+        print(f"Error during inference: {e}")
+        # Return a red error image of the specified size and the used seed
+        error_img = Image.new('RGB', (width, height), color='red')
+        return error_img, seed
+
+# ----------------------------- Florence-2 Captioner ---------------------------
+import subprocess
+subprocess.run(
+    'pip install flash-attn --no-build-isolation',
+    env={'FLASH_ATTENTION_SKIP_CUDA_BUILD': "TRUE"},
+    shell=True
+)
+
+from transformers import AutoProcessor, AutoModelForCausalLM
+
+# Pre-load models and processors
+models = {
+    'gokaygokay/Florence-2-Flux-Large': AutoModelForCausalLM.from_pretrained(
+        'gokaygokay/Florence-2-Flux-Large', trust_remote_code=True
+    ).eval(),
+    'gokaygokay/Florence-2-Flux': AutoModelForCausalLM.from_pretrained(
+        'gokaygokay/Florence-2-Flux', trust_remote_code=True
+    ).eval(),
+}
+
+processors = {
+    'gokaygokay/Florence-2-Flux-Large': AutoProcessor.from_pretrained(
+        'gokaygokay/Florence-2-Flux-Large', trust_remote_code=True
+    ),
+    'gokaygokay/Florence-2-Flux': AutoProcessor.from_pretrained(
+        'gokaygokay/Florence-2-Flux', trust_remote_code=True
+    ),
+}
+
+@spaces.GPU
+def caption_image(image, model_name='gokaygokay/Florence-2-Flux-Large'):
+    """
+    Runs the selected Florence-2 model to generate a detailed caption.
+    """
+    from PIL import Image as PILImage
+    
+    task_prompt = "<DESCRIPTION>"
+    user_prompt = task_prompt + "Describe this image in great detail."
+
+    # Convert input to RGB if needed
+    image = PILImage.fromarray(image)
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+
+    model = models[model_name]
+    processor = processors[model_name]
+
+    inputs = processor(text=user_prompt, images=image, return_tensors="pt")
+    generated_ids = model.generate(
+        input_ids=inputs["input_ids"],
+        pixel_values=inputs["pixel_values"],
+        max_new_tokens=1024,
+        num_beams=3,
+        repetition_penalty=1.10,
+    )
+    generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
+    parsed_answer = processor.post_process_generation(
+        generated_text, task=task_prompt, image_size=(image.width, image.height)
+    )
+    return parsed_answer["<DESCRIPTION>"]
+
+# ----------------------------- Gradio UI --------------------------------------
+with gr.Blocks(analytics_enabled=False) as demo:
+    with gr.Tabs():
+        # ------------------ TAB 1: Image Generation ----------------------------
+        with gr.TabItem("FLUX Ghibli LoRA Generator"):
+            gr.Markdown("## Generate an image with the FLUX Ghibli LoRA")
+
+            with gr.Row():
+                with gr.Column():
+                    prompt = gr.Textbox(
+                        label="Prompt",
+                        placeholder="Describe your Ghibli-style image...",
+                        lines=3
+                    )
+                    with gr.Row():
+                        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=512
+                        )
+                        height = gr.Slider(
+                            label="Height",
+                            minimum=256,
+                            maximum=MAX_IMAGE_SIZE,
+                            step=32,
+                            value=512
+                        )
+                    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="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
+                    )
+                    generate_button = gr.Button("Generate Image")
+                
+                with gr.Column():
+                    output_image = gr.Image(label="Generated Image")
+                    output_seed = gr.Number(label="Seed Used")
+
+            # Link the button to the inference function
+            generate_button.click(
+                inference,
+                inputs=[
+                    prompt,
+                    seed,
+                    randomize_seed,
+                    width,
+                    height,
+                    guidance_scale,
+                    num_inference_steps,
+                    lora_scale,
+                ],
+                outputs=[output_image, output_seed]
+            )
+
+        # ------------------ TAB 2: Image Captioning ---------------------------
+        with gr.TabItem("Florence-2 Captioner"):
+            gr.Markdown("## Generate a caption for an uploaded image using Florence-2")
+
+            with gr.Row():
+                with gr.Column():
+                    input_img = gr.Image(label="Upload an Image")
+                    model_selector = gr.Dropdown(
+                        choices=list(models.keys()),
+                        value='gokaygokay/Florence-2-Flux-Large',
+                        label="Select Model"
+                    )
+                    caption_button = gr.Button("Generate Caption")
+                with gr.Column():
+                    caption_output = gr.Textbox(label="Caption")
+
+            caption_button.click(
+                caption_image,
+                inputs=[input_img, model_selector],
+                outputs=[caption_output]
+            )
+
+# Just remove or simplify the queue call if needed:
+
+demo.launch(debug=True)