Upload 4 files

app.py

@@ -0,0 +1,280 @@
+import random
+
+import gradio as gr
+import numpy as np
+import spaces
+import torch
+from diffusers import FluxFillPipeline
+from loras import LoRA, loras
+from PIL import Image
+
+MAX_SEED = np.iinfo(np.int32).max
+
+pipe = FluxFillPipeline.from_pretrained("black-forest-labs/FLUX.1-Fill-dev", torch_dtype=torch.bfloat16)
+
+flux_keywords_available = ["IMG_1025.HEIC", "Selfie"]
+
+# --- LATENT MANIPULATION FUNCTIONS ---
+def pack_latents(latents, batch_size, num_channels, height, width):
+    latents = latents.view(batch_size, num_channels, height // 2, 2, width // 2, 2)
+    latents = latents.permute(0, 2, 4, 1, 3, 5)
+    latents = latents.reshape(batch_size, (height // 2) * (width // 2), num_channels * 4)
+    return latents
+
+
+def unpack_latents(latents, height, width, h_scale=2, w_scale=2):
+    batch_size, seq_len, channels = latents.shape
+    # Flux uses a 2x2 patch, so the factor is 2
+    latents = latents.view(
+        batch_size, height // h_scale, width // w_scale, channels // (h_scale * w_scale), h_scale, w_scale
+    )
+    latents = latents.permute(0, 3, 1, 4, 2, 5)
+    latents = latents.reshape(batch_size, channels // (h_scale * w_scale), height, width)
+    return latents
+
+
+# --- CALLBACK (PRESERVED AREA + STEP CAPTURE) ---
+def get_gradual_blend_callback(
+    pipe, original_image, preserved_area_mask, total_steps, step_images_list, start_alpha=1.0, end_alpha=0.2
+):
+    device = pipe.device
+    dtype = pipe.transformer.dtype
+
+    with torch.no_grad():
+        # Prepare original image
+        img_tensor = (
+            (torch.from_numpy(np.array(original_image).transpose(2, 0, 1)).float() / 127.5 - 1.0)
+            .unsqueeze(0)
+            .to(device, dtype)
+        )
+        init_latents = pipe.vae.encode(img_tensor).latent_dist.sample()
+        init_latents = (init_latents - pipe.vae.config.shift_factor) * pipe.vae.config.scaling_factor
+
+        # Dimensions in latent space
+        _, _, h_latent, w_latent = init_latents.shape
+
+        # Pack original latents (64 channels)
+        packed_init_latents = pack_latents(init_latents, batch_size=1, num_channels=16, height=h_latent, width=w_latent)
+
+        # Prepare and pack the preserved area mask (4 channels)
+        mask_tensor = (
+            (torch.from_numpy(np.array(preserved_area_mask.convert("L"))).float() / 255.0)
+            .unsqueeze(0)
+            .unsqueeze(0)
+            .to(device, dtype)
+        )
+        latent_preserved_mask = torch.nn.functional.interpolate(mask_tensor, size=(h_latent, w_latent), mode="nearest")
+        packed_preserved_mask = pack_latents(
+            latent_preserved_mask, batch_size=1, num_channels=1, height=h_latent, width=w_latent
+        )
+
+    def callback_fn(pipe, step, timestep, callback_kwargs):
+        latents = callback_kwargs["latents"]
+
+        # A. Preserved Area Logic
+        progress = step / max(1, total_steps - 1)
+        current_alpha = start_alpha - (start_alpha - end_alpha) * progress
+
+        # We use .repeat(1, 1, 16) so the 4 mask channels affect the 64 latent channels
+        effective_mask_64 = (packed_preserved_mask * current_alpha).repeat(1, 1, 16)
+        latents = (1 - effective_mask_64) * latents + effective_mask_64 * packed_init_latents
+
+        # B. Step Capture (Save an image every 5 steps to save GPU memory)
+        if step % 5 == 0 or step == total_steps - 1:
+            with torch.no_grad():
+                unpacked = unpack_latents(latents, h_latent, w_latent)
+                unpacked = (unpacked / pipe.vae.config.scaling_factor) + pipe.vae.config.shift_factor
+
+                # Decode and convert to PIL image
+                decoded = pipe.vae.decode(unpacked.to(pipe.vae.dtype)).sample
+                img_step = pipe.image_processor.postprocess(decoded, output_type="pil")[0]
+                step_images_list.append(img_step)
+
+        callback_kwargs["latents"] = latents
+        return callback_kwargs
+
+    return callback_fn
+
+
+# --- LoRA's FUNCTIONS ---
+def activate_loras(pipe: FluxFillPipeline, loras_with_weights: list[tuple[LoRA, float]]):
+    adapter_names = []
+    adapter_weights = []
+    for lora, weight in loras_with_weights:
+        pipe.load_lora_weights(lora.id, weight=weight, adapter_name=lora.name)
+        adapter_names.append(lora.name)
+        adapter_weights.append(weight)
+    pipe.set_adapters(adapter_names, adapter_weights=adapter_weights)
+    return pipe
+
+
+def deactivate_loras(pipe):
+    pipe.unload_lora_weights()
+    return pipe
+
+
+# --- GENERATION
+def calculate_optimal_dimensions(image):
+    original_width, original_height = image.size
+    FIXED_DIMENSION = 1024
+    aspect_ratio = original_width / original_height
+    if aspect_ratio > 1:
+        width, height = FIXED_DIMENSION, round(FIXED_DIMENSION / aspect_ratio)
+    else:
+        height, width = FIXED_DIMENSION, round(FIXED_DIMENSION * aspect_ratio)
+    return (width // 8) * 8, (height // 8) * 8
+
+
+@spaces.GPU(duration=60)
+def inpaint(
+    image,
+    mask,
+    preserved_area_mask=None,
+    prompt: str = "",
+    seed: int = 0,
+    num_inference_steps: int = 28,
+    guidance_scale: int = 50,
+    strength: float = 1.0,
+):
+    image = image.convert("RGB")
+    mask = mask.convert("L")
+    width, height = calculate_optimal_dimensions(image)
+
+    # Resize to match dimensions
+    image_resized = image.resize((width, height), Image.LANCZOS)
+
+    pipe.to("cuda")
+
+    # Setup callback if a preserved area mask is provided
+    step_images = []
+    callback = None
+    if preserved_area_mask is not None:
+        preserved_area_resized = preserved_area_mask.resize((width, height), Image.NEAREST)
+        callback = get_gradual_blend_callback(
+            pipe, image_resized, preserved_area_resized, num_inference_steps, step_images
+        )
+
+    result = pipe(
+        image=image_resized,
+        mask_image=mask.resize((width, height)),
+        prompt=prompt,
+        width=width,
+        height=height,
+        num_inference_steps=num_inference_steps,
+        guidance_scale=guidance_scale,
+        strength=strength,
+        generator=torch.Generator().manual_seed(seed),
+        callback_on_step_end=callback,
+        callback_on_step_end_tensor_inputs=["latents"] if callback else None,
+    ).images[0]
+
+    return result.convert("RGBA"), step_images, prompt, seed
+
+
+def inpaint_api(
+    image,
+    mask,
+    preserved_area_mask,
+    prompt: str,
+    seed: int,
+    num_inference_steps: int,
+    guidance_scale: int,
+    strength: float,
+    flux_keywords: list[str] = None,
+    loras_selected: list[tuple[str, float]] = None,
+):
+    flux_keywords = flux_keywords or []
+    loras_selected = loras_selected or []
+    selected_loras_with_weights = []
+
+    for name, weight_value in loras_selected:
+        try:
+            weight = float(weight_value)
+        except:
+            continue
+        lora_obj = next((l for l in loras if l.display_name == name), None)
+        if lora_obj and weight != 0.0:
+            selected_loras_with_weights.append((lora_obj, weight))
+
+    deactivate_loras(pipe)
+    if selected_loras_with_weights:
+        activate_loras(pipe, selected_loras_with_weights)
+
+    final_prompt = ""
+    if flux_keywords:
+        final_prompt += ", ".join(flux_keywords) + ", "
+    for lora, _ in selected_loras_with_weights:
+        if lora.keyword:
+            final_prompt += (lora.keyword if isinstance(lora.keyword, str) else ", ".join(lora.keyword)) + ", "
+    final_prompt += prompt
+
+    if not isinstance(seed, int) or seed < 0:
+        seed = random.randint(0, MAX_SEED)
+
+    return inpaint(
+        image=image,
+        mask=mask,
+        preserved_area_mask=preserved_area_mask,
+        prompt=final_prompt,
+        seed=seed,
+        num_inference_steps=num_inference_steps,
+        guidance_scale=guidance_scale,
+        strength=strength,
+    )
+
+
+with gr.Blocks(title="FLUX.1 Fill dev + Area Preservation", theme=gr.themes.Soft()) as demo:
+    with gr.Row():
+        with gr.Column(scale=2):
+            prompt_input = gr.Text(label="Prompt", lines=4, value="a 25 years old woman")
+            seed_slider = gr.Slider(label="Seed", minimum=-1, maximum=MAX_SEED, step=1, value=-1)
+            num_inference_steps_input = gr.Number(label="Inference steps", value=40)
+            guidance_scale_input = gr.Number(label="Guidance scale", value=30)
+            strength_input = gr.Number(label="Strength", value=1.0, maximum=1.0)
+
+            gr.Markdown("### Flux Keywords")
+            flux_keywords_input = gr.CheckboxGroup(choices=flux_keywords_available, label="Flux Keywords")
+
+            if loras:
+                gr.Markdown("### Available LoRAs")
+                lora_names = [l.display_name for l in loras]
+                loras_selected_input = gr.Dataframe(
+                    type="array",
+                    headers=["LoRA", "Weight"],
+                    value=[[name, 0.0] for name in lora_names],
+                    datatype=["str", "number"],
+                    interactive=[False, True],
+                    label="LoRA selection",
+                )
+
+        with gr.Column(scale=3):
+            image_input = gr.Image(label="Original Image", type="pil")
+            mask_input = gr.Image(label="Inpaint Mask (Area to change)", type="pil")
+            preserved_area_input = gr.Image(label="Preserved Area Mask (Area to keep)", type="pil")
+            run_btn = gr.Button("Generate", variant="primary")
+
+        with gr.Column(scale=3):
+            result_image = gr.Image(label="Result")
+            used_prompt_box = gr.Text(label="Final Prompt")
+            used_seed_box = gr.Number(label="Used Seed")
+            steps_gallery = gr.Gallery(label="Evolution (Steps)", columns=3, preview=True)
+
+    run_btn.click(
+        fn=inpaint_api,
+        inputs=[
+            image_input,
+            mask_input,
+            preserved_area_input,
+            prompt_input,
+            seed_slider,
+            num_inference_steps_input,
+            guidance_scale_input,
+            strength_input,
+            flux_keywords_input,
+            loras_selected_input,
+        ],
+        outputs=[result_image, steps_gallery, used_prompt_box, used_seed_box],
+    )
+
+if __name__ == "__main__":
+    demo.launch()

loras.py

@@ -0,0 +1,190 @@
+from dataclasses import field
+from typing import List
+
+from pydantic import BaseModel
+
+
+class LoRA(BaseModel):
+
+    id: str
+    name: str
+    display_name: str
+    url: str | None = None
+    keyword: str = None
+    all_keywords: List[str] = field(default_factory=list)
+    note: str | None = None
+
+
+loras = [
+    LoRA(        
+        id="X-HighVoltage-X/Flux-Kontext-Makeup-remover", 
+        name="Flux Kontext Makeup remover", 
+        display_name="Flux Kontext Makeup remover v1.0",
+        keyword="Remove makeup of this person",
+        url="https://civitai.com/models/1859952/flux-kontext-makeup-remover",
+        note=(
+            "This model is a Flux Kontext LoRA trained with the AI-toolkit. "
+            "It was trained on 70 image pairs, with around 80% of them featuring Asian subjects. "
+            "However, since Kontext LoRA learns concepts rather than specific faces, "
+            "it works well with various ethnicities."
+            "I recommend using a LoRA strength of 1 for best results."
+        )
+    ),
+    LoRA(
+        id="black-forest-labs/FLUX.1-Canny-dev-lora", 
+        name="Canny dev LoRA", 
+        display_name="Canny dev LoRA",
+        url="https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev-lora"
+    ),
+    LoRA(
+        id="strangerzonehf/Flux-Super-Realism-LoRA", 
+        name="Super Realism", 
+        display_name="Super Realism",
+        keyword="Super Realism",
+        url="https://huggingface.co/strangerzonehf/Flux-Super-Realism-LoRA",
+        note=(
+            "The trigger word is not mandatory; ensure that words like "
+            'realistic" and "realism" appear in the image description. '
+            'The "super realism" trigger word should prompt an exact match '
+            'to the reference image in the showcase.'
+        )
+    ),
+    LoRA(
+        id="ujouy/Amateur_Photography_FluxDev", 
+        name="Amateur Photography", 
+        display_name="Amateur Photography v6.0",
+        url="https://civitai.com/models/652699/amateur-photography-flux-dev",
+        note=(
+            "Recommended Settings (v6)\n"
+            "Distilled CFG Scale: 3.5\n"
+            "Sampling method and Schedule type: DEIS with DDIM\n"
+            "Steps: 20\n"
+            "Resolution: 896x1152\n"
+            "Hires fix model: 4x_NMKD-Superscale-SP_178000_G\n"
+            "Steps: 10\n"
+            "Denoise: 0.3\n"
+            "Upscale by: 1.5\n"
+            "Lora Weight: 0.8. You have to experiment based on your prompts\n"            
+        )
+        
+    ),
+    LoRA(
+        id="VideoAditor/Flux-Lora-Realism", 
+        name="Flux Lora Realism", 
+        display_name="Flux Lora Realism",
+        url="https://huggingface.co/VideoAditor/Flux-Lora-Realism"
+    ),
+    LoRA(
+        id="strangerzonehf/Flux-SuperPortrait-v2-LoRA", 
+        name="Super Portrait v2", 
+        display_name="Super Portrait v2",
+        keyword="Super Portrait v2",
+        url="https://huggingface.co/strangerzonehf/Flux-SuperPortrait-v2-LoRA",
+        note=(
+            "Best Dimensions & Inference\n"
+            "Dimension: 1280 x 832, Aspect Ratio: 3:2, Recommendation: Best\n"
+            "Dimension: 1024 x 1024, Aspect Ratio: 1:1, Recommendation: Default\n"
+            "Inference Range\n"
+            "Recommended Inference Steps: 30–35"
+        )
+    ),
+    LoRA(
+        id="fofr/kontext-make-person-real", 
+        name="kontext make person real", 
+        display_name="kontext make person real",
+        keyword="make this person look real",
+        url="https://huggingface.co/fofr/kontext-make-person-real"
+    ),
+    LoRA(
+        id="prithivMLmods/Castor-Character-Polygon-Flux-LoRA", 
+        name="Castor Character Polygon Flux LoRA", 
+        display_name="Castor Character Polygon Flux LoRA",
+        keyword="Create a hyper-realistic 3D polygon character portrait of",
+        url="https://huggingface.co/prithivMLmods/Castor-Character-Polygon-Flux-LoRA",
+        note=(
+            "You should use 3D Polygon to trigger the image generation.\n"
+            "You should use 3D Polygon Character to trigger the image generation.\n"
+        )
+    ),
+    LoRA(
+        id="X-HighVoltage-X/chinfixer-2000", 
+        name="Chin Fixer 2000", 
+        display_name="Chin Fixer 2000 v3.0",
+        keyword="ChinFixer-2000 style",
+        url="https://civitai.com/models/775002/chin-fixer-2000",
+        note=(
+            "More trigger words:\n"
+            "chin, cleft chin, jawbone, bottom of head\n"
+            "Try with <lora:Flux\chinfixer-2000.safetensors:1.0:1.0> at the end of prompt"
+        )
+    ),
+    LoRA(
+        id="X-HighVoltage-X/cultures-flux-v3", 
+        name="better faces cultures v3", 
+        display_name="better faces cultures v3",
+        url="https://civitai.com/models/119376?modelVersionId=1228102",
+        notes=(
+            "include a diverse range of cultures and ethnicities.\n"
+            "aborigines, african, arab, arctic, brazilian, chinese, egyptian, finish\n"
+            "german, havaiian, indian, japanese, mongolian, russian, western.\n"
+            "responds to age prompts like __yo for 20yo, 30yo, 40yo.\n"
+            "Weight: start with 0.3"
+        )
+    ),
+    LoRA(
+        id="X-HighVoltage-X/cultures-Portait-FLUX", 
+        name="better faces cultures FLUX Portait", 
+        display_name="better faces cultures FLUX Portait",
+        url="https://civitai.com/models/119376?modelVersionId=779782",
+        notes=(
+            "include a diverse range of cultures and ethnicities.\n"
+            "aborigines, african, arab, arctic, brazilian, chinese, egyptian, finish\n"
+            "german, havaiian, indian, japanese, mongolian, russian, western.\n"
+            "responds to age prompts like __yo for 20yo, 30yo, 40yo.\n"
+            "Weight: start with 0.3"
+        )
+    ),
+    LoRA(
+        id="X-HighVoltage-X/Black-Hair-Blue-Eyes-Pale-Skin-v1.0", 
+        name="Black Hair Blue Eyes Pale Skin v1", 
+        display_name="Black Hair Blue Eyes Pale Skin v1",
+        url="https://civitai.com/models/928269/black-hair-blue-eyes-pale-skin",
+        keyword="BHBEPS"        
+    ),
+    LoRA(
+        id="X-HighVoltage-X/Long-hair-LoRA-V3", 
+        name="Long hair LoRA V3", 
+        display_name="Long hair LoRA V3",
+        url="https://civitai.com/models/669029/long-hair-lora-flux"        
+    ),
+    LoRA(
+        id="X-HighVoltage-X/Long-Hair-beautiful-Blond-v1.0", 
+        name="Long Hair beautiful Blond v1", 
+        display_name="Long Hair beautiful Blond v1",
+        url="https://civitai.com/models/1685872/long-hair-beautiful-blond",
+        keyword="longhairblond1"
+    ),
+    LoRA(
+        id="X-HighVoltage-X/Gabri3lla-TS-v1.0", 
+        name="Gabri3lla TS v1", 
+        display_name="Gabri3lla TS v1",
+        url="https://civitai.com/models/1218749/gabri3lla-ts",
+        keyword="G@bri3ll@ Dark hair"
+    ),
+    LoRA(
+        id="X-HighVoltage-X/Nobody_11-Arabic-Female-Uncensored-v1.0", 
+        name="Nobody_11 - Arabic Female - Uncensored v1", 
+        display_name="Nobody_11 - Arabic Female - Uncensored v1",
+        url="https://civitai.com/models/1762729/nobody11-arabic-female-uncensored-flux1d",
+        keyword="a woman"
+    ),
+
+    
+    LoRA(
+        id="X-HighVoltage-X/No-Shine", name="No Shine", display_name="No Shine"
+    ),
+    LoRA(
+        id="X-HighVoltage-X/sameface-fix-flux-lora", name="SameFace Fix Flux Lora", display_name="SameFace Fix Flux Lora",
+        keyword="woman"
+    ),
+]

readme.md

@@ -0,0 +1,13 @@
+---
+title: Flux.1 Fill Dev Inpainting Super Realism LoRA
+emoji: 📉
+colorFrom: green
+colorTo: gray
+sdk: gradio
+sdk_version: 5.39.0
+app_file: app.py
+pinned: false
+short_description: Flux.1-Fill-dev Inpainting with Super Realism LoRA
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

requirements.txt

@@ -0,0 +1,9 @@
+transformers==4.49
+diffusers==0.35.1
+accelerate
+peft
+spaces
+sentencepiece
+safetensors
+torch
+scipy