testing_lora / app.py
sanetium's picture
Update app.py
c6bb0ae verified
Raw History Blame Contribute Delete
15.8 kB
"""Qwen-Image-2.1 image edit with stacked LoRAs (single or dual image) on ZeroGPU.
-------------------------------------------------------------------------------------------------------------
Supports:
- Single image edit
- Optional dual-image edit (image1 = main, image2 = reference)
LoRAs stacked:
1. N_lora (NSFW Qwen by TheseAlpacas V2)
2. FV (qwen2_1-femaledVaginus-nsfw-v1_3-fine_L22-31)
Two base-model modes:
* Turbo - Viggle turbo LoRA stacked on top, 6 steps
* Base - plain Qwen-Image-2.1 + the two LoRAs, ~30 steps
"""
import os
os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
import spaces # noqa: E402 - must precede torch
import math # noqa: E402
import random # noqa: E402
import time # noqa: E402
import gradio as gr # noqa: E402
import numpy as np # noqa: E402
import torch # noqa: E402
from diffusers import FlowMatchEulerDiscreteScheduler, QwenImage21Pipeline # noqa: E402
from diffusers.pipelines.qwenimage21.pipeline_qwenimage21 import calculate_dimensions # noqa: E402
from huggingface_hub import hf_hub_download # noqa: E402
from PIL import Image, ImageOps # noqa: E402
from safetensors.torch import load_file # noqa: E402
BASE_MODEL_ID = "Qwen/Qwen-Image-2.1"
# Main NSFW LoRA
LORA_REPO = "sanetium/N_lora_sfw_Qwen"
LORA_FILE = "NSFW Qwen by TheseAlpacas V2.safetensors"
# Second LoRA (FV)
FV_REPO = "sanetium/FV"
FV_FILE = "qwen2_1-femaledVaginus-nsfw-v1_3-fine_L22-31.safetensors"
TURBO_REPO = "Viggle/Qwen-Image-2.1-viggle-turbo"
TURBO_FILE = "Qwen-Image-2.1-viggle-turbo-v0.2.1-6step-lora-r256.safetensors"
MAX_SEED = np.iinfo(np.int32).max
TURBO = "Turbo · Viggle 6-step"
BASE = "Base · Qwen-Image-2.1"
MODES = [TURBO, BASE]
DEFAULT_STEPS = {TURBO: 6, BASE: 30}
RESOLUTIONS = [("1K (1024² area)", 1024), ("1.5K (1536² area)", 1536), ("2K (2048² area, full GPU)", 2048)]
# ----------------------------------------------------------------------------------------
# Models
# ----------------------------------------------------------------------------------------
print("[load] base pipeline ...", flush=True)
pipe = QwenImage21Pipeline.from_pretrained(BASE_MODEL_ID, torch_dtype=torch.bfloat16)
print("[load] N_lora ...", flush=True)
pipe.load_lora_weights(LORA_REPO, weight_name=LORA_FILE, adapter_name="n_lora")
print("[load] FV LoRA ...", flush=True)
pipe.load_lora_weights(FV_REPO, weight_name=FV_FILE, adapter_name="fv")
print("[load] Viggle turbo LoRA ...", flush=True)
pipe.load_lora_weights(TURBO_REPO, weight_name=TURBO_FILE, adapter_name="turbo")
base_scheduler = pipe.scheduler
# The stock config has shift_terminal=0.02, which would wreck turbo's last step.
turbo_scheduler = FlowMatchEulerDiscreteScheduler.from_config(pipe.scheduler.config, shift_terminal=None)
pipe.to("cuda")
# Qwen3-VL's patch embed is a Conv3d with kernel == stride, i.e. a linear map; cuDNN's bf16
# Conv3d fallback costs tens of seconds per reference image. Same result as a matmul.
try:
patch_embed = pipe.text_encoder.model.visual.patch_embed
def _patch_embed_forward(hidden_states):
proj = patch_embed.proj
weight = proj.weight.reshape(proj.weight.shape[0], -1)
return hidden_states.to(weight.dtype).flatten(1) @ weight.T + proj.bias
patch_embed.forward = _patch_embed_forward
except AttributeError as exc:
print(f"[load] patch_embed fast path unavailable: {exc!r}", flush=True)
print("[load] ready", flush=True)
# ----------------------------------------------------------------------------------------
# Helpers
# ----------------------------------------------------------------------------------------
def turbo_sigmas(steps: int):
"""Viggle's raw sigma nodes: keep 0.875/0.75/0.5/0.25, add steps in the 1 -> 0.875 segment."""
steps = min(max(int(steps), 4), 8)
if steps == 4:
return steps, [1.0, 0.75, 0.5, 0.25]
return steps, [1.0 - 0.125 * i / (steps - 4) for i in range(steps - 4)] + [0.875, 0.75, 0.5, 0.25]
def kv_cache_fits(resolution: int, budget_gb: float) -> bool:
prefix_tokens = 2 * (int(resolution) // 16) ** 2
return prefix_tokens * 32 * 2 * 4096 * 2 <= budget_gb * 1e9
def estimate_duration(main_image=None, reference_image=None, base_model=TURBO, resolution=1536,
num_inference_steps=6, *args, **kwargs):
try:
res, steps = int(resolution), int(num_inference_steps)
except (TypeError, ValueError):
res, steps = 1536, 6
if base_model == TURBO:
steps = min(max(steps, 4), 8)
per_step = {1024: 0.65, 1536: 2.0, 2048: 2.6}.get(res, 2.0)
fixed = {1024: 6, 1536: 11, 2048: 9}.get(res, 11)
return int(min(300, math.ceil((fixed + steps * per_step) * 1.15 + 3)))
@torch.no_grad()
def decode_latents(latents, height, width, tile_decode):
"""The pipeline's own decode, with the KV cache freed first and (on the 48 GB slice) a tiled
decode: the untiled VAE decoder upcasts to fp32 and OOMs at 1536² after two 1536² references.
Only the decode is tiled - tiling the reference *encode* is known to degrade edits."""
torch.cuda.empty_cache()
vae = pipe.vae
latents = pipe._unpack_latents(latents, height, width, pipe.vae_scale_factor).to(vae.dtype)
mean = torch.tensor(vae.config.latents_mean).view(1, vae.config.z_dim, 1, 1, 1).to(latents)
std = torch.tensor(vae.config.latents_std).view(1, vae.config.z_dim, 1, 1, 1).to(latents)
latents = latents * std + mean
if tile_decode:
vae.enable_tiling(tile_sample_min_height=1024, tile_sample_min_width=1024,
tile_sample_stride_height=768, tile_sample_stride_width=768)
try:
image = vae.decode(latents, return_dict=False)[0][:, :, 0]
finally:
vae.disable_tiling()
return pipe.image_processor.postprocess(image, output_type="pil")[0]
def _run(main_image, reference_image, base_model, resolution, num_inference_steps,
n_lora_scale, fv_scale, seed, prompt, kv_budget_gb, tile_decode):
res = int(resolution)
if base_model == TURBO:
pipe.set_adapters(
["n_lora", "fv", "turbo"],
adapter_weights=[float(n_lora_scale), float(fv_scale), 1.0]
)
pipe.scheduler = turbo_scheduler
steps, sigmas = turbo_sigmas(num_inference_steps)
else:
pipe.set_adapters(
["n_lora", "fv"],
adapter_weights=[float(n_lora_scale), float(fv_scale)]
)
pipe.scheduler = base_scheduler
steps, sigmas = int(num_inference_steps), None
# Output follows the main image aspect ratio
width, height, _ = calculate_dimensions(res * res, main_image.width / main_image.height)
# Build image list: single or dual
if reference_image is not None:
images = [main_image, reference_image]
else:
images = [main_image]
started = time.perf_counter()
latents = pipe(
prompt=prompt,
image=images,
width=width,
height=height,
output_resolution=res,
num_inference_steps=steps,
sigmas=sigmas,
true_cfg_scale=1.0,
use_kv_cache=kv_cache_fits(res, kv_budget_gb),
generator=torch.Generator(device="cuda").manual_seed(int(seed)),
output_type="latent",
).images
image = decode_latents(latents, height, width, tile_decode)
elapsed = time.perf_counter() - started
print(f"[edit] mode={base_model} res={res} size={image.size} steps={steps} "
f"n_lora={n_lora_scale} fv={fv_scale} images={len(images)} elapsed={elapsed:.1f}s", flush=True)
return image.convert("RGB"), elapsed
@spaces.GPU(duration=estimate_duration)
def _edit_large(main_image, reference_image, base_model, resolution, num_inference_steps,
n_lora_scale, fv_scale, seed, prompt, progress=gr.Progress(track_tqdm=True)):
return _run(main_image, reference_image, base_model, resolution, num_inference_steps,
n_lora_scale, fv_scale, seed, prompt, kv_budget_gb=10.0, tile_decode=True)
@spaces.GPU(duration=estimate_duration, size="xlarge")
def _edit_xlarge(main_image, reference_image, base_model, resolution, num_inference_steps,
n_lora_scale, fv_scale, seed, prompt, progress=gr.Progress(track_tqdm=True)):
return _run(main_image, reference_image, base_model, resolution, num_inference_steps,
n_lora_scale, fv_scale, seed, prompt, kv_budget_gb=30.0, tile_decode=False)
def edit_image(
main_image: Image.Image,
reference_image: Image.Image = None,
base_model: str = TURBO,
resolution: int = 1536,
num_inference_steps: int = 6,
n_lora_scale: float = 1.0,
fv_scale: float = 1.0,
seed: int = 0,
randomize_seed: bool = True,
prompt: str = "",
progress=gr.Progress(track_tqdm=True),
):
"""Edit an image with optional second reference image and two stacked LoRAs.
Args:
main_image: The main image to edit (required).
reference_image: Optional second image (reference / style / identity etc.).
base_model: "Turbo · Viggle 6-step" or "Base · Qwen-Image-2.1".
resolution: Output pixel budget side (1024, 1536 or 2048).
num_inference_steps: Denoising steps (Turbo: 4-8 recommended; Base: ~30).
n_lora_scale: Strength of the main N_lora.
fv_scale: Strength of the FV LoRA.
seed: Random seed.
randomize_seed: Pick a random seed instead of `seed`.
prompt: Your edit instruction (write freely).
Returns:
A (before, after) pair for the slider, and the seed used.
"""
if main_image is None:
raise gr.Error("Please provide at least the main image.")
if base_model not in MODES:
base_model = TURBO
prompt = (prompt or "").strip()
if not prompt:
raise gr.Error("Please write a prompt describing the edit you want.")
main_image = ImageOps.exif_transpose(main_image).convert("RGB")
if reference_image is not None:
reference_image = ImageOps.exif_transpose(reference_image).convert("RGB")
seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
runner = _edit_xlarge if int(resolution) >= 2048 else _edit_large
result, _ = runner(
main_image, reference_image, base_model, int(resolution),
int(num_inference_steps), float(n_lora_scale), float(fv_scale),
seed, prompt, progress
)
return (main_image, result), seed
def on_mode_change(base_model):
if base_model == TURBO:
return gr.update(value=DEFAULT_STEPS[TURBO],
info="Turbo: 6 is the validated schedule (clamped to 4-8; extra steps go to the high-noise end).")
return gr.update(value=DEFAULT_STEPS[BASE],
info="Base: the official pipeline uses ~40-50 Euler steps; 30 is a good trade-off.")
# ----------------------------------------------------------------------------------------
# UI
# ----------------------------------------------------------------------------------------
css = """
#col-container { margin: 0 auto; max-width: 1200px; }
.image-container img { object-fit: contain; }
.dark .gradio-container { color: var(--body-text-color); }
"""
with gr.Blocks(title="N_lora + FV · Qwen-Image-2.1 Edit") as demo:
with gr.Column(elem_id="col-container"):
gr.Markdown(
"# N_lora + FV · Qwen-Image-2.1 Edit\n"
"Single or dual-image editing with two stacked LoRAs on [Qwen-Image-2.1](https://huggingface.co/Qwen/Qwen-Image-2.1):\n\n"
"• **N_lora** – [sanetium/N_lora_sfw_Qwen](https://huggingface.co/sanetium/N_lora_sfw_Qwen)\n"
"• **FV** – [sanetium/FV](https://huggingface.co/sanetium/FV)\n\n"
"• Upload **Main Image** (required)\n"
"• Optionally upload a **Reference Image** for dual-image edit\n"
"• Write your own prompt\n"
"Optionally accelerated with [Viggle turbo](https://huggingface.co/Viggle/Qwen-Image-2.1-viggle-turbo) (6 steps)."
)
with gr.Row():
with gr.Column():
with gr.Row():
main_image = gr.Image(
label="Main Image (required)",
type="pil",
sources=["upload", "clipboard"],
elem_classes="image-container",
height=380,
)
reference_image = gr.Image(
label="Reference Image (optional)",
type="pil",
sources=["upload", "clipboard"],
elem_classes="image-container",
height=380,
)
prompt = gr.Textbox(
label="Prompt",
value="",
lines=4,
placeholder="Describe the edit you want... (e.g. change the background to a beach at sunset, make her wear a red dress, etc.)",
info="Write freely. For dual-image: refer to images as needed in your prompt.",
)
base_model = gr.Radio(
MODES,
value=TURBO,
label="Base model",
info="Turbo: Viggle's 6-step distilled LoRA (~5x faster). Base: higher quality path.",
)
run_button = gr.Button("Generate Edit", variant="primary")
with gr.Accordion("Advanced Settings", open=False):
resolution = gr.Dropdown(
RESOLUTIONS,
value=1536,
label="Resolution",
info="Higher resolutions keep more detail. 2K runs on the full GPU (2x quota).",
)
num_inference_steps = gr.Slider(
label="Inference Steps",
minimum=4,
maximum=50,
step=1,
value=DEFAULT_STEPS[TURBO],
info="Turbo: 6 is the validated schedule (clamped to 4-8).",
)
n_lora_scale = gr.Slider(
label="N_lora strength",
minimum=0.0,
maximum=1.5,
step=0.05,
value=1.0,
)
fv_scale = gr.Slider(
label="FV LoRA strength",
minimum=0.0,
maximum=1.5,
step=0.05,
value=1.0,
)
with gr.Row():
seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0)
randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
with gr.Column():
comparison_slider = gr.ImageSlider(label="Before / After", type="pil", format="png")
seed_output = gr.Number(label="Seed used", interactive=False)
base_model.change(on_mode_change, inputs=base_model, outputs=num_inference_steps)
run_button.click(
edit_image,
inputs=[
main_image,
reference_image,
base_model,
resolution,
num_inference_steps,
n_lora_scale,
fv_scale,
seed,
randomize_seed,
prompt,
],
outputs=[comparison_slider, seed_output],
api_name="edit_image",
)
if __name__ == "__main__":
demo.queue(max_size=20).launch(theme=gr.themes.Citrus(), css=css, mcp_server=True)