Upload app.py

app.py

@@ -0,0 +1,120 @@
+import os
+# ZeroGPU runs on MIG slices; torch's expandable-segments allocator makes NVML
+# calls that fail on MIG and surface as "NVML_SUCCESS == r INTERNAL ASSERT
+# FAILED (CUDACachingAllocator)". Must be set before torch is imported.
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:False")
+
+import random
+
+import gradio as gr
+import spaces
+import torch
+from diffusers import Krea2Pipeline
+from transformers import AutoConfig, AutoModel, AutoTokenizer, Qwen2Tokenizer
+
+# ----------------------------------------------------------------------------
+# Krea-R-Turbo = Krea 2 Turbo + RebelReal @ 0.31 + RebelMidjourney @ 0.13
+# LoRAs are fused at startup, so inference cost is identical to the base model.
+# ----------------------------------------------------------------------------
+BASE = "krea/Krea-2-Turbo"
+
+# Krea's repo ships only tokenizer.json (fast format), but the pipeline's
+# model_index declares the slow Qwen2Tokenizer, and diffusers' class check
+# rejects a fast instance. So: load fast (with extra_special_tokens={} to
+# dodge the list-vs-dict bug in transformers 4.x), export it — which writes
+# the vocab.json/merges.txt the slow class needs — then load the slow class
+# from the export. Verified: slow/fast produce identical token ids.
+_fast = AutoTokenizer.from_pretrained(BASE, subfolder="tokenizer",
+                                      use_fast=True, extra_special_tokens={})
+_fast.save_pretrained("/tmp/krea_tokenizer")
+tokenizer = Qwen2Tokenizer.from_pretrained("/tmp/krea_tokenizer",
+                                           extra_special_tokens={})
+
+# Krea's text_encoder config has rope_scaling: null; transformers 4.57's
+# Qwen3-VL calls .get() on it and crashes. Inject the dict with the exact
+# values 4.57 defaults to anyway, so the math is unchanged.
+te_cfg = AutoConfig.from_pretrained(BASE, subfolder="text_encoder")
+_txt = getattr(te_cfg, "text_config", te_cfg)
+if getattr(_txt, "rope_scaling", None) is None:
+    _txt.rope_scaling = {"rope_type": "default", "mrope_section": [24, 20, 20]}
+text_encoder = AutoModel.from_pretrained(BASE, subfolder="text_encoder",
+                                         config=te_cfg, torch_dtype=torch.bfloat16)
+
+pipe = Krea2Pipeline.from_pretrained(BASE, tokenizer=tokenizer,
+                                     text_encoder=text_encoder,
+                                     torch_dtype=torch.bfloat16)
+
+pipe.load_lora_weights("realrebelai/RebelReal_LoRA_Collection",
+                       weight_name="RebelReal_(Krea-2).safetensors",
+                       adapter_name="rebelreal")
+pipe.load_lora_weights("realrebelai/RebelMidjourney_LoRA_Collection",
+                       weight_name="RebelMidjourney_(Krea-2).safetensors",
+                       adapter_name="rebelmj")
+pipe.set_adapters(["rebelreal", "rebelmj"], adapter_weights=[0.31, 0.13])
+# Bake the LoRAs into the weights (same math as an offline merge), then drop
+# the adapter machinery so sampling has zero LoRA overhead.
+pipe.fuse_lora(adapter_names=["rebelreal", "rebelmj"])
+pipe.unload_lora_weights()
+
+pipe.to("cuda")
+# trim peak VRAM: tiled VAE decode costs ~nothing at these resolutions and
+# keeps headroom on the ZeroGPU slice alongside 35 GB of packed weights
+if hasattr(pipe, "vae") and hasattr(pipe.vae, "enable_tiling"):
+    pipe.vae.enable_tiling()
+
+MAX_SEED = 2**31 - 1
+
+
+@spaces.GPU(duration=60)
+def generate(prompt, width, height, steps, seed, randomize_seed,
+             progress=gr.Progress(track_tqdm=True)):
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    generator = torch.Generator("cuda").manual_seed(int(seed))
+    image = pipe(
+        prompt=prompt,
+        width=int(width),
+        height=int(height),
+        num_inference_steps=int(steps),
+        guidance_scale=0.0,          # Turbo is CFG-free
+        generator=generator,
+    ).images[0]
+    return image, seed
+
+
+with gr.Blocks(title="Krea-R-Turbo") as demo:
+    gr.Markdown(
+        """
+        # Krea-R-Turbo
+        **Krea 2 Turbo** with RealRebelAI's **RebelReal** (0.31) and
+        **RebelMidjourney** (0.13) LoRAs fused in. 8-step, CFG-free.
+
+        GGUF quants for local ComfyUI (8 GB VRAM+):
+        [realrebelai/Krea-R-Turbo](https://huggingface.co/realrebelai/Krea-R-Turbo)
+        """
+    )
+    with gr.Row():
+        with gr.Column():
+            prompt = gr.Textbox(label="Prompt", lines=3,
+                                placeholder="a cinematic photo of ...")
+            run = gr.Button("Generate", variant="primary")
+            with gr.Accordion("Settings", open=False):
+                with gr.Row():
+                    width = gr.Slider(512, 2048, value=1280, step=64, label="Width")
+                    height = gr.Slider(512, 2048, value=1024, step=64, label="Height")
+                steps = gr.Slider(4, 12, value=8, step=1, label="Steps")
+                with gr.Row():
+                    seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+                    randomize_seed = gr.Checkbox(value=True, label="Random seed")
+        with gr.Column():
+            out = gr.Image(label="Result", format="png")
+            used_seed = gr.Number(label="Seed used", interactive=False)
+
+    run.click(generate,
+              inputs=[prompt, width, height, steps, seed, randomize_seed],
+              outputs=[out, used_seed])
+    prompt.submit(generate,
+                  inputs=[prompt, width, height, steps, seed, randomize_seed],
+                  outputs=[out, used_seed])
+
+demo.launch()